<?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.0;

        $hours = 0.5; // 30 Minuten

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

        if ($sumBatPowerW <= 0.0) {
            $this->WriteAllZero("sumBatPowerW=0");
            return;
        }

        // Einheiten
        $sdlTotalkW    = $sdlTotalW / 1000.0;
        $sumBatPowerkW = $sumBatPowerW / 1000.0;

        // Totals (dein Modell)
        $totalCapKWh        = 0.0;

        $real_kWh_ev_ges    = 0.0;
        $real_kWh_sdl_ges   = 0.0;

        $SDL_kWh_ges        = 0.0; // Summe (2*under)
        $EV_kWh_ges         = 0.0; // Summe (cap - 2*under)

        $sdlDisKW_ges       = 0.0;
        $evDisKW_ges        = 0.0;
        $sdlChKW_ges        = 0.0;
        $evChKW_ges         = 0.0;

        $pSDLmaxKW_ges      = 0.0; // Summe SDL-Anteile (kW)
        $pEVmaxKW_ges       = 0.0; // Summe EV-Anteile  (kW)

        $calc = [
            "inputs" => [
                "SDL_Leistung_W" => round($sdlTotalW, 0),
                "SumBatPower_W"  => round($sumBatPowerW, 0),
                "hours"          => $hours
            ],
            "batteries" => [],
            "total" => []
        ];

        foreach ($batteries as $idx => $b) {

            // pro Batterie reset
            $EV_SOC = 0.0;
            $SDL_SOC = 0.0;

            $sdlDisKW = 0.0;
            $evDisKW  = 0.0;
            $sdlChKW  = 0.0;
            $evChKW   = 0.0;

            $real_kWh_ev  = 0.0;
            $real_kWh_sdl = 0.0;

            // Eingaben
            $pBatW  = max(0.0, (float)($b["powerbat"] ?? 0));
            $pBatkW = $pBatW / 1000.0;
            $capKWh = max(0.0, (float)($b["capazity"] ?? 0));

            $socVarId = (int)($b["soc"] ?? 0);
            $socPct   = (float)$this->ReadSocPercent($socVarId);

            if ($socPct < 0.0) $socPct = 0.0;
            if ($socPct > 100.0) $socPct = 100.0;

            $totalCapKWh += $capKWh;

            // SDL/EV Power Verteilung (proportional nach Leistung)
            $sdlShareKW = ($sumBatPowerkW > 0.0) ? ($sdlTotalkW / $sumBatPowerkW * $pBatkW) : 0.0;
            if ($sdlShareKW < 0.0) $sdlShareKW = 0.0;
            if ($sdlShareKW > $pBatkW) $sdlShareKW = $pBatkW;

            $evShareKW = max(0.0, $pBatkW - $sdlShareKW);

            // Grenzen / Zonen
            $underKWh = $sdlShareKW * $hours;            // SDL Reserve für 30min
            $upKWh    = $capKWh - $underKWh;             // obere Grenze (deine Definition)

            $SDL_kWh  = 2.0 * $underKWh;                 // SDL-Zonenbreite
            $EV_kWh   = $capKWh - 2.0 * $underKWh;       // EV-Zonenbreite
            if ($EV_kWh < 0.0) $EV_kWh = 0.0;

            $real_kWh = $capKWh * ($socPct / 100.0);     // aktueller Inhalt

            // Zonenlogik
            if ($real_kWh <= $underKWh) {
                // untere Zone: EV = 0
                $EV_SOC = 0.0;
                $den = 2.0 * $underKWh;
                $SDL_SOC = ($den > 0.0) ? ($real_kWh * 100.0 / $den) : 0.0;

                $sdlDisKW = $sdlShareKW;
                $evDisKW  = 0.0;

                $sdlChKW = $sdlShareKW;
                $evChKW  = $evShareKW;

                $real_kWh_ev  = 0.0;
                $real_kWh_sdl = $real_kWh;
            } elseif ($real_kWh < $upKWh) {
                // mittlere Zone: SDL fix 50, EV wächst
                $SDL_SOC = 50.0;

                // EV_SOC bezogen auf EV_kWh (wenn du lieber capKWh willst: / $capKWh)
                $EV_SOC = ($EV_kWh > 0.0) ? (($real_kWh - $underKWh) * 100.0 / $EV_kWh) : 0.0;
                if ($EV_SOC < 0.0) $EV_SOC = 0.0;
                if ($EV_SOC > 100.0) $EV_SOC = 100.0;

                $sdlDisKW = $sdlShareKW;
                $evDisKW  = $evShareKW;

                $sdlChKW = $sdlShareKW;
                $evChKW  = $evShareKW;

                $real_kWh_ev  = $real_kWh - $underKWh;
                $real_kWh_sdl = $underKWh;
            } else {
                // obere Zone: EV voll, SDL wächst
                $EV_SOC = 100.0;

                $SDL_SOC = ($underKWh > 0.0)
                    ? (50.0 + (($real_kWh - $upKWh) * 50.0 / $underKWh))
                    : 100.0;

                if ($SDL_SOC < 0.0) $SDL_SOC = 0.0;
                if ($SDL_SOC > 100.0) $SDL_SOC = 100.0;

                $sdlDisKW = $sdlShareKW;
                $evDisKW  = $evShareKW;

                $sdlChKW = $sdlShareKW;
                $evChKW  = 0.0;

                $real_kWh_ev  = max(0.0, $real_kWh - 2.0*$underKWh);
                $real_kWh_sdl = min($SDL_kWh, $real_kWh);
            }

            // leer/voll Sicherheitskorrektur
            if ($real_kWh <= 0.000001) {
                $sdlDisKW = 0.0;
                $evDisKW  = 0.0;
                $real_kWh_ev  = 0.0;
                $real_kWh_sdl = 0.0;
                $EV_SOC = 0.0;
                $SDL_SOC = 0.0;
            }

            if ($capKWh > 0.0 && $real_kWh >= $capKWh - 0.000001) {
                $sdlChKW = 0.0;
                $evChKW  = 0.0;

                $real_kWh_ev  = $EV_kWh;
                $real_kWh_sdl = $SDL_kWh;
                $EV_SOC = 100.0;
                $SDL_SOC = 100.0;
            }

            // Totals
            $pSDLmaxKW_ges += $sdlShareKW;
            $pEVmaxKW_ges  += $evShareKW;

            $sdlDisKW_ges += $sdlDisKW;
            $evDisKW_ges  += $evDisKW;
            $sdlChKW_ges  += $sdlChKW;
            $evChKW_ges   += $evChKW;

            $real_kWh_ev_ges  += $real_kWh_ev;
            $real_kWh_sdl_ges += $real_kWh_sdl;

            $SDL_kWh_ges += $SDL_kWh;
            $EV_kWh_ges  += $EV_kWh;

            // Debug pro Batterie
            $calc["batteries"][] = [
                "idx" => $idx,
                "typ" => (string)($b["typ"] ?? ("Bat " . ($idx + 1))),

                "P_bat_W" => round($pBatW, 0),
                "Cap_kWh" => round($capKWh, 3),

                "SoC_varId" => $socVarId,
                "SoC_pct"   => round($socPct, 3),

                "real_kWh" => round($real_kWh, 3),

                "SDL_Power_kW" => round($sdlShareKW, 3),
                "EV_Power_kW"  => round($evShareKW, 3),

                "under_grenze_kWh" => round($underKWh, 3),
                "up_grenze_kWh"    => round($upKWh, 3),

                "SDL_kWh_zone" => round($SDL_kWh, 3),
                "EV_kWh_zone"  => round($EV_kWh, 3),

                "SDL_SOC" => round($SDL_SOC, 3),
                "EV_SOC"  => round($EV_SOC, 3),

                "SDL_kWh" => round($real_kWh_sdl, 3),
                "EV_kWh"  => round($real_kWh_ev, 3),

                "SDL_Charge_kW"    => round($sdlChKW, 3),
                "SDL_Discharge_kW" => round($sdlDisKW, 3),

                "EV_Charge_kW"     => round($evChKW, 3),
                "EV_Discharge_kW"  => round($evDisKW, 3),
            ];
        }

        // Prozentwerte nach deinem Ansatz (Division absichern!)
        $evPosPct  = ($EV_kWh_ges  > 0.000001) ? ($real_kWh_ev_ges  * 100.0 / $EV_kWh_ges)  : 0.0;
        $sdlPosPct = ($SDL_kWh_ges > 0.000001) ? ($real_kWh_sdl_ges * 100.0 / $SDL_kWh_ges) : 0.0;

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

        // Leistungsvariablen (in W)
        $this->SetIdentValue("P_SDL_max",      round($pSDLmaxKW_ges * 1000.0, 0));
        $this->SetIdentValue("P_SDL_laden",    round($sdlChKW_ges   * 1000.0, 0));
        $this->SetIdentValue("P_SDL_entladen", round($sdlDisKW_ges  * 1000.0, 0));

        $this->SetIdentValue("P_EV_max",       round($pEVmaxKW_ges  * 1000.0, 0));
        $this->SetIdentValue("P_EV_laden",     round($evChKW_ges    * 1000.0, 0));
        $this->SetIdentValue("P_EV_entladen",  round($evDisKW_ges   * 1000.0, 0));

        $calc["total"] = [
            "SDL_SoC_pct" => round($sdlPosPct, 3),
            "EV_SoC_pct"  => round($evPosPct, 3),

            "SDL_kWh_total" => round($real_kWh_sdl_ges, 3),
            "EV_kWh_total"  => round($real_kWh_ev_ges, 3),

            "SDL_kWh_zone_total" => round($SDL_kWh_ges, 3),
            "EV_kWh_zone_total"  => round($EV_kWh_ges, 3),

            "SDL_Charge_kW"    => round($sdlChKW_ges, 3),
            "SDL_Discharge_kW" => round($sdlDisKW_ges, 3),

            "EV_Charge_kW"     => round($evChKW_ges, 3),
            "EV_Discharge_kW"  => round($evDisKW_ges, 3),

            "P_SDL_max_kW" => round($pSDLmaxKW_ges, 3),
            "P_EV_max_kW"  => round($pEVmaxKW_ges, 3),

            "totalCap_kWh" => round($totalCapKWh, 3)
        ];

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

    // ---------------- Helpers ----------------

    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);
    }

    private function ReadSocPercent(int $varId): float
    {
        // Falls jemand statt Variable direkt 0..100 einträgt
        if ($varId >= 0 && $varId <= 100) {
            return (float)$varId;
        }

        if ($varId <= 0 || !IPS_VariableExists($varId)) {
            return 0.0;
        }

        $v = GetValue($varId);
        if (!is_numeric($v)) {
            return 0.0;
        }

        $soc = (float)$v;

        // 0..1 -> 0..100 (Achtung: wenn dein Sensor 1 = 1% liefert, muss das raus!)
        if ($soc >= 0.0 && $soc <= 1.0) {
            $soc *= 100.0;
        }

        if ($soc < 0.0) $soc = 0.0;
        if ($soc > 100.0) $soc = 100.0;

        return $soc;
    }
}
?>