iobroker.utility-monitor 1.5.0 → 1.6.1

package/lib/billingManager.js

@@ -171,7 +171,7 @@ class BillingManager {
         }
 
         if (!startDate || isNaN(startDate.getTime())) {
-            const lastYearStart = await this.adapter.getStateAsync(`${type}.statistics.lastYearStart`);
+            const lastYearStart = await this.adapter.getStateAsync(`${type}.statistics.timestamps.lastYearStart`);
             startDate = new Date(lastYearStart?.val || Date.now());
         }
 
@@ -372,7 +372,11 @@ class BillingManager {
         // even if the user closes the period early (e.g. 2 days before)
         const thisYearAnniversary = new Date(startDate);
         thisYearAnniversary.setFullYear(new Date().getFullYear());
-        await this.adapter.setStateAsync(`${type}.statistics.lastYearStart`, thisYearAnniversary.getTime(), true);
+        await this.adapter.setStateAsync(
+            `${type}.statistics.timestamps.lastYearStart`,
+            thisYearAnniversary.getTime(),
+            true,
+        );
 
         this.adapter.log.info(`✅ Abrechnungszeitraum ${year} für ${type} erfolgreich abgeschlossen!`);
         this.adapter.log.info(
@@ -419,11 +423,96 @@ class BillingManager {
             return;
         }
 
+        // Archive data for this meter
         const year = startDate.getFullYear();
 
-        // Archive data for this meter
-        // TODO: Implement full history archiving for individual meters
-        // For now, just reset the meter
+        this.adapter.log.info(`Archiving data for ${basePath} year ${year}...`);
+
+        // Create history structure for this meter
+        await this.adapter.setObjectNotExistsAsync(`${basePath}.history`, {
+            type: 'channel',
+            common: { name: 'Historie' },
+            native: {},
+        });
+        await this.adapter.setObjectNotExistsAsync(`${basePath}.history.${year}`, {
+            type: 'channel',
+            common: { name: `Jahr ${year}` },
+            native: {},
+        });
+
+        // Get current values for archiving
+        const yearlyState = await this.adapter.getStateAsync(`${basePath}.consumption.yearly`);
+        const totalYearlyState = await this.adapter.getStateAsync(`${basePath}.costs.totalYearly`);
+        const balanceState = await this.adapter.getStateAsync(`${basePath}.costs.balance`);
+
+        const yearly = yearlyState?.val || 0;
+        const totalYearly = totalYearlyState?.val || 0;
+        const balance = balanceState?.val || 0;
+
+        const consumptionUnit = type === 'gas' ? 'kWh' : type === 'water' ? 'm³' : 'kWh';
+
+        // Archive yearly consumption
+        await this.adapter.setObjectNotExistsAsync(`${basePath}.history.${year}.yearly`, {
+            type: 'state',
+            common: {
+                name: `Jahresverbrauch ${year}`,
+                type: 'number',
+                role: 'value',
+                read: true,
+                write: false,
+                unit: consumptionUnit,
+            },
+            native: {},
+        });
+        await this.adapter.setStateAsync(`${basePath}.history.${year}.yearly`, yearly, true);
+
+        // Archive gas volume if applicable
+        if (type === 'gas') {
+            const yearlyVolume = (await this.adapter.getStateAsync(`${basePath}.consumption.yearlyVolume`))?.val || 0;
+            await this.adapter.setObjectNotExistsAsync(`${basePath}.history.${year}.yearlyVolume`, {
+                type: 'state',
+                common: {
+                    name: `Jahresverbrauch ${year} (m³)`,
+                    type: 'number',
+                    role: 'value',
+                    read: true,
+                    write: false,
+                    unit: 'm³',
+                },
+                native: {},
+            });
+            await this.adapter.setStateAsync(`${basePath}.history.${year}.yearlyVolume`, yearlyVolume, true);
+        }
+
+        // Archive total yearly costs
+        await this.adapter.setObjectNotExistsAsync(`${basePath}.history.${year}.totalYearly`, {
+            type: 'state',
+            common: {
+                name: `Gesamtkosten ${year}`,
+                type: 'number',
+                role: 'value.money',
+                read: true,
+                write: false,
+                unit: '€',
+            },
+            native: {},
+        });
+        await this.adapter.setStateAsync(`${basePath}.history.${year}.totalYearly`, totalYearly, true);
+
+        // Archive balance
+        await this.adapter.setObjectNotExistsAsync(`${basePath}.history.${year}.balance`, {
+            type: 'state',
+            common: {
+                name: `Bilanz ${year}`,
+                type: 'number',
+                role: 'value.money',
+                read: true,
+                write: false,
+                unit: '€',
+            },
+            native: {},
+        });
+        await this.adapter.setStateAsync(`${basePath}.history.${year}.balance`, balance, true);
 
         // Reset consumption and costs for this meter
         await this.adapter.setStateAsync(`${basePath}.consumption.yearly`, 0, true);
@@ -441,7 +530,11 @@ class BillingManager {
         // Update lastYearStart to contract anniversary
         const thisYearAnniversary = new Date(startDate);
         thisYearAnniversary.setFullYear(new Date().getFullYear());
-        await this.adapter.setStateAsync(`${basePath}.statistics.lastYearStart`, thisYearAnniversary.getTime(), true);
+        await this.adapter.setStateAsync(
+            `${basePath}.statistics.timestamps.lastYearStart`,
+            thisYearAnniversary.getTime(),
+            true,
+        );
 
         // Update totals if multiple meters exist
         const meters = this.adapter.multiMeterManager?.getMetersForType(type) || [];
@@ -539,64 +632,100 @@ class BillingManager {
             // This ensures History adapter sees clean day boundaries
             const isResetTime = nowDate.getHours() === 23 && nowDate.getMinutes() === 59;
 
-            // Helper: Check if timestamp is from today
+            // Helper: Create normalized timestamp for 23:59:00 of a given date
+            // This ensures consistent timestamps regardless of actual execution time
+            const getNormalizedResetTime = date => {
+                return new Date(date.getFullYear(), date.getMonth(), date.getDate(), 23, 59, 0, 0).getTime();
+            };
+
+            // Helper: Check if timestamp is from a valid 23:59 reset today
+            // A valid reset must be from today AND from the 23:xx hour
+            // This prevents adapter restarts (e.g. at 00:01:03) from blocking the real 23:59 reset
             const todayStart = new Date(nowDate.getFullYear(), nowDate.getMonth(), nowDate.getDate()).getTime();
-            const isFromToday = timestamp => timestamp >= todayStart;
+            const isValidResetToday = timestamp => {
+                if (timestamp < todayStart) {
+                    return false; // Not from today
+                }
+                // Check if the timestamp was from the 23:xx hour (valid reset time)
+                const resetDate = new Date(timestamp);
+                return resetDate.getHours() === 23;
+            };
 
             // DAILY RESET: Trigger at 23:59 if today's reset hasn't happened yet
-            const lastDayStart = await this.adapter.getStateAsync(`${basePath}.statistics.lastDayStart`);
+            const lastDayStart = await this.adapter.getStateAsync(`${basePath}.statistics.timestamps.lastDayStart`);
             if (lastDayStart?.val) {
                 const lastResetTime = lastDayStart.val;
-                const alreadyResetToday = isFromToday(lastResetTime);
+                const alreadyResetToday = isValidResetToday(lastResetTime);
 
                 // Reset at 23:59 if not yet reset today, OR catch up if we missed it (e.g. adapter was offline)
                 if (isResetTime && !alreadyResetToday) {
                     this.adapter.log.info(`Täglicher Reset für ${type} um 23:59`);
-                    await this.resetDailyCounters(type);
+                    await this.resetDailyCounters(type, getNormalizedResetTime(nowDate));
                 } else if (!alreadyResetToday && nowDate.getTime() > lastResetTime + 24 * 60 * 60 * 1000) {
                     // Catch-up: More than 24h since last reset (adapter was offline)
+                    // Calculate when the reset SHOULD have happened (yesterday 23:59)
+                    const yesterday = new Date(nowDate);
+                    yesterday.setDate(yesterday.getDate() - 1);
+                    const catchUpTime = getNormalizedResetTime(yesterday);
                     this.adapter.log.info(`Täglicher Reset für ${type} (Nachholung - Adapter war offline)`);
-                    await this.resetDailyCounters(type);
+                    await this.resetDailyCounters(type, catchUpTime);
                 }
             }
 
             // WEEKLY RESET: Trigger at 23:59 on Sunday if this week's reset hasn't happened yet
-            const lastWeekStart = await this.adapter.getStateAsync(`${basePath}.statistics.lastWeekStart`);
+            const lastWeekStart = await this.adapter.getStateAsync(`${basePath}.statistics.timestamps.lastWeekStart`);
             if (lastWeekStart?.val) {
                 const lastWeekTime = lastWeekStart.val;
                 const isSunday = nowDate.getDay() === 0; // 0 = Sunday
 
                 // Check if we're in a new week (more than 6 days since last reset)
+                // BUT also check if the last reset was actually a valid 23:59 reset
+                // to prevent adapter restarts from blocking the real weekly reset
                 const daysSinceLastReset = (nowDate.getTime() - lastWeekTime) / (24 * 60 * 60 * 1000);
-                const needsWeeklyReset = daysSinceLastReset >= 6;
+                const lastWeekResetDate = new Date(lastWeekTime);
+                const wasValidWeeklyReset = lastWeekResetDate.getHours() === 23;
+                const needsWeeklyReset = daysSinceLastReset >= 6 || (isSunday && !wasValidWeeklyReset);
 
                 if (isSunday && isResetTime && needsWeeklyReset) {
                     this.adapter.log.info(`Wöchentlicher Reset für ${type} um 23:59`);
-                    await this.resetWeeklyCounters(type);
-                } else if (needsWeeklyReset && daysSinceLastReset > 7) {
-                    // Catch-up: More than 7 days since last reset
+                    await this.resetWeeklyCounters(type, getNormalizedResetTime(nowDate));
+                } else if (needsWeeklyReset && daysSinceLastReset >= 7) {
+                    // Catch-up: 7 or more days since last reset (was offline or missed window)
+                    // Calculate when the reset SHOULD have happened (last Sunday 23:59)
+                    const lastSunday = new Date(nowDate);
+                    lastSunday.setDate(lastSunday.getDate() - lastSunday.getDay()); // Go back to Sunday
+                    const catchUpTime = getNormalizedResetTime(lastSunday);
                     this.adapter.log.info(`Wöchentlicher Reset für ${type} (Nachholung)`);
-                    await this.resetWeeklyCounters(type);
+                    await this.resetWeeklyCounters(type, catchUpTime);
                 }
             }
 
             // MONTHLY RESET: Trigger at 23:59 on last day of month
             if (meters.length > 0) {
-                const lastMonthStartState = await this.adapter.getStateAsync(`${basePath}.statistics.lastMonthStart`);
+                const lastMonthStartState = await this.adapter.getStateAsync(
+                    `${basePath}.statistics.timestamps.lastMonthStart`,
+                );
                 if (lastMonthStartState?.val) {
                     const lastMonthTime = lastMonthStartState.val;
                     const lastMonthDate = new Date(lastMonthTime);
                     const isLastDayOfMonth =
                         new Date(nowDate.getFullYear(), nowDate.getMonth() + 1, 0).getDate() === nowDate.getDate();
                     const monthChanged = nowDate.getMonth() !== lastMonthDate.getMonth();
+                    // Also check if the last reset was a valid 23:59 reset
+                    // to prevent adapter restarts from blocking the real monthly reset
+                    const wasValidMonthlyReset = lastMonthDate.getHours() === 23;
+                    const needsMonthlyReset = monthChanged || (isLastDayOfMonth && !wasValidMonthlyReset);
 
-                    if (isLastDayOfMonth && isResetTime && monthChanged) {
+                    if (isLastDayOfMonth && isResetTime && needsMonthlyReset) {
                         this.adapter.log.info(`Monatlicher Reset für ${type} um 23:59`);
-                        await this.resetMonthlyCounters(type);
+                        await this.resetMonthlyCounters(type, getNormalizedResetTime(nowDate));
                     } else if (monthChanged && nowDate.getDate() > 1) {
                         // Catch-up: We're past the 1st of a new month and haven't reset yet
+                        // Calculate when the reset SHOULD have happened (last day of previous month 23:59)
+                        const lastDayPrevMonth = new Date(nowDate.getFullYear(), nowDate.getMonth(), 0);
+                        const catchUpTime = getNormalizedResetTime(lastDayPrevMonth);
                         this.adapter.log.info(`Monatlicher Reset für ${type} (Nachholung)`);
-                        await this.resetMonthlyCounters(type);
+                        await this.resetMonthlyCounters(type, catchUpTime);
                     }
                 }
             }
@@ -606,7 +735,7 @@ class BillingManager {
             for (const meter of meters) {
                 const meterBasePath = `${type}.${meter.name}`;
                 const lastYearStartState = await this.adapter.getStateAsync(
-                    `${meterBasePath}.statistics.lastYearStart`,
+                    `${meterBasePath}.statistics.timestamps.lastYearStart`,
                 );
 
                 if (lastYearStartState?.val) {
@@ -638,17 +767,19 @@ class BillingManager {
                                 this.adapter.log.info(
                                     `Yearly reset for ${meterBasePath} um 23:59 (Vertragsjubiläum morgen: ${contractStartDate})`,
                                 );
-                                await this.resetYearlyCountersForMeter(type, meter);
+                                await this.resetYearlyCountersForMeter(type, meter, getNormalizedResetTime(nowDate));
 
                                 if (meters.length > 1) {
                                     await this.adapter.multiMeterManager.updateTotalCosts(type);
                                 }
                             } else if (isPastAnniversary && needsReset) {
                                 // Catch-up: Anniversary has passed but we haven't reset yet
+                                // Use the day before anniversary 23:59 as the reset time
+                                const catchUpTime = getNormalizedResetTime(dayBeforeAnniversary);
                                 this.adapter.log.info(
                                     `Yearly reset for ${meterBasePath} (Nachholung - Jubiläum: ${contractStartDate})`,
                                 );
-                                await this.resetYearlyCountersForMeter(type, meter);
+                                await this.resetYearlyCountersForMeter(type, meter, catchUpTime);
 
                                 if (meters.length > 1) {
                                     await this.adapter.multiMeterManager.updateTotalCosts(type);
@@ -663,15 +794,18 @@ class BillingManager {
                         if (isDecember31 && isResetTime && !needsReset) {
                             // Reset at 23:59 on Dec 31 for the upcoming year
                             this.adapter.log.info(`Yearly reset for ${meterBasePath} um 23:59 (Kalenderjahr)`);
-                            await this.resetYearlyCountersForMeter(type, meter);
+                            await this.resetYearlyCountersForMeter(type, meter, getNormalizedResetTime(nowDate));
 
                             if (meters.length > 1) {
                                 await this.adapter.multiMeterManager.updateTotalCosts(type);
                             }
                         } else if (needsReset) {
                             // Catch-up: We're in a new year but haven't reset yet
+                            // Use Dec 31 of last year 23:59 as reset time
+                            const dec31LastYear = new Date(nowDate.getFullYear() - 1, 11, 31);
+                            const catchUpTime = getNormalizedResetTime(dec31LastYear);
                             this.adapter.log.info(`Yearly reset for ${meterBasePath} (Nachholung - Kalenderjahr)`);
-                            await this.resetYearlyCountersForMeter(type, meter);
+                            await this.resetYearlyCountersForMeter(type, meter, catchUpTime);
 
                             if (meters.length > 1) {
                                 await this.adapter.multiMeterManager.updateTotalCosts(type);
@@ -687,8 +821,9 @@ class BillingManager {
      * Resets daily counters
      *
      * @param {string} type - Utility type
+     * @param {number} [resetTimestamp] - Optional normalized timestamp (defaults to Date.now())
      */
-    async resetDailyCounters(type) {
+    async resetDailyCounters(type, resetTimestamp) {
         this.adapter.log.info(`Resetting daily counters for ${type}`);
 
         // Get all meters for this type (main + additional meters)
@@ -710,7 +845,12 @@ class BillingManager {
             const dailyValue = dailyState?.val || 0;
 
             // Save last day consumption
-            await this.adapter.setStateAsync(`${basePath}.statistics.lastDay`, dailyValue, true);
+            await this.adapter.setStateAsync(`${basePath}.statistics.consumption.lastDay`, dailyValue, true);
+
+            // Save last day costs
+            const dailyCostState = await this.adapter.getStateAsync(`${basePath}.costs.daily`);
+            const dailyCostValue = dailyCostState?.val || 0;
+            await this.adapter.setStateAsync(`${basePath}.statistics.cost.lastDay`, dailyCostValue, true);
 
             await this.adapter.setStateAsync(`${basePath}.consumption.daily`, 0, true);
 
@@ -718,7 +858,11 @@ class BillingManager {
                 const dailyVolume = await this.adapter.getStateAsync(`${basePath}.consumption.dailyVolume`);
                 const dailyVolumeValue = dailyVolume?.val || 0;
                 // Save last day volume for gas
-                await this.adapter.setStateAsync(`${basePath}.statistics.lastDayVolume`, dailyVolumeValue, true);
+                await this.adapter.setStateAsync(
+                    `${basePath}.statistics.consumption.lastDayVolume`,
+                    dailyVolumeValue,
+                    true,
+                );
                 await this.adapter.setStateAsync(`${basePath}.consumption.dailyVolume`, 0, true);
             }
 
@@ -728,22 +872,44 @@ class BillingManager {
             if (htNtEnabled) {
                 const dailyHT = await this.adapter.getStateAsync(`${basePath}.consumption.dailyHT`);
                 const dailyNT = await this.adapter.getStateAsync(`${basePath}.consumption.dailyNT`);
-                await this.adapter.setStateAsync(`${basePath}.statistics.lastDayHT`, dailyHT?.val || 0, true);
-                await this.adapter.setStateAsync(`${basePath}.statistics.lastDayNT`, dailyNT?.val || 0, true);
+                await this.adapter.setStateAsync(
+                    `${basePath}.statistics.consumption.lastDayHT`,
+                    dailyHT?.val || 0,
+                    true,
+                );
+                await this.adapter.setStateAsync(
+                    `${basePath}.statistics.consumption.lastDayNT`,
+                    dailyNT?.val || 0,
+                    true,
+                );
                 await this.adapter.setStateAsync(`${basePath}.consumption.dailyHT`, 0, true);
                 await this.adapter.setStateAsync(`${basePath}.consumption.dailyNT`, 0, true);
+
+                // Costs for HT/NT
+                const dailyCostHT = (await this.adapter.getStateAsync(`${basePath}.costs.dailyHT`))?.val || 0;
+                const dailyCostNT = (await this.adapter.getStateAsync(`${basePath}.costs.dailyNT`))?.val || 0;
+                await this.adapter.setStateAsync(`${basePath}.statistics.cost.lastDayHT`, dailyCostHT, true);
+                await this.adapter.setStateAsync(`${basePath}.statistics.cost.lastDayNT`, dailyCostNT, true);
+                await this.adapter.setStateAsync(`${basePath}.costs.dailyHT`, 0, true);
+                await this.adapter.setStateAsync(`${basePath}.costs.dailyNT`, 0, true);
             }
 
             await this.adapter.setStateAsync(`${basePath}.costs.daily`, 0, true);
 
-            // Update lastDayStart timestamp
-            await this.adapter.setStateAsync(`${basePath}.statistics.lastDayStart`, Date.now(), true);
+            // Update lastDayStart timestamp (use normalized timestamp if provided)
+            const timestamp = resetTimestamp || Date.now();
+            await this.adapter.setStateAsync(`${basePath}.statistics.timestamps.lastDayStart`, timestamp, true);
 
             await this.adapter.setStateAsync(
-                `${basePath}.statistics.averageDaily`,
+                `${basePath}.statistics.consumption.averageDaily`,
                 calculator.roundToDecimals(dailyValue, 2),
                 true,
             );
+            await this.adapter.setStateAsync(
+                `${basePath}.statistics.cost.averageDaily`,
+                calculator.roundToDecimals(dailyCostValue, 2),
+                true,
+            );
         }
 
         // Update totals if multiple meters exist
@@ -756,8 +922,9 @@ class BillingManager {
      * Resets monthly counters
      *
      * @param {string} type - Utility type
+     * @param {number} [resetTimestamp] - Optional normalized timestamp (defaults to Date.now())
      */
-    async resetMonthlyCounters(type) {
+    async resetMonthlyCounters(type, resetTimestamp) {
         this.adapter.log.info(`Resetting monthly counters for ${type}`);
 
         // Get all meters for this type (main + additional meters)
@@ -780,13 +947,22 @@ class BillingManager {
             const monthlyValue = monthlyState?.val || 0;
 
             // Save last month consumption
-            await this.adapter.setStateAsync(`${basePath}.statistics.lastMonth`, monthlyValue, true);
+            await this.adapter.setStateAsync(`${basePath}.statistics.consumption.lastMonth`, monthlyValue, true);
+
+            // Save last month costs
+            const monthlyCostState = await this.adapter.getStateAsync(`${basePath}.costs.monthly`);
+            const monthlyCostValue = monthlyCostState?.val || 0;
+            await this.adapter.setStateAsync(`${basePath}.statistics.cost.lastMonth`, monthlyCostValue, true);
 
             // For gas: also save volume
             if (type === 'gas') {
                 const monthlyVolume = await this.adapter.getStateAsync(`${basePath}.consumption.monthlyVolume`);
                 const monthlyVolumeValue = monthlyVolume?.val || 0;
-                await this.adapter.setStateAsync(`${basePath}.statistics.lastMonthVolume`, monthlyVolumeValue, true);
+                await this.adapter.setStateAsync(
+                    `${basePath}.statistics.consumption.lastMonthVolume`,
+                    monthlyVolumeValue,
+                    true,
+                );
                 await this.adapter.setStateAsync(`${basePath}.consumption.monthlyVolume`, 0, true);
             }
 
@@ -797,20 +973,38 @@ class BillingManager {
             const configType = getConfigType(type);
             const htNtEnabled = this.adapter.config[`${configType}HtNtEnabled`] || false;
             if (htNtEnabled) {
+                const monthlyHT = (await this.adapter.getStateAsync(`${basePath}.consumption.monthlyHT`))?.val || 0;
+                const monthlyNT = (await this.adapter.getStateAsync(`${basePath}.consumption.monthlyNT`))?.val || 0;
+                await this.adapter.setStateAsync(`${basePath}.statistics.consumption.lastMonthHT`, monthlyHT, true);
+                await this.adapter.setStateAsync(`${basePath}.statistics.consumption.lastMonthNT`, monthlyNT, true);
                 await this.adapter.setStateAsync(`${basePath}.consumption.monthlyHT`, 0, true);
                 await this.adapter.setStateAsync(`${basePath}.consumption.monthlyNT`, 0, true);
+
+                // Costs for HT/NT
+                const monthlyCostHT = (await this.adapter.getStateAsync(`${basePath}.costs.monthlyHT`))?.val || 0;
+                const monthlyCostNT = (await this.adapter.getStateAsync(`${basePath}.costs.monthlyNT`))?.val || 0;
+                await this.adapter.setStateAsync(`${basePath}.statistics.cost.lastMonthHT`, monthlyCostHT, true);
+                await this.adapter.setStateAsync(`${basePath}.statistics.cost.lastMonthNT`, monthlyCostNT, true);
+                await this.adapter.setStateAsync(`${basePath}.costs.monthlyHT`, 0, true);
+                await this.adapter.setStateAsync(`${basePath}.costs.monthlyNT`, 0, true);
             }
 
             await this.adapter.setStateAsync(`${basePath}.costs.monthly`, 0, true);
 
-            // Update lastMonthStart timestamp
-            await this.adapter.setStateAsync(`${basePath}.statistics.lastMonthStart`, Date.now(), true);
+            // Update lastMonthStart timestamp (use normalized timestamp if provided)
+            const timestamp = resetTimestamp || Date.now();
+            await this.adapter.setStateAsync(`${basePath}.statistics.timestamps.lastMonthStart`, timestamp, true);
 
             await this.adapter.setStateAsync(
-                `${basePath}.statistics.averageMonthly`,
+                `${basePath}.statistics.consumption.averageMonthly`,
                 calculator.roundToDecimals(monthlyValue, 2),
                 true,
             );
+            await this.adapter.setStateAsync(
+                `${basePath}.statistics.cost.averageMonthly`,
+                calculator.roundToDecimals(monthlyCostValue, 2),
+                true,
+            );
         }
 
         // Update totals if multiple meters exist
@@ -842,18 +1036,51 @@ class BillingManager {
 
             this.adapter.log.debug(`Resetting yearly counter for ${basePath} (${label})`);
 
+            const yearlyState = await this.adapter.getStateAsync(`${basePath}.consumption.yearly`);
+            const yearlyValue = yearlyState?.val || 0;
+            await this.adapter.setStateAsync(`${basePath}.statistics.consumption.lastYear`, yearlyValue, true);
+
+            const yearlyCostState = await this.adapter.getStateAsync(`${basePath}.costs.yearly`);
+            const yearlyCostValue = yearlyCostState?.val || 0;
+            await this.adapter.setStateAsync(`${basePath}.statistics.cost.lastYear`, yearlyCostValue, true);
+
             await this.adapter.setStateAsync(`${basePath}.consumption.yearly`, 0, true);
 
             if (type === 'gas') {
+                const yearlyVolume = await this.adapter.getStateAsync(`${basePath}.consumption.yearlyVolume`);
+                const yearlyVolumeValue = yearlyVolume?.val || 0;
+                await this.adapter.setStateAsync(
+                    `${basePath}.statistics.consumption.lastYearVolume`,
+                    yearlyVolumeValue,
+                    true,
+                );
                 await this.adapter.setStateAsync(`${basePath}.consumption.yearlyVolume`, 0, true);
             }
 
+            const configType = getConfigType(type);
+            const htNtEnabled = this.adapter.config[`${configType}HtNtEnabled`] || false;
+            if (htNtEnabled) {
+                const yearlyHT = (await this.adapter.getStateAsync(`${basePath}.consumption.yearlyHT`))?.val || 0;
+                const yearlyNT = (await this.adapter.getStateAsync(`${basePath}.consumption.yearlyNT`))?.val || 0;
+                await this.adapter.setStateAsync(`${basePath}.statistics.consumption.lastYearHT`, yearlyHT, true);
+                await this.adapter.setStateAsync(`${basePath}.statistics.consumption.lastYearNT`, yearlyNT, true);
+                await this.adapter.setStateAsync(`${basePath}.consumption.yearlyHT`, 0, true);
+                await this.adapter.setStateAsync(`${basePath}.consumption.yearlyNT`, 0, true);
+
+                const yearlyCostHT = (await this.adapter.getStateAsync(`${basePath}.costs.yearlyHT`))?.val || 0;
+                const yearlyCostNT = (await this.adapter.getStateAsync(`${basePath}.costs.yearlyNT`))?.val || 0;
+                await this.adapter.setStateAsync(`${basePath}.statistics.cost.lastYearHT`, yearlyCostHT, true);
+                await this.adapter.setStateAsync(`${basePath}.statistics.cost.lastYearNT`, yearlyCostNT, true);
+                await this.adapter.setStateAsync(`${basePath}.costs.yearlyHT`, 0, true);
+                await this.adapter.setStateAsync(`${basePath}.costs.yearlyNT`, 0, true);
+            }
+
             await this.adapter.setStateAsync(`${basePath}.costs.yearly`, 0, true);
             await this.adapter.setStateAsync(`${basePath}.billing.notificationSent`, false, true);
             await this.adapter.setStateAsync(`${basePath}.billing.notificationChangeSent`, false, true);
 
             // Update lastYearStart timestamp
-            await this.adapter.setStateAsync(`${basePath}.statistics.lastYearStart`, Date.now(), true);
+            await this.adapter.setStateAsync(`${basePath}.statistics.timestamps.lastYearStart`, Date.now(), true);
         }
 
         // Update totals if multiple meters exist
@@ -867,33 +1094,69 @@ class BillingManager {
      *
      * @param {string} type - Utility type
      * @param {object} meter - Meter object from multiMeterManager
+     * @param {number} [resetTimestamp] - Optional normalized timestamp (defaults to Date.now())
      */
-    async resetYearlyCountersForMeter(type, meter) {
+    async resetYearlyCountersForMeter(type, meter, resetTimestamp) {
         const basePath = `${type}.${meter.name}`;
         const label = meter.displayName || meter.name;
 
         this.adapter.log.debug(`Resetting yearly counter for ${basePath} (${label})`);
 
+        const yearlyState = await this.adapter.getStateAsync(`${basePath}.consumption.yearly`);
+        const yearlyValue = yearlyState?.val || 0;
+        await this.adapter.setStateAsync(`${basePath}.statistics.consumption.lastYear`, yearlyValue, true);
+
+        const yearlyCostState = await this.adapter.getStateAsync(`${basePath}.costs.yearly`);
+        const yearlyCostValue = yearlyCostState?.val || 0;
+        await this.adapter.setStateAsync(`${basePath}.statistics.cost.lastYear`, yearlyCostValue, true);
+
         await this.adapter.setStateAsync(`${basePath}.consumption.yearly`, 0, true);
 
         if (type === 'gas') {
+            const yearlyVolume = await this.adapter.getStateAsync(`${basePath}.consumption.yearlyVolume`);
+            const yearlyVolumeValue = yearlyVolume?.val || 0;
+            await this.adapter.setStateAsync(
+                `${basePath}.statistics.consumption.lastYearVolume`,
+                yearlyVolumeValue,
+                true,
+            );
             await this.adapter.setStateAsync(`${basePath}.consumption.yearlyVolume`, 0, true);
         }
 
+        const configType = getConfigType(type);
+        const htNtEnabled = this.adapter.config[`${configType}HtNtEnabled`] || false;
+        if (htNtEnabled) {
+            const yearlyHT = (await this.adapter.getStateAsync(`${basePath}.consumption.yearlyHT`))?.val || 0;
+            const yearlyNT = (await this.adapter.getStateAsync(`${basePath}.consumption.yearlyNT`))?.val || 0;
+            await this.adapter.setStateAsync(`${basePath}.statistics.consumption.lastYearHT`, yearlyHT, true);
+            await this.adapter.setStateAsync(`${basePath}.statistics.consumption.lastYearNT`, yearlyNT, true);
+            await this.adapter.setStateAsync(`${basePath}.consumption.yearlyHT`, 0, true);
+            await this.adapter.setStateAsync(`${basePath}.consumption.yearlyNT`, 0, true);
+
+            const yearlyCostHT = (await this.adapter.getStateAsync(`${basePath}.costs.yearlyHT`))?.val || 0;
+            const yearlyCostNT = (await this.adapter.getStateAsync(`${basePath}.costs.yearlyNT`))?.val || 0;
+            await this.adapter.setStateAsync(`${basePath}.statistics.cost.lastYearHT`, yearlyCostHT, true);
+            await this.adapter.setStateAsync(`${basePath}.statistics.cost.lastYearNT`, yearlyCostNT, true);
+            await this.adapter.setStateAsync(`${basePath}.costs.yearlyHT`, 0, true);
+            await this.adapter.setStateAsync(`${basePath}.costs.yearlyNT`, 0, true);
+        }
+
         await this.adapter.setStateAsync(`${basePath}.costs.yearly`, 0, true);
         await this.adapter.setStateAsync(`${basePath}.billing.notificationSent`, false, true);
         await this.adapter.setStateAsync(`${basePath}.billing.notificationChangeSent`, false, true);
 
-        // Update lastYearStart timestamp
-        await this.adapter.setStateAsync(`${basePath}.statistics.lastYearStart`, Date.now(), true);
+        // Update lastYearStart timestamp (use normalized timestamp if provided)
+        const timestamp = resetTimestamp || Date.now();
+        await this.adapter.setStateAsync(`${basePath}.statistics.timestamps.lastYearStart`, timestamp, true);
     }
 
     /**
      * Resets weekly counters
      *
      * @param {string} type - Utility type
+     * @param {number} [resetTimestamp] - Optional normalized timestamp (defaults to Date.now())
      */
-    async resetWeeklyCounters(type) {
+    async resetWeeklyCounters(type, resetTimestamp) {
         this.adapter.log.info(`Resetting weekly counters for ${type}`);
 
         const meters = this.adapter.multiMeterManager?.getMetersForType(type) || [];
@@ -903,13 +1166,22 @@ class BillingManager {
             // Save last week consumption before reset
             const weeklyState = await this.adapter.getStateAsync(`${basePath}.consumption.weekly`);
             const weeklyValue = weeklyState?.val || 0;
-            await this.adapter.setStateAsync(`${basePath}.statistics.lastWeek`, weeklyValue, true);
+            await this.adapter.setStateAsync(`${basePath}.statistics.consumption.lastWeek`, weeklyValue, true);
+
+            // Save last week costs before reset
+            const weeklyCostState = await this.adapter.getStateAsync(`${basePath}.costs.weekly`);
+            const weeklyCostValue = weeklyCostState?.val || 0;
+            await this.adapter.setStateAsync(`${basePath}.statistics.cost.lastWeek`, weeklyCostValue, true);
 
             // For gas: also save volume
             if (type === 'gas') {
                 const weeklyVolume = await this.adapter.getStateAsync(`${basePath}.consumption.weeklyVolume`);
                 const weeklyVolumeValue = weeklyVolume?.val || 0;
-                await this.adapter.setStateAsync(`${basePath}.statistics.lastWeekVolume`, weeklyVolumeValue, true);
+                await this.adapter.setStateAsync(
+                    `${basePath}.statistics.consumption.lastWeekVolume`,
+                    weeklyVolumeValue,
+                    true,
+                );
                 await this.adapter.setStateAsync(`${basePath}.consumption.weeklyVolume`, 0, true);
             }
 
@@ -920,13 +1192,25 @@ class BillingManager {
             const configType = getConfigType(type);
             const htNtEnabled = this.adapter.config[`${configType}HtNtEnabled`] || false;
             if (htNtEnabled) {
+                const weeklyHT = (await this.adapter.getStateAsync(`${basePath}.consumption.weeklyHT`))?.val || 0;
+                const weeklyNT = (await this.adapter.getStateAsync(`${basePath}.consumption.weeklyNT`))?.val || 0;
+                await this.adapter.setStateAsync(`${basePath}.statistics.consumption.lastWeekHT`, weeklyHT, true);
+                await this.adapter.setStateAsync(`${basePath}.statistics.consumption.lastWeekNT`, weeklyNT, true);
                 await this.adapter.setStateAsync(`${basePath}.consumption.weeklyHT`, 0, true);
                 await this.adapter.setStateAsync(`${basePath}.consumption.weeklyNT`, 0, true);
+
+                // Costs for HT/NT
+                const weeklyCostHT = (await this.adapter.getStateAsync(`${basePath}.costs.weeklyHT`))?.val || 0;
+                const weeklyCostNT = (await this.adapter.getStateAsync(`${basePath}.costs.weeklyNT`))?.val || 0;
+                await this.adapter.setStateAsync(`${basePath}.statistics.cost.lastWeekHT`, weeklyCostHT, true);
+                await this.adapter.setStateAsync(`${basePath}.statistics.cost.lastWeekNT`, weeklyCostNT, true);
                 await this.adapter.setStateAsync(`${basePath}.costs.weeklyHT`, 0, true);
                 await this.adapter.setStateAsync(`${basePath}.costs.weeklyNT`, 0, true);
             }
 
-            await this.adapter.setStateAsync(`${basePath}.statistics.lastWeekStart`, Date.now(), true);
+            // Update lastWeekStart timestamp (use normalized timestamp if provided)
+            const timestamp = resetTimestamp || Date.now();
+            await this.adapter.setStateAsync(`${basePath}.statistics.timestamps.lastWeekStart`, timestamp, true);
         }
 
         if (meters.length > 1) {