import json
from datetime import datetime
from flask import request, jsonify
from database import get_db_connection, init_db

def berechne_budget(data):

    pflegegrad = int(data.get("pflegegrad", 2) or 2)

    uebertrag_entlastung = float(data.get("uebertrag_entlastung", 0) or 0)

    # -------------------------------
    # DATUM / STICHTAG
    # -------------------------------

    heute = datetime.today()
    jahr = heute.year
    stichtag = datetime(jahr, 6, 30)

    vorjahr_gueltig = heute <= stichtag

    # 🔥 Trennung Anzeige vs. Berechnung
    uebertrag_entlastung_anzeige = uebertrag_entlastung if vorjahr_gueltig else None
    uebertrag_entlastung_berechnung = uebertrag_entlastung if vorjahr_gueltig else 0

    # -------------------------------
    # GRUNDWERTE
    # -------------------------------

    pflegegeld_map = {1: 0, 2: 347, 3: 599, 4: 800, 5: 990}
    sachleistung_map = {1: 0, 2: 796, 3: 1497, 4: 1859, 5: 2299}

    pflegegeld = pflegegeld_map.get(pflegegrad, 0)
    sachleistung = sachleistung_map.get(pflegegrad, 0)

    entlastung = 131
    verhinderung_jahr = 3539

    stundensatz = float(data.get("stundensatz", 39.5) or 39.5)

    # -------------------------------
    # VERBRAUCH (BESTAND)
    # -------------------------------

    verbrauch_entlastung_jahr = float(data.get("verbrauch_entlastung", 0) or 0)
    verbrauch_entlastung_monat = float(data.get("verbrauch_entlastung_monat", 0) or 0)

    verbrauch_sachleistung_monat = float(data.get("verbrauch_sachleistung_monat", 0) or 0)
    verbrauch_umwandlung_monat = float(data.get("verbrauch_umwandlung_monat", 0) or 0)

    verbrauch_verhinderung_monat = float(data.get("verbrauch_verhinderung_monat", 0) or 0)
    verbrauch_verhinderung_jahr = float(data.get("verbrauch_verhinderung", 0) or 0)

    # -------------------------------
    # 🔥 EINSÄTZE AUSWERTEN
    # -------------------------------

    einsaetze = data.get("einsaetze", []) or []

    verbrauch_zukunft_map = {
        "Entlastungsbetrag": 0,
        "Umwandlung": 0,
        "Verhinderungspflege": 0,
        "Pflegegeld": 0
    }

    for e in einsaetze:
        topf = e.get("topf")
        betrag = float(e.get("betrag", 0) or 0)

        if topf in verbrauch_zukunft_map:
            verbrauch_zukunft_map[topf] += betrag

    # -------------------------------
    # 🔥 ENTLASTUNGSBETRAG LOGIK (FIX)
    # -------------------------------

    rest_monate = max(12 - heute.month + 1, 1)

    verbrauch_entlastung_plan = verbrauch_entlastung_monat * rest_monate

    rest_vorjahr_nach_bisher = max(
        uebertrag_entlastung_berechnung - verbrauch_entlastung_jahr,
        0
    )

    verbrauch_laufendes_jahr_bisher = max(
        verbrauch_entlastung_jahr - uebertrag_entlastung_berechnung,
        0
    )

    verbrauch_aus_vorjahr_plan = min(
        rest_vorjahr_nach_bisher,
        verbrauch_entlastung_plan
    )

    rest_vorjahr_final = rest_vorjahr_nach_bisher - verbrauch_aus_vorjahr_plan

    verbrauch_laufendes_jahr_plan = (
        verbrauch_entlastung_plan - verbrauch_aus_vorjahr_plan
    )

    verbrauch_laufendes_jahr_gesamt = (
        verbrauch_laufendes_jahr_bisher + verbrauch_laufendes_jahr_plan
    )

    budget_laufendes_jahr = entlastung * 12

    rest_laufendes_jahr = max(
        budget_laufendes_jahr - verbrauch_laufendes_jahr_gesamt,
        0
    )

    rest_monat_entlastung = max(
        entlastung - verbrauch_entlastung_monat,
        0
    )

    rest_jahr_entlastung = rest_vorjahr_final + rest_laufendes_jahr

    # -------------------------------
    # MONATSVERLAUF
    # -------------------------------

    monatsverlauf = []
    rest = uebertrag_entlastung_berechnung

    for m in range(heute.month, 13):

        budget = entlastung + (rest if m == heute.month else 0)

        verbrauch = verbrauch_entlastung_monat

        rest = max(budget - verbrauch, 0)

        monatsverlauf.append({
            "monat": m,
            "budget": budget,
            "verbrauch": verbrauch,
            "rest": rest
        })

    # -------------------------------
    # UMWANDLUNG (FIX E/F)
    # -------------------------------

    freie_sachleistung = max(sachleistung - verbrauch_sachleistung_monat, 0)
    umwandlung_monat = round(freie_sachleistung * 0.4, 2)

    umwandlung_verbrauch_gesamt = (
        verbrauch_umwandlung_monat + verbrauch_zukunft_map["Umwandlung"]
    )

    umwandlung_rest = max(
        umwandlung_monat - umwandlung_verbrauch_gesamt,
        0
    )

    # -------------------------------
    # 🔥 VERHINDERUNGSPFLEGE FIX
    # -------------------------------

    rest_jahr_verhinderung_start = max(
        verhinderung_jahr - verbrauch_verhinderung_jahr,
        0
    )

    verbrauch_verhinderung_plan = verbrauch_verhinderung_monat * rest_monate

    verbrauch_verhinderung_zukunft = min(
        rest_jahr_verhinderung_start,
        verbrauch_verhinderung_plan
    )

    rest_jahr_verhinderung = max(
        rest_jahr_verhinderung_start - verbrauch_verhinderung_zukunft,
        0
    )

    rest_monat_verhinderung = max(
        verhinderung_jahr / 12 - verbrauch_verhinderung_monat,
        0
    )

    # -------------------------------
    # STUNDENFORMAT
    # -------------------------------

    def format_stunden(budget):
        if not budget or not stundensatz:
            return "–"

        minuten_total = int(round((budget / stundensatz) * 60 / 15) * 15)
        std = minuten_total // 60
        min_rest = minuten_total % 60

        return f"{std} Std. {min_rest:02d} Min."

    # -------------------------------
    # ZEILEN (FIX B C D)
    # -------------------------------

    zeilen = [

        {
            "topf": "Pflegegeld",
            "monat": pflegegeld,
            "jahr": pflegegeld * 12,
            "monat_origin": True,
            "jahr_origin": False,
            "gruppe": None,
            "uebertrag": None,
            "verbrauch_monat": None,
            "verbrauch_jahr": None,
            "verbrauch_zukunft": None,
            "rest_monat": None,
            "rest_jahr": pflegegeld * (12 - heute.month + 1),
            "stunden_monat": None,
            "stunden_jahr": None,
            "hinweis": "kein Stundenbudget / Bar-Auszahlung"
        },

        {
            "topf": "Entlastungsbetrag",
            "monat": entlastung,
            "jahr": entlastung * 12,
            "monat_origin": True,
            "jahr_origin": False,
            "gruppe": None,
            "uebertrag": uebertrag_entlastung_anzeige,
            "verbrauch_monat": verbrauch_entlastung_monat,
            "verbrauch_jahr": verbrauch_entlastung_jahr,
            "verbrauch_zukunft": verbrauch_entlastung_plan,
            "rest_monat": rest_monat_entlastung,
            "rest_jahr": rest_jahr_entlastung,
            "stunden_monat": format_stunden(rest_monat_entlastung),
            "stunden_jahr": format_stunden(rest_jahr_entlastung),
            "hinweis": f"inkl. Übertrag bis 30.06. | Vorjahr Rest: {round(rest_vorjahr_final,2)} €"
        },

        {
            "topf": "Sachleistung",
            "monat": sachleistung,
            "jahr": None,
            "monat_origin": True,
            "jahr_origin": False,
            "gruppe": "sachleistung",
            "uebertrag": None,
            "verbrauch_monat": verbrauch_sachleistung_monat,
            "verbrauch_jahr": None,
            "verbrauch_zukunft": None,
            "rest_monat": max(sachleistung - verbrauch_sachleistung_monat, 0),
            "rest_jahr": None,
            "stunden_monat": None,
            "stunden_jahr": None,
            "hinweis": "nur Grundlage (monatlich)"
        },

        {
            "topf": "↳ Umwandlung (40%)",
            "monat": umwandlung_monat,
            "jahr": None,
            "monat_origin": False,
            "jahr_origin": False,
            "gruppe": "umwandlung",
            "uebertrag": None,
            "verbrauch_monat": umwandlung_verbrauch_gesamt,
            "verbrauch_jahr": None,
            "verbrauch_zukunft": None,
            "rest_monat": umwandlung_rest,
            "rest_jahr": None,
            "stunden_monat": format_stunden(umwandlung_rest),
            "stunden_jahr": None,
            "hinweis": "abhängig von freier Sachleistung"
        },

        {
            "topf": "Verhinderungspflege",
            "monat": verhinderung_jahr / 12,
            "jahr": verhinderung_jahr,
            "monat_origin": False,
            "jahr_origin": True,
            "gruppe": None,
            "uebertrag": None,
            "verbrauch_monat": verbrauch_verhinderung_monat,
            "verbrauch_jahr": verbrauch_verhinderung_jahr,
            "verbrauch_zukunft": verbrauch_verhinderung_zukunft,
            "rest_monat": rest_monat_verhinderung,
            "rest_jahr": rest_jahr_verhinderung,
            "stunden_monat": format_stunden(rest_monat_verhinderung),
            "stunden_jahr": format_stunden(rest_jahr_verhinderung),
            "hinweis": "Jahresbudget (§42a SGB XI)"
        }
    ]

    # -------------------------------
    # SUMMEN
    # -------------------------------

    def summe_stunden(values):
        minuten = 0
        for v in values:
            if not v or v == "–":
                continue
            parts = v.split()
            std = int(parts[0])
            min_rest = int(parts[2])
            minuten += std * 60 + min_rest

        std = minuten // 60
        min_rest = minuten % 60
        return f"{std} Std. {min_rest:02d} Min."

    sum_monat = summe_stunden([z["stunden_monat"] for z in zeilen])
    sum_jahr = summe_stunden([z["stunden_jahr"] for z in zeilen])

    return {
        "zeilen": zeilen,
        "summe_stunden_monat": sum_monat,
        "summe_stunden_jahr": sum_jahr,
        "einsatzzeilen": [],
        "monatsverlauf": monatsverlauf
    }