<?php

class PV_Forecast extends IPSModule
{
    // GUID vom Archive Control (Standard in IP-Symcon)
    private const ARCHIVE_GUID = "{43192F0B-135B-4CE7-A0A7-1475603F3060}";

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

        $this->RegisterPropertyString("URL", "");
        $this->RegisterPropertyInteger("ActualVariableID", 0);
        $this->RegisterPropertyInteger("RefreshMinutes", 5);
        $this->RegisterPropertyBoolean("ActualIsWatt", true);

        // Timer
        $this->RegisterTimer("UpdateForecastTimer", 0, 'IPS_RequestAction($_IPS["TARGET"], "UpdateForecast", 0);');

        // Hook für Visualisierung (JSON Endpoint)
        // (Falls das automatische Registrieren bei dir nicht greift: du hast es manuell im WebHook Control bereits erledigt.)
        $this->RegisterHook("/hook/solcastcompare");
    }

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

        // Tile Visualization aktivieren
        $this->SetVisualizationType(1);

        $mins = max(1, (int)$this->ReadPropertyInteger("RefreshMinutes"));
        $this->SetTimerInterval("UpdateForecastTimer", $mins * 60 * 1000);

        // Hook hier nochmal versuchen zu registrieren (ist oft zuverlässiger)
        $this->RegisterHook("/hook/solcastcompare");
    }

    public function RequestAction($Ident, $Value)
    {
        switch ($Ident) {
            case "UpdateForecast":
                $this->UpdateForecast();
                break;

            default:
                throw new Exception("Unknown Ident: " . $Ident);
        }
    }

    private function UpdateForecast()
    {
        $url = trim($this->ReadPropertyString("URL"));
        if ($url === "") {
            $this->SendDebug("UpdateForecast", "URL ist leer", 0);
            return;
        }

        try {
            $json = Sys_GetURLContent($url);
            if ($json === false || $json === "") {
                $this->SendDebug("UpdateForecast", "Leere Antwort von URL", 0);
                return;
            }

            $data = json_decode($json, true);
            if (!is_array($data)) {
                $this->SendDebug("UpdateForecast", "JSON decode fehlgeschlagen", 0);
                return;
            }

            // Cache in Buffer
            $this->SetBuffer("ForecastRaw", $json);
            $this->SetBuffer("ForecastTS", (string)time());

            $this->SendDebug("UpdateForecast", "Forecast aktualisiert", 0);
        } catch (Throwable $e) {
            $this->SendDebug("UpdateForecast", "Fehler: " . $e->getMessage(), 0);
        }
    }

    // -------- Datenaufbereitung fürs Diagramm --------

    private function GetForecastSeries(): array
    {
        $raw = $this->GetBuffer("ForecastRaw");
        if ($raw === "") {
            return [];
        }

        $data = json_decode($raw, true);
        if (!is_array($data) || !isset($data["estimated_actuals"]) || !is_array($data["estimated_actuals"])) {
            return [];
        }

        // Solcast liefert period_end in UTC (Z)
        $series = [];
        foreach ($data["estimated_actuals"] as $row) {
            if (!isset($row["period_end"], $row["pv_power_rooftop"])) {
                continue;
            }
            $ts = strtotime($row["period_end"]); // UTC korrekt wegen "Z"
            if ($ts === false) {
                continue;
            }

            // pv_power_rooftop i.d.R. kW
            $val = (float)$row["pv_power_rooftop"];
            $series[] = [$ts * 1000, $val];
        }

        // oft absteigend -> aufsteigend fürs Chart
        usort($series, function ($a, $b) {
            return $a[0] <=> $b[0];
        });

        return $series;
    }

    private function GetActualSeriesFromArchive(int $startTs, int $endTs, int $bucketSeconds = 1800): array
    {
        $varId = (int)$this->ReadPropertyInteger("ActualVariableID");
        if ($varId <= 0 || !IPS_VariableExists($varId)) {
            return [];
        }

        $archiveId = $this->GetArchiveInstanceID();
        if ($archiveId === 0) {
            return [];
        }

        if (!AC_GetLoggingStatus($archiveId, $varId)) {
            $this->SendDebug("Actual", "Variable wird nicht geloggt im Archiv", 0);
            return [];
        }

        // Rohwerte holen
        $logged = AC_GetLoggedValues($archiveId, $varId, $startTs, $endTs, 0);
        if (!is_array($logged) || count($logged) === 0) {
            return [];
        }

        // Bucket: 30 Minuten
        $buckets = []; // key=bucketEndTs => [sum, count]
        foreach ($logged as $row) {
            if (!isset($row["TimeStamp"], $row["Value"])) {
                continue;
            }

            $ts = (int)$row["TimeStamp"];

            // 30min Raster
            $bucketStart = intdiv($ts, $bucketSeconds) * $bucketSeconds;
            $bucketEnd = $bucketStart + $bucketSeconds; // wie Solcast period_end

            if ($bucketEnd < $startTs || $bucketEnd > $endTs) {
                continue;
            }

            if (!isset($buckets[$bucketEnd])) {
                $buckets[$bucketEnd] = [0.0, 0];
            }
            $buckets[$bucketEnd][0] += (float)$row["Value"];
            $buckets[$bucketEnd][1] += 1;
        }

        ksort($buckets);

        $series = [];
        $isWatt = (bool)$this->ReadPropertyBoolean("ActualIsWatt");

        foreach ($buckets as $bucketEnd => $sc) {
            $sum = $sc[0];
            $count = $sc[1];
            if ($count <= 0) {
                continue;
            }

            $avg = $sum / $count;

            // W -> kW, damit es zu Solcast passt
            if ($isWatt) {
                $avg = $avg / 1000.0;
            }

            $series[] = [$bucketEnd * 1000, $avg];
        }

        return $series;
    }

    private function GetArchiveInstanceID(): int
    {
        $list = IPS_GetInstanceListByModuleID(self::ARCHIVE_GUID);
        if (is_array($list) && count($list) > 0) {
            return (int)$list[0];
        }
        return 0;
    }

    // -------- Tile Visualisierung --------

    public function GetVisualizationTile(): string
    {
        // Forecast ggf. initial laden
        if ($this->GetBuffer("ForecastRaw") === "") {
            $this->UpdateForecast();
        }

        $html = file_get_contents(__DIR__ . "/module.html");
        $html = str_replace("{{INSTANCE_ID}}", (string)$this->InstanceID, $html);

        return $html;
    }

    // -------- WebHook Handler --------

    protected function ProcessHookData()
    {
        // Erwartet: /hook/solcastcompare?instance=12345&action=data
        $instance = isset($_GET["instance"]) ? (int)$_GET["instance"] : 0;
        $action = isset($_GET["action"]) ? (string)$_GET["action"] : "";

        if ($instance !== $this->InstanceID) {
            http_response_code(404);
            echo "Wrong instance";
            return;
        }

        if ($action !== "data") {
            http_response_code(400);
            echo "Unknown action";
            return;
        }

        $end = time();
        $start = $end - 24 * 3600;

        $forecast = $this->GetForecastSeries();
        $actual = $this->GetActualSeriesFromArchive($start, $end, 1800);

        $out = [
            "meta" => [
                "forecast_cached_at" => (int)$this->GetBuffer("ForecastTS"),
                "bucket_seconds" => 1800,
                "actual_is_watt" => (bool)$this->ReadPropertyBoolean("ActualIsWatt")
            ],
            "series" => [
                "forecast" => $forecast,
                "actual" => $actual
            ]
        ];

        header("Content-Type: application/json; charset=utf-8");
        echo json_encode($out);
    }

    // -------- optional: Hook automatisch im WebHook Control registrieren --------
    // Wenn du es bereits manuell eingetragen hast, ist das hier nicht zwingend.
    private function RegisterHook(string $Hook)
    {
        // WebHook Control GUID (kann je nach Version variieren; wenn nicht gefunden -> einfach ignorieren)
        $ids = IPS_GetInstanceListByModuleID("{015A6EB8-D6E5-4B93-B496-0D3FAD4D0E6E}");
        if (count($ids) === 0) {
            return;
        }

        $hookID = (int)$ids[0];
        $hooks = json_decode(IPS_GetProperty($hookID, "Hooks"), true);
        if (!is_array($hooks)) {
            $hooks = [];
        }

        $found = false;
        foreach ($hooks as $h) {
            if (isset($h["Hook"]) && $h["Hook"] === $Hook) {
                $found = true;
                break;
            }
        }

        if (!$found) {
            $hooks[] = ["Hook" => $Hook, "TargetID" => $this->InstanceID];
            IPS_SetProperty($hookID, "Hooks", json_encode($hooks));
            IPS_ApplyChanges($hookID);
        }
    }
}