<?php

class Bat_EV_SDL_V2 extends IPSModule
{
    private const HOURS = 0.5; // 30 Minuten

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

        // Properties
        $this->RegisterPropertyString("Batteries", "[]");
        //$this->RegisterPropertyInteger("$upKWh + $underKWh)", 0);   
        $this->RegisterPropertyInteger("SDL_Leistung_Laden", 0);  
        $this->RegisterPropertyInteger("SDL_Leistung_Entladen", 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("Nennleistung_Soll_EV",  "Nennleistung Soll EV",  "", 2);
        $this->RegisterVariableFloat("Nennleistung_Soll_SDL", "Nennleistung Soll SDL", "", 3);
        $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: wichtig -> Prefix muss passen
        $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);

        // Cache neu bauen (force)
        $this->BuildBatteryCache(true);

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

            // Cache nur neu bauen, wenn nötig
            $this->BuildBatteryCache(false);

            $cache = json_decode($this->GetBufferSafe("BatCacheJSON"), true);
            if (!is_array($cache) || empty($cache["bats"])) {
                $this->WriteAllZero("cache empty/invalid");
                return;
            }

            $calc = [
                "inputs" => $cache["inputs"] ?? [],
                "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 ($cache["bats"] as $i => $c) {

                $capKWh = (float)($c["capKWh"] ?? 0.0);
                if ($capKWh <= 0.0) {
                    continue;
                }

                // dynamisch: SoC lesen
                $socVarId = (int)($c["socVarId"] ?? 0);
                $socPct   = $this->ReadSocPercent($socVarId);

                $real_kWh = $capKWh / 100.0 * $socPct;

                // vorkalkuliert:
                $typ        = (string)($c["typ"] ?? ("Bat " . ($i + 1)));
                $underKWh   = (float)($c["underKWh"] ?? 0.0);
                $upKWh      = (float)($c["upKWh"] ?? 0.0);
                $SDL_kWh    = (float)($c["SDL_kWh_total"] ?? 0.0);
                $EV_kWh     = (float)($c["EV_kWh_total"] ?? 0.0);

                $sdlShareKW_laden = (float)($c["sdlShareKW_laden"] ?? 0.0);
                $sdlShareKW_entladen = (float)($c["sdlShareKW_entladen"] ?? 0.0);
                $evShareKW_laden  = (float)($c["evShareKW_laden"] ?? 0.0);
                $evShareKW_entladen  = (float)($c["evShareKW_entladen"] ?? 0.0);


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

                // --- Deine 3 Fälle ---
                if ($underKWh <= $real_kWh && $upKWh >= $real_kWh) {

                    $SDL_SOC = 100 / ($capKWh - $upKWh + $underKWh) * $underKWh;
                    $EV_SOC = 100 / $EV_kWh * ($real_kWh - $underKWh);
                    
                    IPS_LogMessage("Bat_EV_SDL", $real_kWh);

                    $sdlDisKW = $sdlShareKW_entladen;
                    $evDisKW  = $evShareKW_entladen;
                    $sdlChKW  = $sdlShareKW_laden;
                    $evChKW   = $evShareKW_laden;

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

                } elseif ($upKWh < $real_kWh) {

                    $EV_SOC = 100.0;

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

                    $sdlDisKW = $sdlShareKW_entladen;
                    $evDisKW  = $evShareKW_entladen;
                    $sdlChKW  = $sdlShareKW_laden;
                    $evChKW   = 0.0;

                    $real_kWh_ev  = $capKWh - ($capKWh - $upKWh + $underKWh);
                    $real_kWh_sdl = ($capKWh - $upKWh + $underKWh) - ($capKWh - $real_kWh);

                } elseif ($underKWh > $real_kWh) {

                    $EV_SOC = 0.0;

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

                    $sdlDisKW = $sdlShareKW_entladen;
                    $evDisKW  = 0.0;
                    $sdlChKW  = $sdlShareKW_laden;
                    $evChKW   = $evShareKW_laden;

                    $real_kWh_ev  = 0.0;
                    $real_kWh_sdl = $real_kWh;
                }

                // Null/Full
                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 - ($upKWh + $underKWh);
                    $real_kWh_sdl = $upKWh + $underKWh;
                }

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

                $calc["batteries"][] = [
                    "idx" => $c["idx"] ?? $i,
                    "typ" => $typ,
                    "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),

                    "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),
                ];
            }

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

            $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_total" => round($SDL_kWh_ges, 3),
                "EV_kWh_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),

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

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


        } catch (Throwable $e) {
            $this->SendDebug("Update ERROR", $e->getMessage() . " @ " . $e->getFile() . ":" . $e->getLine(), 0);
            $this->WriteAllZero("Exception: " . $e->getMessage());
        }
    }

    private function BuildBatteryCache(bool $force): void
    {
        $batteriesRaw = $this->ReadPropertyString("Batteries");
        //$sdlTotalW    = max(0, (int)$this->ReadPropertyInteger("SDL_Leistung"));
        $sdlTotalW_laden    = max(0, (int)$this->ReadPropertyInteger("SDL_Leistung_Laden"));
        $sdlTotalW_entladen    = max(0, (int)$this->ReadPropertyInteger("SDL_Leistung_Entladen"));
        $hours        = self::HOURS;

        $hash = md5(json_encode([
            "Batteries" => $batteriesRaw,
            "SDL_W_Laden"     => $sdlTotalW_laden,
            "SDL_W_Entladen"  => $sdlTotalW_entladen,
            "hours"     => $hours
        ]));

        $oldHash = $this->GetBufferSafe("BatCacheHash");
        if (!$force && $oldHash === $hash) {
            return;
        }

        $batteries = json_decode($batteriesRaw, true);
        if (!is_array($batteries)) $batteries = [];

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

        $cache = [
            "inputs" => [
                "SDL_Leistung_W_laden" => $sdlTotalW_laden,
                "SDL_Leistung_W_entladen" => $sdlTotalW_entladen,
                "SumBatPower_W"  => round($sumBatPowerW, 0),
                "hours"          => $hours
            ],
            "bats" => []
        ];

        if ($sumBatPowerW <= 0.0) {
            $this->SetBuffer("BatCacheHash", $hash);
            $this->SetBuffer("BatCacheJSON", json_encode($cache));
            $this->SendDebug("Cache", "sumBatPowerW=0 -> empty cache", 0);
            return;
        }

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

        $sdlTotalkW_laden    = $sdlTotalW_laden / 1000.0;
        $sdlTotalkW_entladen = $sdlTotalW_entladen / 1000.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));
            if ($capKWh <= 0.0) continue;

            $socVarId = (int)($b["soc"] ?? 0);
            $typ      = (string)($b["typ"] ?? ("Bat " . ($idx + 1)));

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

            $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);
            */

            //  Mit laden und entladen unterschiedlich
            //----------------------------------------------------
            $sdlShareKW_laden = ($sumBatPowerkW > 0.0) ? ($sdlTotalkW_laden / $sumBatPowerkW * $pBatkW) : 0.0;
            $evShareKW_laden = $pBatkW - $sdlShareKW_laden;
            $upKWh = $capKWh - $sdlShareKW_laden * 0.5;

            $sdlShareKW_entladen = ($sumBatPowerkW > 0.0) ? ($sdlTotalkW_entladen / $sumBatPowerkW * $pBatkW) : 0.0;
            $evShareKW_entladen = $pBatkW - $sdlShareKW_entladen;
            $underKWh = $sdlShareKW_entladen * 0.5;

            $SDL_kWh = $underKWh + ($capKWh -$upKWh);
            $EV_kWh = $capKWh - $SDL_kWh;
            //----------------------------------------------------

            $cache["bats"][] = [
                "idx" => $idx,
                "typ" => $typ,

                "socVarId" => $socVarId,
                "capKWh"   => $capKWh,

                "pBatW"      => $pBatW,
                "sdlShareKW_laden" => $sdlShareKW_laden,
                "sdlShareKW_entladen" => $sdlShareKW_entladen,
                "evShareKW_laden"  => $evShareKW_laden,
                "evShareKW_entladen"  => $evShareKW_entladen,

                "underKWh" => $underKWh,
                "upKWh"    => $upKWh,

                "SDL_kWh_total" => $SDL_kWh,
                "EV_kWh_total"  => $EV_kWh
            ];
        }

        $this->SetBuffer("BatCacheHash", $hash);
        $this->SetBuffer("BatCacheJSON", json_encode($cache));

        $this->SendDebug("Cache", "Battery cache rebuilt (" . count($cache["bats"]) . " bats)", 0);
    }

    private function GetBufferSafe(string $name): string
    {
        $v = $this->GetBuffer($name);
        return is_string($v) ? $v : "";
    }

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

        public function ApplySetpoints(): void
    {
        $pEvW  = (float) GetValue($this->GetIDForIdent("Nennleistung_Soll_EV"));
        $pSdlW = (float) GetValue($this->GetIDForIdent("Nennleistung_Soll_SDL"));
        //Diverenz zwischen EV und SDl berechnen 
        

        // Methode für priorisierung
        $distribution = $this->CalculateBatteryDistribution($pEvW,$pSdlW);


        $this->WriteBatteryPowerSetpoints($distribution);
    }


    private function CalculateBatteryDistribution(float $pEvW, float $pSdlW): array
    {

        // Holt das berechnete Json aus, also das Debug json, wo in der Konsole angezeigt wird
        $calcJsonId = $this->GetIDForIdent("CalcJSON");
        $calc = json_decode((string)GetValue($calcJsonId), true);

        if (!is_array($calc) || empty($calc["batteries"])) {
            return [];
        }
    
        foreach ($calc["batteries"] as $bat) {

        $idx = (int)$bat["idx"];
        $typ = (string)$bat["typ"];

        $evSoc  = (float)$bat["EV_SOC"];
        $sdlSoc = (float)$bat["SDL_SOC"];

        $sdlChargeKW    = (float)$bat["SDL_Charge_kW"];
        $sdlDischargeKW = (float)$bat["SDL_Discharge_kW"];
        $evChargeKW     = (float)$bat["EV_Charge_kW"];
        $evDischargeKW  = (float)$bat["EV_Discharge_kW"];
        }


    /*
        // Return sieht so aus:
            return :[
                "idx" => 0,
                "typ":"1",
                "chargeW" => 0.0,
                "dischargeW" => 3000.0
            ],
            [
                "idx" => 1,
                "typ":"2",
                "chargeW" => 0.0,
                "dischargeW" => 1000.0
            ];
        */

    }

    private function WriteBatteryPowerSetpoints(array $distribution): void
    {
        // Batteries-Config laden (enthält register_laden / register_entladen)
        $batteriesCfg = json_decode($this->ReadPropertyString("Batteries"), true);
        if (!is_array($batteriesCfg) || empty($batteriesCfg)) {
            return;
        }

        foreach ($distribution as $d) {

            // --- Batterie bestimmen ---
            $idx = (int)($d["idx"] ?? -1);
            if ($idx < 0 || !isset($batteriesCfg[$idx])) {
                continue;
            }

            $cfg = $batteriesCfg[$idx];

            // typ aus distribution bevorzugen, sonst aus Config
            $typ = (string)($d["typ"] ?? ($cfg["typ"] ?? ("Bat " . ($idx + 1))));

            // --- Sollwerte (Watt) ---
            $chargeW    = max(0.0, (float)($d["chargeW"] ?? 0.0));
            $dischargeW = max(0.0, (float)($d["dischargeW"] ?? 0.0));

            // Sicherheitsnetz: nie gleichzeitig laden & entladen
            if ($chargeW > 0.0 && $dischargeW > 0.0) {
                $this->SendDebug(
                    "WriteBatteryPowerSetpoints",
                    "WARN: charge & discharge gleichzeitig > 0 bei $typ (idx=$idx) -> setze beides 0",
                    0
                );
                $chargeW = 0.0;
                $dischargeW = 0.0;
            }

            // --- Vendor-/Default-Handling über Register schreiben ---
            $this->WriteByVendorRegisters($typ, $cfg, $chargeW, $dischargeW);

            // Optionales Debug
            $this->SendDebug(
                "Setpoints",
                "$typ (idx=$idx): charge={$chargeW}W discharge={$dischargeW}W",
                0
            );
        }
    }

    private function WriteByVendorRegisters(string $typ, array $cfg, float $chargeW, float $dischargeW): void
    {
        $typLower = mb_strtolower($typ);

        // Register aus Formular
        $regCharge = (int)($cfg["register_laden"] ?? 0);
        $regDisch  = (int)($cfg["register_entladen"] ?? 0);

        // -----------------------------
        // GOODWE → ein Register, signed
        // -----------------------------
        if (strpos($typLower, "goodwe") !== false) {

            if ($regCharge > 0 && IPS_VariableExists($regCharge)) {
                $signedW = 0.0;

                if ($chargeW > 0.0) {
                    $signedW = $chargeW;           // Laden → +
                } elseif ($dischargeW > 0.0) {
                    $signedW = -1.0 * $dischargeW; // Entladen → -
                }

                SetValue($regCharge, (int)round($signedW, 0));
            }

            // optional: zweites Register auf 0 halten
            if ($regDisch > 0 && IPS_VariableExists($regDisch)) {
                SetValue($regDisch, 0);
            }

            return;
        }

        // --------------------------------
        // SOLAREDGE → getrennte Register
        // --------------------------------
        if (strpos($typLower, "solaredge") !== false) {

            if ($regCharge > 0 && IPS_VariableExists($regCharge)) {
                SetValue($regCharge, (int)round($chargeW, 0));
            }

            if ($regDisch > 0 && IPS_VariableExists($regDisch)) {
                SetValue($regDisch, (int)round($dischargeW, 0));
            }

            return;
        }

        // --------------------------------
        // DEFAULT → getrennt, fest: 1 / 2
        // --------------------------------
        // Laden = Register 1, Entladen = Register 2

        if (IPS_VariableExists(1)) {
            SetValue(1, (int)round($chargeW, 0));
        }

        if (IPS_VariableExists(2)) {
            SetValue(2, (int)round($dischargeW, 0));
        }

        $this->SendDebug(
            "WriteByVendorRegisters",
            "DEFAULT ($typ): charge={$chargeW}W -> Reg1, discharge={$dischargeW}W -> Reg2",
            0
        );
    }


}
?>