iobroker.poolcontrol 0.7.3 → 0.8.1

package/lib/helpers/aiHelper.js

@@ -8,35 +8,35 @@
  * Zentraler KI-Helper für PoolControl.
  *
  * Nutzt die States aus aiStates.js:
- *   ai.switches.*
- *   ai.schedule.*
- *   ai.outputs.*
+ *   ai.weather.switches.*
+ *   ai.weather.schedule.*
+ *   ai.weather.outputs.*
  *
  * Funktionen:
  *   - Liest Geodaten aus system.config (Latitude/Longitude)
  *   - Ruft Wetterdaten von Open-Meteo ab (bei Bedarf, max. 4x/Tag – je Modul)
  *   - Erzeugt Textausgaben:
- *       ai.outputs.weather_advice
- *       ai.outputs.daily_summary
- *       ai.outputs.pool_tips
- *       ai.outputs.weekend_summary
- *       ai.outputs.last_message
+ *       ai.weather.outputs.weather_advice
+ *       ai.weather.outputs.daily_summary
+ *       ai.weather.outputs.pool_tips
+ *       ai.weather.outputs.weekend_summary
+ *       ai.weather.outputs.last_message
  *   - Optional: legt Texte in speech.queue für Sprachausgabe
  *
  * Wichtige Schalter:
- *   - ai.switches.enabled              → globaler KI-Schalter
- *   - ai.switches.allow_speech         → Sprachausgabe erlaubt
- *   - ai.switches.weather_advice_enabled
- *   - ai.switches.daily_summary_enabled
- *   - ai.switches.daily_pool_tips_enabled
- *   - ai.switches.weekend_summary_enabled
- *   - ai.switches.debug_mode
+ *   - ai.enabled              → globaler KI-Schalter
+ *   - ai.weather.switches.allow_speech         → Sprachausgabe erlaubt
+ *   - ai.weather.switches.weather_advice_enabled
+ *   - ai.weather.switches.daily_summary_enabled
+ *   - ai.weather.switches.daily_pool_tips_enabled
+ *   - ai.weather.switches.weekend_summary_enabled
+ *   - ai.weather.switches.debug_mode
  *
  * Zeitsteuerung (HH:MM, lokal):
- *   - ai.schedule.weather_advice_time
- *   - ai.schedule.daily_summary_time
- *   - ai.schedule.daily_pool_tips_time
- *   - ai.schedule.weekend_summary_time
+ *   - ai.weather.schedule.weather_advice_time
+ *   - ai.weather.schedule.daily_summary_time
+ *   - ai.weather.schedule.daily_pool_tips_time
+ *   - ai.weather.schedule.weekend_summary_time
  */
 
 const https = require('https');
@@ -47,6 +47,13 @@ const aiHelper = {
     _lastScheduleValues: {}, // NEU: merkt sich letzte Zeitwerte
     _debugMode: false,
 
+    _adapterStartedAt: Date.now(), // FIX: Zeitpunkt des Adapterstarts
+
+    // Anti-Spam-Level (merkt sich letzte Warnungen)
+    _lastPoolTipCode: null,
+    _lastPoolTipWindLevel: null,
+    _lastPoolTipTimestamp: 0,
+
     /**
      * Initialisiert den AI-Helper (Timer + Grundkonfiguration).
      *
@@ -101,7 +108,7 @@ const aiHelper = {
         // ---------------------------------------------------------
         // FIX 2: Uhrzeitänderungen IMMER erkennen und loggen
         // ---------------------------------------------------------
-        if (id.includes('.ai.schedule.')) {
+        if (id.includes('.ai.weather.schedule.')) {
             const oldVal = this._lastScheduleValues[id];
             const newVal = state.val;
 
@@ -114,13 +121,54 @@ const aiHelper = {
 
             // Timer neu aufbauen
             await this._refreshTimers();
+
+            // ----------------------------------------------------------
+            // NEU: Delay, damit ioBroker alle States laden kann
+            // ----------------------------------------------------------
+            await new Promise(res => setTimeout(res, 1500));
+
+            // NEU: Wenn Uhrzeit heute noch in der Zukunft liegt → sofort ausführen
+            try {
+                const now = new Date();
+                const [hourStr, minuteStr] = String(newVal).split(':');
+                const hour = Number(hourStr);
+                const minute = Number(minuteStr);
+
+                if (!Number.isNaN(hour) && !Number.isNaN(minute)) {
+                    const target = new Date();
+                    target.setHours(hour, minute, 0, 0);
+
+                    // Nur wenn Zielzeit HEUTE noch bevorsteht
+                    if (target > now) {
+                        this.adapter.log.info(
+                            `[aiHelper] Neue Uhrzeit liegt heute noch in der Zukunft → führe Modul sofort aus (${id})`,
+                        );
+
+                        if (id.endsWith('weather_advice_time')) {
+                            await this._runWeatherAdvice();
+                        }
+                        if (id.endsWith('daily_summary_time')) {
+                            await this._runDailySummary();
+                        }
+                        if (id.endsWith('daily_pool_tips_time')) {
+                            await this._runDailyPoolTips();
+                        }
+                        if (id.endsWith('weekend_summary_time')) {
+                            await this._runWeekendSummary();
+                        }
+                    }
+                }
+            } catch (e) {
+                this.adapter.log.warn(`[aiHelper] Fehler bei Sofortausführung nach Zeitänderung: ${e.message}`);
+            }
+
             return;
         }
 
         // ---------------------------------------------------------
         // FIX 3: Schalteränderungen immer melden
         // ---------------------------------------------------------
-        if (id.includes('.ai.switches.')) {
+        if (id.includes('.ai.weather.switches.')) {
             this.adapter.log.info(`[aiHelper] Schalter geändert: ${id} = ${state.val} – Timer werden neu aufgebaut`);
 
             await this._refreshTimers();
@@ -148,63 +196,106 @@ const aiHelper = {
     async _refreshTimers() {
         this._clearTimers();
 
-        const aiEnabled = await this._getBool('ai.switches.enabled', false);
-        this._debugMode = await this._getBool('ai.switches.debug_mode', false);
+        const aiEnabled = await this._getBool('ai.enabled', false);
+        this._debugMode = await this._getBool('ai.weather.switches.debug_mode', false);
 
         if (!aiEnabled) {
-            this.adapter.log.info('[aiHelper] KI ist deaktiviert (ai.switches.enabled = false) – keine Timer aktiv');
+            this.adapter.log.info('[aiHelper] KI ist deaktiviert (ai.enabled = false) – keine Timer aktiv');
             return;
         }
 
         this.adapter.log.info('[aiHelper] KI ist aktiv – Timer werden gesetzt');
 
         // --- Wetterhinweise ---
-        const weatherEnabled = await this._getBool('ai.switches.weather_advice_enabled', false);
+        const weatherEnabled = await this._getBool('ai.weather.switches.weather_advice_enabled', false);
         if (weatherEnabled) {
-            const time = await this._getTimeOrDefault('ai.schedule.weather_advice_time', '08:00');
+            const time = await this._getTimeOrDefault('ai.weather.schedule.weather_advice_time', '08:00');
             this._createDailyTimer(time, async () => {
                 await this._runWeatherAdvice();
             });
-            this.adapter.log.info(
+            this.adapter.log.debug(
                 `[aiHelper] Wetterhinweis-Timer gesetzt für ${time.hour}:${String(time.minute).padStart(2, '0')}`,
             );
         }
 
         // --- Tägliche Zusammenfassung ---
-        const summaryEnabled = await this._getBool('ai.switches.daily_summary_enabled', false);
+        const summaryEnabled = await this._getBool('ai.weather.switches.daily_summary_enabled', false);
         if (summaryEnabled) {
-            const time = await this._getTimeOrDefault('ai.schedule.daily_summary_time', '09:00');
+            const time = await this._getTimeOrDefault('ai.weather.schedule.daily_summary_time', '09:00');
             this._createDailyTimer(time, async () => {
                 await this._runDailySummary();
             });
-            this.adapter.log.info(
+            this.adapter.log.debug(
                 `[aiHelper] Daily-Summary-Timer gesetzt für ${time.hour}:${String(time.minute).padStart(2, '0')}`,
             );
         }
 
         // --- Tägliche Pool-Tipps ---
-        const tipsEnabled = await this._getBool('ai.switches.daily_pool_tips_enabled', false);
+        const tipsEnabled = await this._getBool('ai.weather.switches.daily_pool_tips_enabled', false);
         if (tipsEnabled) {
-            const time = await this._getTimeOrDefault('ai.schedule.daily_pool_tips_time', '10:00');
+            const time = await this._getTimeOrDefault('ai.weather.schedule.daily_pool_tips_time', '10:00');
             this._createDailyTimer(time, async () => {
                 await this._runDailyPoolTips();
             });
-            this.adapter.log.info(
+            this.adapter.log.debug(
                 `[aiHelper] Pool-Tipps-Timer gesetzt für ${time.hour}:${String(time.minute).padStart(2, '0')}`,
             );
         }
 
         // --- Wochenend-Zusammenfassung ---
-        const weekendEnabled = await this._getBool('ai.switches.weekend_summary_enabled', false);
+        const weekendEnabled = await this._getBool('ai.weather.switches.weekend_summary_enabled', false);
         if (weekendEnabled) {
-            const time = await this._getTimeOrDefault('ai.schedule.weekend_summary_time', '18:00');
+            const time = await this._getTimeOrDefault('ai.weather.schedule.weekend_summary_time', '18:00');
             this._createDailyTimer(time, async () => {
                 await this._runWeekendSummary();
             });
-            this.adapter.log.info(
+            this.adapter.log.debug(
                 `[aiHelper] Wochenend-Timer gesetzt für ${time.hour}:${String(time.minute).padStart(2, '0')}`,
             );
         }
+
+        //--------------------------------------------------------
+        // NEU: Stündlicher Wetter-Update-Timer
+        //--------------------------------------------------------
+        this.adapter.log.debug('[aiHelper] Stündlicher Wetter-Update-Timer wird gesetzt');
+
+        const hourlyTimer = setInterval(
+            async () => {
+                try {
+                    const geo = await this._loadGeoLocation();
+                    if (!geo) {
+                        this.adapter.log.info('[aiHelper] Wetter-Update abgebrochen – keine Geodaten verfügbar');
+                        return;
+                    }
+
+                    const weather = await this._fetchWeather(geo.lat, geo.lon);
+                    if (!weather) {
+                        this.adapter.log.info('[aiHelper] Wetter-Update abgebrochen – keine Wetterdaten verfügbar');
+                        return;
+                    }
+
+                    // WeatherAdvice aktualisieren (heutiges Wetter)
+                    const weatherText = this._buildWeatherAdviceText(weather);
+                    await this._writeOutput('weather_advice', weatherText);
+
+                    // NEU: Pool-Tipps automatisch mit aktualisieren
+                    const seasonActive = await this._getBool('status.season_active', false);
+                    const poolTipsText = this._buildPoolTipsText(weather, seasonActive);
+                    await this._writeOutput('pool_tips', poolTipsText);
+
+                    if (this._debugMode) {
+                        this.adapter.log.debug(
+                            '[aiHelper] Stündliches Wetter-Update durchgeführt (Weather + Pool-Tipps)',
+                        );
+                    }
+                } catch (err) {
+                    this.adapter.log.warn(`[aiHelper] Fehler beim stündlichen Wetter-Update: ${err.message}`);
+                }
+            },
+            60 * 60 * 1000,
+        ); // 1 Stunde
+
+        this.timers.push(hourlyTimer);
     },
 
     /**
@@ -219,20 +310,25 @@ const aiHelper = {
         const timer = setInterval(async () => {
             const now = new Date();
 
-            // --- NEU: Nachträgliche Ausführung, falls Zeit knapp verpasst wurde ---
+            // --- FIX: Nachholen nur in den ersten 3 Minuten nach Adapterstart ---
             const diffMinutes = now.getHours() * 60 + now.getMinutes() - (hour * 60 + minute);
 
-            if (diffMinutes > 0 && diffMinutes <= 2) {
+            const adapterUptimeMs = Date.now() - this._adapterStartedAt;
+            const withinStartupWindow = adapterUptimeMs <= 3 * 60 * 1000; // 3 Minuten
+
+            if (withinStartupWindow && diffMinutes > 0 && diffMinutes <= 2) {
                 try {
                     await callback();
-                    this.adapter.log.info('[aiHelper] Zeit knapp verpasst – nachträgliche Ausführung durchgeführt');
+                    this.adapter.log.info(
+                        '[aiHelper] Nachholung ausgeführt (innerhalb der ersten 3 Minuten nach Start)',
+                    );
                 } catch (err) {
-                    this.adapter.log.warn(`[aiHelper] Fehler bei nachträglicher Ausführung: ${err.message}`);
+                    this.adapter.log.warn(`[aiHelper] Fehler bei Nachholung: ${err.message}`);
                 }
             }
 
             if (now.getHours() === hour && now.getMinutes() === minute) {
-                this.adapter.log.info(
+                this.adapter.log.debug(
                     `[aiHelper] Timer ausgelöst: ${hour}:${String(minute).padStart(2, '0')} → Callback wird ausgeführt`,
                 ); // NEU
 
@@ -359,32 +455,57 @@ const aiHelper = {
         }
     },
 
+    //--------------------------------------------------------
+    // NEU: Stündliches Wetter-Update als eigene Funktion
+    //--------------------------------------------------------
+    async _runWeatherAutoUpdate() {
+        try {
+            const geo = await this._loadGeoLocation();
+            if (!geo) {
+                this.adapter.log.info('[aiHelper] Auto-Wetterupdate abgebrochen – keine Geodaten verfügbar');
+                return;
+            }
+
+            const weather = await this._fetchWeather(geo.lat, geo.lon);
+            if (!weather) {
+                this.adapter.log.info('[aiHelper] Auto-Wetterupdate abgebrochen – keine Wetterdaten verfügbar');
+                return;
+            }
+
+            // WeatherAdvice aktualisieren
+            const text = this._buildWeatherAdviceText(weather);
+            await this._writeOutput('weather_advice', text);
+
+            if (this._debugMode) {
+                this.adapter.log.debug('[aiHelper] Auto-Wetterupdate erfolgreich durchgeführt');
+            }
+        } catch (err) {
+            this.adapter.log.warn(`[aiHelper] Fehler bei Auto-Wetterupdate: ${err.message}`);
+        }
+    },
+
     // ---------------------------------------------------------------------
     // Geodaten + Wetter
     // ---------------------------------------------------------------------
 
     /**
-     * Lädt Geokoordinaten aus system.config.
+     * Lädt Geokoordinaten korrekt aus system.config.
      *
      * @returns {{lat:number,lon:number}|null}
      */
     async _loadGeoLocation() {
         try {
-            const latState = await this.adapter.getForeignStateAsync('system.config.latitude');
-            const lonState = await this.adapter.getForeignStateAsync('system.config.longitude');
-
-            if (!latState || !lonState || latState.val == null || lonState.val == null) {
-                this.adapter.log.warn(
-                    '[aiHelper] Geodaten in system.config nicht gesetzt – bitte im Admin konfigurieren',
-                );
+            const obj = await this.adapter.getForeignObjectAsync('system.config');
+            if (!obj || !obj.common) {
+                this.adapter.log.warn('[aiHelper] Konnte system.config nicht laden');
                 return null;
             }
 
-            const lat = Number(latState.val);
-            const lon = Number(lonState.val);
+            const lat = Number(obj.common.latitude);
+            const lon = Number(obj.common.longitude);
 
             if (Number.isNaN(lat) || Number.isNaN(lon)) {
-                this.adapter.log.warn('[aiHelper] Geodaten ungültig – latitude/longitude sind keine Zahlen');
+                this.adapter.log.warn('[aiHelper] Geodaten ungültig – bitte in Admin unter System/Standort eintragen');
                 return null;
             }
 
@@ -567,6 +688,54 @@ const aiHelper = {
 
         let text = 'Pool-Tipp für heute: ';
 
+        //--------------------------------------------------------
+        // NEU: Erweiterte Analyse für Pool-Tipps
+        //--------------------------------------------------------
+
+        // 1) Wind / Sturm
+        const wind = weather?.current?.wind_speed_10m ?? null;
+        if (wind != null) {
+            if (wind >= 60) {
+                text +=
+                    '⚠️ Extrem starker Sturm erwartet! Bitte unbedingt die Abdeckung sichern und alle Gegenstände im Poolbereich fest verankern. ';
+            } else if (wind >= 45) {
+                text += 'Achtung: Starke Windböen treten auf. Bitte Abdeckung fixieren und lose Gegenstände sichern. ';
+            } else if (wind >= 30) {
+                text += 'Es wird windig – Abdeckung gut verschließen und empfindliches Zubehör schützen. ';
+            }
+        }
+
+        // 2) Regen / Starkregen
+        if (code != null) {
+            if ([65, 82].includes(code)) {
+                text += 'Kräftige Regenschauer erwartet – Abdeckung geschlossen halten. ';
+            } else if ([61, 63, 80, 81].includes(code)) {
+                text += 'Es wird regnerisch – Abdeckung eher geschlossen lassen. ';
+            }
+        }
+
+        // 3) Gewitter / Hagel
+        if (code === 95) {
+            text += '⚡ Gewitterwarnung! Bitte Solarfolie sichern und Technik vor Feuchtigkeit schützen. ';
+        }
+        if (code === 96 || code === 99) {
+            text += '⚠️ Hagelgefahr! Bitte empfindliche Geräte schützen und Poolbereich räumen. ';
+        }
+
+        // 4) Temperatur / Hitze
+        if (tmax >= 28) {
+            text += 'Sehr warmes Badewetter – Abdeckung tagsüber offen lassen. Chlorverbrauch steigt. ';
+        } else if (tmax >= 22) {
+            text += 'Angenehme Temperaturen – normaler Poolbetrieb empfohlen. ';
+        } else if (tmax <= 16) {
+            text += 'Kühle Temperaturen – Abdeckung geschlossen halten, um Wärmeverluste zu reduzieren. ';
+        }
+
+        // Fallback falls noch nichts geschrieben wurde
+        if (text.trim() === 'Pool-Tipp für heute:') {
+            text += desc ? `${desc}. ` : 'Keine besonderen Hinweise für den heutigen Tag. ';
+        }
+
         if (tmax >= 26) {
             text += 'Es wird warm bis sehr warm – gutes Badewetter. ';
             text +=
@@ -587,6 +756,47 @@ const aiHelper = {
             text += 'Bei sonniger Witterung steigt der Chlorverbrauch – Wasserwerte im Auge behalten.';
         }
 
+        //--------------------------------------------------------
+        // NEU: Anti-Spam-Logik
+        //--------------------------------------------------------
+
+        // // Wettercode vergleichen
+        // if (code != null) {
+        //     if (this._lastPoolTipCode === code) {
+        //         // gleiches Wetter wie vorher → eventuell abbrechen
+        //         const nowTs = Date.now();
+        //         // nur jede 3 Stunden dieselbe Warnung erneut ausgeben
+        //         if (nowTs - this._lastPoolTipTimestamp < 3 * 60 * 60 * 1000) {
+        //             return 'Pool-Tipp: Keine neuen Hinweise – Bedingungen unverändert.';
+        //         }
+        //     }
+        // }
+
+        // Windlevel kategorisieren: 0 = ruhig, 1 = windig, 2 = stark, 3 = Sturm
+        let windLevel = 0;
+        if (wind != null) {
+            if (wind >= 60) {
+                windLevel = 3;
+            } else if (wind >= 45) {
+                windLevel = 2;
+            } else if (wind >= 30) {
+                windLevel = 1;
+            }
+        }
+
+        // // prüfen, ob derselbe Windlevel schon gemeldet wurde
+        // if (windLevel === this._lastPoolTipWindLevel) {
+        //     const nowTs = Date.now();
+        //     if (nowTs - this._lastPoolTipTimestamp < 3 * 60 * 60 * 1000) {
+        //         return 'Pool-Tipp: Keine neuen Informationen – Wetter gleich geblieben.';
+        //     }
+        // }
+
+        // Wenn wir hier sind → neuer Hinweis → Werte speichern
+        this._lastPoolTipCode = code;
+        this._lastPoolTipWindLevel = windLevel;
+        this._lastPoolTipTimestamp = Date.now();
+
         return text;
     },
 
@@ -761,11 +971,11 @@ const aiHelper = {
         }
 
         try {
-            await this.adapter.setStateAsync(`ai.outputs.${id}`, { val: text, ack: true });
-            await this.adapter.setStateAsync('ai.outputs.last_message', { val: text, ack: true });
+            await this.adapter.setStateAsync(`ai.weather.outputs.${id}`, { val: text, ack: true });
+            await this.adapter.setStateAsync('ai.weather.outputs.last_message', { val: text, ack: true });
 
             if (this._debugMode) {
-                this.adapter.log.info(`[aiHelper] Output geschrieben → ai.outputs.${id}: ${text}`);
+                this.adapter.log.debug(`[aiHelper] Output geschrieben → ai.weather.outputs.${id}: ${text}`);
             }
         } catch (err) {
             this.adapter.log.error(`[aiHelper] Fehler beim Schreiben eines Outputs (${id}): ${err.message}`);
@@ -785,10 +995,12 @@ const aiHelper = {
             return;
         }
 
-        const allowSpeech = await this._getBool('ai.switches.allow_speech', false);
+        const allowSpeech = await this._getBool('ai.weather.switches.allow_speech', false);
         if (!allowSpeech) {
             if (this._debugMode) {
-                this.adapter.log.debug('[aiHelper] Sprachausgabe deaktiviert (ai.switches.allow_speech = false)');
+                this.adapter.log.debug(
+                    '[aiHelper] Sprachausgabe deaktiviert (ai.weather.switches.allow_speech = false)',
+                );
             }
             return;
         }
@@ -870,7 +1082,7 @@ const aiHelper = {
         const str = await this._getString(id, def);
 
         // NEU: Log, welche Uhrzeit der Helper tatsächlich verwendet
-        this.adapter.log.info(`[aiHelper] Uhrzeit geladen: ${id} = "${str}" (Default: ${def})`);
+        this.adapter.log.debug(`[aiHelper] Uhrzeit geladen: ${id} = "${str}" (Default: ${def})`);
 
         const match = /^(\d{1,2}):(\d{2})$/.exec(str || '');
         let hour = 0;