// ip_reporter.js - Erweiterte Version mit Partner-IP im KVS
// Konstante: Die URL Ihres externen Servers
let TARGET_URL = "http://easy-solar.eu:43300/update_ip"; 

// Funktion zum Senden der IP-Adresse und ID an den Server
function reportIpAndId() {
    
    // 1. Geräteinformationen abrufen
    Shelly.call(
        "Shelly.GetStatus",
        {},
        function (res, error_code, error_message) {
            
            if (error_code !== 0) {
                print("FEHLER: Konnte den Shelly-Status nicht abrufen:", error_message);
                return;
            }
            
            // 2. Erforderliche Daten extrahieren
            let localIp = res.wifi.sta_ip; 
            let deviceId = res.sys.mac;
            
            // 3. Nutzlast (Payload) für den Server erstellen
            let payload = JSON.stringify({
                // --- IDENTIFIKATION ---
                device_id: res.sys.mac,
                device_name: Shelly.getComponentConfig("sys").device.name || "Unbenannt",
                
                // --- NETZWERK ---
                local_ip: res.wifi.sta_ip,
                ssid: res.wifi.ssid,
                rssi: res.wifi.rssi,
                
                // --- SYSTEM ---
                firmware: res.sys.fw_id,
                model: "Shelly Plug S Plus",
                uptime: res.sys.uptime,
                
                // --- STROMVERBRAUCH ---
                power: res.switch0 ? res.switch0.apower : 0,
                voltage: res.switch0 ? res.switch0.voltage : 0,
                current: res.switch0 ? res.switch0.current : 0,
                energy_total: res.switch0 ? res.switch0.aenergy.total : 0,
                
                // --- STATUS ---
                switch_state: res.switch0 ? res.switch0.output : false,
                temperature: res.switch0 ? res.switch0.temperature.tC : null,
                overtemperature: res.switch0 ? res.switch0.temperature.tC > 95 : false,
                
                // --- ZEITSTEMPEL ---
                timestamp: Date.now(),
                last_restart_reason: res.sys.restart_required ? "pending" : "none"
            });
            
            // 4. HTTP POST-Anfrage an den Server senden
            Shelly.call(
                "HTTP.POST",
                {
                    url: TARGET_URL,
                    content_type: "application/json",
                    body: payload,
                    timeout: 5
                },
                function (response, error_code, error_message) {
                    if (error_code === 0 && response.code >= 200 && response.code < 300) {
                        print("✓ IP-Meldung erfolgreich | ID:", deviceId, "| IP:", localIp);
                        
                        // 5. Partner-IP aus der Antwort extrahieren und im KVS speichern
                        try {
                            let responseData = JSON.parse(response.body);
                            
                            // Prüfen ob Partner-Daten vorhanden sind
                            if (responseData.partner_ip) {
                                let partnerData = {
                                    partner_ip: responseData.partner_ip,
                                    partner_id: responseData.partner_id || "unknown",
                                    partner_name: responseData.partner_name || "Unknown Partner",
                                    last_updated: Date.now()
                                };
                                
                                // Im KVS speichern
                                Shelly.call(
                                    "KVS.Set",
                                    {
                                        key: "PartnerIp",
                                        value: JSON.stringify(partnerData)
                                    },
                                    function(result, err_code, err_msg) {
                                        if (err_code === 0) {
                                            print("✓ Partner-IP gespeichert:", partnerData.partner_ip, 
                                                  "(", partnerData.partner_name, ")");
                                        } else {
                                            print("✗ KVS-Speichern fehlgeschlagen:", err_msg);
                                        }
                                    }
                                );
                            } else {
                                print("ℹ Kein Partner im selben LAN gefunden");
                                
                                // Alten Eintrag löschen falls vorhanden
                                Shelly.call("KVS.Delete", {key: "PartnerIp"}, function() {});
                            }
                        } catch (e) {
                            print("⚠ Konnte Partner-Daten nicht verarbeiten:", e);
                        }
                        
                    } else {
                        print("✗ Senden fehlgeschlagen | Code:", error_code, 
                              "| HTTP:", response ? response.code : "N/A",
                              "| Msg:", error_message);
                    }
                }
            );
        }
    );
}

// Hilfsfunktion: Partner-IP aus KVS auslesen
function getPartnerIp() {
    Shelly.call(
        "KVS.Get",
        {key: "PartnerIp"},
        function(result, error_code, error_message) {
            if (error_code === 0 && result.value) {
                try {
                    let partnerData = JSON.parse(result.value);
                    print("=== Gespeicherte Partner-Daten ===");
                    print("IP:", partnerData.partner_ip);
                    print("ID:", partnerData.partner_id);
                    print("Name:", partnerData.partner_name);
                    print("Zuletzt aktualisiert:", new Date(partnerData.last_updated).toISOString());
                } catch (e) {
                    print("Fehler beim Lesen der Partner-Daten:", e);
                }
            } else {
                print("Keine Partner-Daten im KVS gefunden");
            }
        }
    );
}

// Sofort beim Start einmal ausführen
print("=== Shelly IP Reporter gestartet ===");
reportIpAndId();

// Dann alle 60 Minuten wiederholen
Timer.set(60 * 60 * 1000, true, function() {
    print("--- Stündliches IP-Update ---");
    reportIpAndId();
});

// Optional: Partner-IP alle 5 Minuten in den Logs anzeigen
//Timer.set(5 * 60 * 1000, true, function() {
//    getPartnerIp();
// });