<?php

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

        // Properties
        $this->RegisterPropertyString("Batteries", "[]");
        $this->RegisterPropertyInteger("SDL_Lade_Leistung", 0);
        $this->RegisterPropertyInteger("SDL_Entlade_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_laden", "P SDL laden max (W)", "", 21);
        $this->RegisterVariableFloat("P_SDL_entladen", "P SDL entladen max (W)", "", 22);
        $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 (korrekt: Klassenname_Update)
        $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()
    {
        
        try {

            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;

            $sdlTotalkW = $sdlTotalW / 1000.0;
            """
            */


            //---------------------------------------------

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

            $sdlTotalLadekW = $sdlTotalLadeW / 1000.0;


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

            $sdlTotalEntladekW = $sdlTotalEntladeW / 1000.0;


            if ($sdlTotalLadekW > $sdlTotalEntladekW) {
                    $sdlTotalkW = $sdlTotalLadekW;
                    $mode = 'charge';
                } elseif ($sdlTotalLadekW < $sdlTotalEntladekW) {
                    $sdlTotalkW = $sdlTotalEntladekW;
                    $mode = 'discharge';
                } else {
                    $sdlTotalkW = $sdlTotalEntladekW;
                    $mode = 'equal';
                }

            //---------------------------------------------

            // 30 Minuten Fenster
            $hours = 0.5;

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

            $sumBatPowerkW = $sumBatPowerW / 1000.0;

            $calc = [
                "inputs" => [
                    "SDL_Entlade_Leistung_W" => round($sdlTotalEntladeW, 0),
                    "SDL_Lade_Leistung_W" => round($sdlTotalLadeW, 0),
                    "SumBatPower_W"  => round($sumBatPowerW, 0),
                    "hours"          => $hours
                ],
                "batteries" => [],
                "total" => []
            ];

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

            $real_kWh_ev_ges  = 0.0;
            $real_kWh_sdl_ges = 0.0;

            $SDL_kWh_ges = 0.0;
            $EV_kWh_ges  = 0.0;
            $totalCapKWh = 0.0;

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

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

                $capKWh = max(0.0, (float)($b["capazity"] ?? 0));

                // soc ist SelectVariable -> Variable-ID
                $socVarId = (int)($b["soc"] ?? 0);
                $socPct   = $this->ReadSocPercent($socVarId);

                // Defaults pro Batterie (wichtig, damit nix "hängenbleibt")
                $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;

                // Wenn Kapazität 0 ist: Batterie überspringen (sonst Divisionen/Unsinn)
                if ($capKWh <= 0.0) {
                    $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),
                        "error"     => "capazity=0"
                    ];
                    continue;
                }


                // Deine Logik: SDL/EV Aufteilung über Leistungsanteil

                $sdlShareKW = ($sumBatPowerkW > 0.0) ? ($sdlTotalkW / $sumBatPowerkW * $pBatkW) : 0.0;
                $evShareKW  = $pBatkW - $sdlShareKW;


                if ($mode == 'charge') {
                    $ver = $sdlTotalLadekW / $sdlTotalEntladekW;
                    $underKWh = ($sdlShareKW * $hours) / $ver;
                    $upKWh   = $capKWh - ($sdlShareKW * $hours);
                    
                    $SDL_kWh = $underKWh + $upKWh;
                    $EV_kWH  = max(0.0, $capKWh - $SDL_kWh);
                } elseif ($mode == 'discharge' ) {

                    $ver = $sdlTotalEntladekW / $sdlTotalLadekW;
                    $underKWh   = ($sdlShareKW * $hours) ;
                    $upKWh   = $capKWh - ($sdlShareKW * $hours) / $ver;

                    $SDL_kWh = $underKWh + $upKWh;
                    $EV_kWH  = max(0.0, $capKWh - $SDL_kWh);
                }else {                  
                    // untere Grenze für SDL (wichtig: zuerst setzen, dann clamp)
                    $underKWh = $sdlShareKW * $hours;
                    $underKWh = max(0.0, min($underKWh, $capKWh / 2.0));

                    $upKWh   = $capKWh - $underKWh;
                    $SDL_kWh = 2.0 * $underKWh;
                    $EV_kWH  = max(0.0, $capKWh - $SDL_kWh);
                }   


                $real_kWh = $capKWh / 100.0 * $socPct;

                // --- Deine 3 Fälle (minimal abgesichert, keine Änderung der Grundfunktion) ---
                if ($underKWh <= $real_kWh && $upKWh >= $real_kWh) {

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

                    $sdlDisKW = $sdlShareKW;
                    $evDisKW  = $evShareKW;
                    $sdlChKW  = $sdlShareKW;
                    $evChKW   = $evShareKW;

                    $real_kWh_ev  = $real_kWh - $underKWh;
                    $real_kWh_sdl = $underKWh;

                } elseif ($upKWh < $real_kWh) {

                    $EV_SOC = 100.0;

                    // Division absichern
                    $den = ($capKWh - $real_kWh + $underKWh);
                    $SDL_SOC = ($den > 0.0) ? (  $den / (2.0 * $underKWh) * 100.0) : 0.0;

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

                    $real_kWh_ev  = $capKWh - 2.0 * $underKWh;
                    $real_kWh_sdl = (2.0 * $underKWh) - ($capKWh - $real_kWh);

                } elseif ($underKWh > $real_kWh) {

                    $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;

                } 
                

                // Null/Full Abdeckung (dein Verhalten beibehalten, aber clampen)
                if ($real_kWh <= 0.0) {
                    $sdlDisKW = 0.0;
                    $real_kWh_ev = 0.0;
                    $real_kWh_sdl = 0.0;
                } elseif ($real_kWh >= $capKWh) {
                    $sdlChKW = 0.0;

                    $real_kWh_ev  = $capKWh - 2.0 * $underKWh;
                    $real_kWh_sdl = 2.0 * $underKWh;
                }

                // Negative "real"-kWh verhindern (nur Sicherheit, sonst knallt später %)
                $real_kWh_ev  = max(0.0, $real_kWh_ev);
                $real_kWh_sdl = max(0.0, $real_kWh_sdl);

                // Summen
                $totalCapKWh += $capKWh;

                $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),
                    "Effektive kWh"   => round($real_kWh, 3),

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

                    "EV_kWh"  => round($real_kWh_ev, 3),
                    "SDL_kWh" => round($real_kWh_sdl, 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_Charge_kW"    => round($sdlChKW, 3),
                    "SDL_Discharge_kW" => round($sdlDisKW, 3),
                    "EV_Charge_kW"     => round($evChKW, 3),
                    "EV_Discharge_kW"  => round($evDisKW, 3),
                ];
            }

            // Prozent gesamt (mit Guards)
            $evPosPct  = ($EV_kWh_ges  > 0.0) ? ($real_kWh_ev_ges  / $EV_kWh_ges  * 100.0) : 0.0;
            $sdlPosPct = ($SDL_kWh_ges > 0.0) ? ($real_kWh_sdl_ges / $SDL_kWh_ges * 100.0) : 0.0;

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

            $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_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_pct" => round($SDL_kWh_ges, 3),
                "EV_kWh_pct"  => 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),
                "totalCap_kWh"     => round($totalCapKWh, 3)
            ];

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

        } catch (Throwable $e) {
            // Damit du den echten Fehler siehst (statt -32603)
            $this->SendDebug("Update ERROR", $e->getMessage() . " @ " . $e->getFile() . ":" . $e->getLine(), 0);
            $this->WriteAllZero("Exception: " . $e->getMessage());
        }
    }

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

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

        $this->SetIdentValue("P_SDL_laden", 0.0);
        $this->SetIdentValue("P_SDL_entladen", 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 && !IPS_VariableExists($varId)) {
            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;


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

        return $soc;
    }
}

?>