<?php

class Bat_EV_SDL extends IPSModule
{
    public function Create()
    {
        parent::Create();

        // Properties
        $this->RegisterPropertyString("Batteries", "[]");
        $this->RegisterPropertyInteger("SDL_Leistung", 0);     // W
        $this->RegisterPropertyInteger("UpdateInterval", 5);   // Minuten

        // Status
        $this->RegisterVariableBoolean("State", "Aktiv", "~Switch", 1);
        $this->EnableAction("State");

        // Prozentwerte
        $this->RegisterVariableFloat("SDL_Pos", "SDL Energie verfügbar (%)", "", 10);
        $this->RegisterVariableFloat("SoC_EV",  "EV Energie verfügbar (%)", "", 11);

        // Leistungsgrenzen
        $this->RegisterVariableFloat("P_SDL_max", "SDL max (W)", "", 20);
        $this->RegisterVariableFloat("P_SDL_laden", "P SDL laden max (W)", "", 21);
        $this->RegisterVariableFloat("P_SDL_entladen", "P SDL entladen max (W)", "", 22);

        $this->RegisterVariableFloat("P_EV_max", "EV max (W)", "", 30);
        $this->RegisterVariableFloat("P_EV_laden", "P EV laden max (W)", "", 31);
        $this->RegisterVariableFloat("P_EV_entladen", "P EV entladen max (W)", "", 32);

        // Debug
        $this->RegisterVariableString("CalcJSON", "Berechnung (JSON)", "", 99);

        // Timer
        $this->RegisterTimer("UpdateTimer", 0, 'GEF_Update($_IPS["TARGET"]);');
    }

    public function ApplyChanges()
    {
        parent::ApplyChanges();

        $intervalMin = (int)$this->ReadPropertyInteger("UpdateInterval");
        $this->SetTimerInterval("UpdateTimer", ($intervalMin > 0) ? $intervalMin * 60 * 1000 : 0);

        $this->Update();
    }

    public function RequestAction($Ident, $Value)
    {
        if ($Ident === "State") {
            SetValue($this->GetIDForIdent("State"), (bool)$Value);
            if ((bool)$Value) {
                $this->Update();
            }
            return;
        }
        throw new Exception("Invalid Ident: " . $Ident);
    }

    public function Update()
    {
        if (!GetValue($this->GetIDForIdent("State"))) {
            return;
        }

        $batteries = json_decode($this->ReadPropertyString("Batteries"), true);
        if (!is_array($batteries)) $batteries = [];

        $sdlTotalW = (float)$this->ReadPropertyInteger("SDL_Leistung"); // W
        if ($sdlTotalW < 0) $sdlTotalW = 0;

        // 30 Minuten Fenster
        $hours = 0.5;

        // Summe Batterie-Leistung
        $sumBatPowerW = 0.0;
        foreach ($batteries as $b) {
            $p = (float)($b["powerbat"] ?? 0);
            if ($p > 0) $sumBatPowerW += $p;
        }

        // Wenn keine Leistung vorhanden → alles 0
        if ($sumBatPowerW <= 0.0) {
            $this->WriteAllZero("sumBatPowerW=0");
            return;
        }

        // SDL kann nicht größer als Gesamtleistung
        if ($sdlTotalW > $sumBatPowerW) $sdlTotalW = $sumBatPowerW;

        // Totale
        $totalCapKWh = 0.0;
        $totalStoredKWh = 0.0;

        $sumSdlPowerW = 0.0;
        $sumEvPowerW  = 0.0;

        $sdlNeedTotalKWh = ($sdlTotalW / 1000.0) * $hours;

        $sumSdlAvailKWh = 0.0; // SDL-Energie, die wirklich geliefert werden kann
        $sumEvKWh       = 0.0; // Restenergie nach SDL-Reservierung

        // Power Limits
        $pSdlChargeW = 0.0;
        $pEvChargeW  = 0.0;

        $pSdlDischargeW = 0.0;
        $pEvDischargeW  = 0.0;

        // Debug JSON
        $calc = [
            "inputs" => [
                "SDL_Leistung_W" => $sdlTotalW,
                "SumBatPower_W"  => $sumBatPowerW,
                "hours"          => $hours
            ],
            "batteries" => []
        ];

        foreach ($batteries as $idx => $b) {
            $pBatW = max(0.0, (float)($b["powerbat"] ?? 0));
            $capKWh = max(0.0, (float)($b["capazity"] ?? 0));
            $socPct = (float)($b["soc"] ?? 0);

            if ($socPct < 0) $socPct = 0;
            if ($socPct > 100) $socPct = 100;

            $totalCapKWh += $capKWh;

            // Energie im Akku
            $storedKWh = $capKWh * ($socPct / 100.0);
            $totalStoredKWh += $storedKWh;

            // SDL-Leistung anteilig verteilen
            $sdlShareW = 0.0;
            if ($pBatW > 0 && $sdlTotalW > 0) {
                $sdlShareW = $sdlTotalW * ($pBatW / $sumBatPowerW);
            }
            // nicht über Batterie-Max
            if ($sdlShareW > $pBatW) $sdlShareW = $pBatW;

            $evShareW = max(0.0, $pBatW - $sdlShareW);

            // Energiebedarf in diesem Zeitfenster
            $sdlNeedKWh = ($sdlShareW / 1000.0) * $hours;

            // Wirklich verfügbare SDL-Energie
            $sdlAvailKWh = min($storedKWh, $sdlNeedKWh);

            // EV Energie ist Rest
            $evKWh = max(0.0, $storedKWh - $sdlAvailKWh);

            // Sammeln
            $sumSdlPowerW += $sdlShareW;
            $sumEvPowerW  += $evShareW;

            $sumSdlAvailKWh += $sdlAvailKWh;
            $sumEvKWh       += $evKWh;

            // Laden (so wie du es willst)
            $pSdlChargeW += $sdlShareW;
            $pEvChargeW  += $evShareW;

            // Entladen: energiebegrenzt für das Zeitfenster!
            // max Leistung aus Energie über 0,5h: P = E/h *1000
            $maxWFromSdlEnergy = ($hours > 0) ? ($sdlAvailKWh / $hours) * 1000.0 : 0.0;
            $maxWFromEvEnergy  = ($hours > 0) ? ($evKWh / $hours) * 1000.0 : 0.0;

            $pSdlDischargeW += min($sdlShareW, $maxWFromSdlEnergy);
            $pEvDischargeW  += min($evShareW,  $maxWFromEvEnergy);

            $calc["batteries"][] = [
                "idx" => $idx,
                "typ" => (string)($b["typ"] ?? ("Bat " . ($idx + 1))),
                "P_bat_W" => round($pBatW, 2),
                "Cap_kWh" => round($capKWh, 4),
                "SoC_pct" => round($socPct, 3),
                "Stored_kWh" => round($storedKWh, 4),

                "SDL_share_W" => round($sdlShareW, 2),
                "EV_share_W"  => round($evShareW, 2),

                "SDL_need_kWh"  => round($sdlNeedKWh, 4),
                "SDL_avail_kWh" => round($sdlAvailKWh, 4),
                "EV_kWh"        => round($evKWh, 4),

                "SDL_discharge_max_W" => round(min($sdlShareW, $maxWFromSdlEnergy), 2),
                "EV_discharge_max_W"  => round(min($evShareW,  $maxWFromEvEnergy), 2),
            ];
        }

        // SDL% = verfügbare SDL Energie / benötigte SDL Energie
        $sdlPosPct = 0.0;
        if ($sdlNeedTotalKWh > 0.000001) {
            $sdlPosPct = ($sumSdlAvailKWh / $sdlNeedTotalKWh) * 100.0;
        }

        // EV%:
        // Deine Skizze ist faktisch: EV verfügbar / EV max
        // EV max interpretieren wir sinnvoll als: SumCap - SDL_need
        // (wenn SDL_need größer ist, wird EV max 0)
        $evMaxKWh = max(0.0, $totalCapKWh - $sdlNeedTotalKWh);
        $evPosPct = 0.0;
        if ($evMaxKWh > 0.000001) {
            $evPosPct = ($sumEvKWh / $evMaxKWh) * 100.0;
        }

        // Werte setzen
        $this->SetIdentValue("SDL_Pos", round($sdlPosPct, 3));
        $this->SetIdentValue("SoC_EV",  round($evPosPct, 3));

        $this->SetIdentValue("P_SDL_max",      round($sumSdlPowerW, 2));
        $this->SetIdentValue("P_SDL_laden",    round($pSdlChargeW, 2));
        $this->SetIdentValue("P_SDL_entladen", round($pSdlDischargeW, 2));

        $this->SetIdentValue("P_EV_max",       round($sumEvPowerW, 2));
        $this->SetIdentValue("P_EV_laden",     round($pEvChargeW, 2));
        $this->SetIdentValue("P_EV_entladen",  round($pEvDischargeW, 2));

        $calc["totals"] = [
            "totalCap_kWh" => round($totalCapKWh, 4),
            "totalStored_kWh" => round($totalStoredKWh, 4),
            "SDL_needTotal_kWh" => round($sdlNeedTotalKWh, 4),
            "SDL_availTotal_kWh" => round($sumSdlAvailKWh, 4),
            "EV_total_kWh" => round($sumEvKWh, 4),
            "SDL_Pos_pct" => round($sdlPosPct, 3),
            "EV_Pos_pct"  => round($evPosPct, 3),

            "P_SDL_sum_W" => round($sumSdlPowerW, 2),
            "P_EV_sum_W"  => round($sumEvPowerW, 2),
            "P_SDL_charge_W" => round($pSdlChargeW, 2),
            "P_SDL_discharge_W" => round($pSdlDischargeW, 2),
            "P_EV_charge_W" => round($pEvChargeW, 2),
            "P_EV_discharge_W" => round($pEvDischargeW, 2),
        ];

        $this->SetIdentValue("CalcJSON", json_encode($calc, JSON_PRETTY_PRINT));
    }

    private function WriteAllZero(string $reason): void
    {
        $this->SetIdentValue("SDL_Pos", 0.0);
        $this->SetIdentValue("SoC_EV", 0.0);

        $this->SetIdentValue("P_SDL_max", 0.0);
        $this->SetIdentValue("P_SDL_laden", 0.0);
        $this->SetIdentValue("P_SDL_entladen", 0.0);

        $this->SetIdentValue("P_EV_max", 0.0);
        $this->SetIdentValue("P_EV_laden", 0.0);
        $this->SetIdentValue("P_EV_entladen", 0.0);

        $this->SetIdentValue("CalcJSON", json_encode(["error" => $reason], JSON_PRETTY_PRINT));
    }

    private function SetIdentValue(string $ident, $value): void
    {
        $id = @$this->GetIDForIdent($ident);
        if ($id <= 0) {
            $this->SendDebug(__FUNCTION__, "Ident nicht gefunden: $ident", 0);
            return;
        }
        SetValue($id, $value);
    }
}