iobroker.utility-monitor 1.4.6 → 1.5.1

package/lib/billingManager.js

@@ -1,6 +1,8 @@
 'use strict';
 
 const calculator = require('./calculator');
+const { getConfigType } = require('./utils/typeMapper');
+const billingHelper = require('./utils/billingHelper');
 
 /**
  * BillingManager handles all cost calculations,
@@ -20,7 +22,7 @@ class BillingManager {
      * @param {string} type - Utility type
      */
     async updateCosts(type) {
-        const configType = this.adapter.consumptionManager.getConfigType(type);
+        const configType = getConfigType(type);
 
         // Get price and basic charge from config
         const priceKey = `${configType}Preis`;
@@ -56,7 +58,7 @@ class BillingManager {
                 const yearlyVolume = typeof yearlyVolumeState?.val === 'number' ? yearlyVolumeState.val : 0;
                 const totalM3 = yearlyVolume + adjustment;
                 const brennwert = this.adapter.config.gasBrennwert || 11.5;
-                const zZahl = this.adapter.config.gasZahl || 0.95;
+                const zZahl = this.adapter.config.gasZahl || calculator.DEFAULTS.GAS_Z_ZAHL;
                 yearly = calculator.convertGasM3ToKWh(totalM3, brennwert, zZahl);
             } else {
                 yearly += adjustment;
@@ -67,7 +69,6 @@ class BillingManager {
         let dailyConsumptionCost, monthlyConsumptionCost, yearlyConsumptionCost;
 
         if (htNtEnabled) {
-            // HT/NT Calculation
             const htPrice = this.adapter.config[`${configType}HtPrice`] || 0;
             const ntPrice = this.adapter.config[`${configType}NtPrice`] || 0;
 
@@ -82,48 +83,27 @@ class BillingManager {
             if (adjustment !== 0) {
                 if (type === 'gas') {
                     const brennwert = this.adapter.config.gasBrennwert || 11.5;
-                    const zZahl = this.adapter.config.gasZahl || 0.95;
+                    const zZahl = this.adapter.config.gasZahl || calculator.DEFAULTS.GAS_Z_ZAHL;
                     yearlyHT = Number(yearlyHT) + calculator.convertGasM3ToKWh(adjustment, brennwert, zZahl);
                 } else {
                     yearlyHT = Number(yearlyHT) + Number(adjustment);
                 }
             }
 
-            dailyConsumptionCost = Number(dailyHT) * parseFloat(htPrice) + Number(dailyNT) * parseFloat(ntPrice);
-            monthlyConsumptionCost = Number(monthlyHT) * parseFloat(htPrice) + Number(monthlyNT) * parseFloat(ntPrice);
-            yearlyConsumptionCost = Number(yearlyHT) * parseFloat(htPrice) + Number(yearlyNT) * parseFloat(ntPrice);
+            const dailyRes = billingHelper.calculateHTNTCosts(dailyHT, htPrice, dailyNT, ntPrice);
+            const monthlyRes = billingHelper.calculateHTNTCosts(monthlyHT, htPrice, monthlyNT, ntPrice);
+            const yearlyRes = billingHelper.calculateHTNTCosts(yearlyHT, htPrice, yearlyNT, ntPrice);
 
-            // Update HT/NT specific cost states
-            await this.adapter.setStateAsync(
-                `${type}.costs.dailyHT`,
-                calculator.roundToDecimals(Number(dailyHT) * parseFloat(htPrice), 2),
-                true,
-            );
-            await this.adapter.setStateAsync(
-                `${type}.costs.dailyNT`,
-                calculator.roundToDecimals(Number(dailyNT) * calculator.ensureNumber(ntPrice), 2),
-                true,
-            );
-            await this.adapter.setStateAsync(
-                `${type}.costs.monthlyHT`,
-                calculator.roundToDecimals(Number(monthlyHT) * calculator.ensureNumber(htPrice), 2),
-                true,
-            );
-            await this.adapter.setStateAsync(
-                `${type}.costs.monthlyNT`,
-                calculator.roundToDecimals(Number(monthlyNT) * calculator.ensureNumber(ntPrice), 2),
-                true,
-            );
-            await this.adapter.setStateAsync(
-                `${type}.costs.yearlyHT`,
-                calculator.roundToDecimals(Number(yearlyHT) * calculator.ensureNumber(htPrice), 2),
-                true,
-            );
-            await this.adapter.setStateAsync(
-                `${type}.costs.yearlyNT`,
-                calculator.roundToDecimals(Number(yearlyNT) * calculator.ensureNumber(ntPrice), 2),
-                true,
-            );
+            dailyConsumptionCost = dailyRes.total;
+            monthlyConsumptionCost = monthlyRes.total;
+            yearlyConsumptionCost = yearlyRes.total;
+
+            await this.adapter.setStateAsync(`${type}.costs.dailyHT`, dailyRes.htCosts, true);
+            await this.adapter.setStateAsync(`${type}.costs.dailyNT`, dailyRes.ntCosts, true);
+            await this.adapter.setStateAsync(`${type}.costs.monthlyHT`, monthlyRes.htCosts, true);
+            await this.adapter.setStateAsync(`${type}.costs.monthlyNT`, monthlyRes.ntCosts, true);
+            await this.adapter.setStateAsync(`${type}.costs.yearlyHT`, yearlyRes.htCosts, true);
+            await this.adapter.setStateAsync(`${type}.costs.yearlyNT`, yearlyRes.ntCosts, true);
         } else {
             dailyConsumptionCost = calculator.calculateCost(daily, price);
             monthlyConsumptionCost = calculator.calculateCost(monthly, price);
@@ -131,40 +111,18 @@ class BillingManager {
         }
 
         // Basic charge calculation
-        const contractStartKey = `${configType}ContractStart`;
-        const contractStartDate = this.adapter.config[contractStartKey];
-
-        let monthsSinceContract;
-        if (contractStartDate) {
-            const contractStart = calculator.parseGermanDate(contractStartDate);
-            if (contractStart && !isNaN(contractStart.getTime())) {
-                const now = new Date();
-                const yDiff = now.getFullYear() - contractStart.getFullYear();
-                const mDiff = now.getMonth() - contractStart.getMonth();
-                monthsSinceContract = Math.max(1, yDiff * 12 + mDiff + 1);
-            }
-        }
-
-        if (monthsSinceContract === undefined) {
-            const yearStartState = await this.adapter.getStateAsync(`${type}.statistics.lastYearStart`);
-            const yearStartTime = typeof yearStartState?.val === 'number' ? yearStartState.val : Date.now();
-            const yearStart = new Date(yearStartTime);
-            const now = new Date();
-            const yDiff = now.getFullYear() - yearStart.getFullYear();
-            const mDiff = now.getMonth() - yearStart.getMonth();
-            monthsSinceContract = Math.max(1, yDiff * 12 + mDiff + 1);
-        }
-
-        // Calculate accumulated basic charge (monthly fee × months)
-        const basicChargeAccumulated = basicChargeMonthly * monthsSinceContract;
+        const monthsSinceContract = await this._calculateMonthsSinceStart(type, configType);
 
-        // Jahresgebühr ist ein FIXER Wert pro Jahr (z.B. 60€)
-        // NICHT pro-rata nach Monaten/Tagen berechnen!
-        const annualFeeAccumulated = annualFeePerYear;
-
-        const totalYearlyCost = yearlyConsumptionCost + basicChargeAccumulated + annualFeeAccumulated;
+        const charges = billingHelper.calculateAccumulatedCharges(
+            basicChargeMonthly,
+            annualFeePerYear,
+            monthsSinceContract,
+        );
+        const basicChargeAccumulated = charges.basicCharge;
+        const annualFeeAccumulated = charges.annualFee;
+        const totalYearlyCost = yearlyConsumptionCost + charges.total;
 
-        // Update states
+        // Update basic charge states
         await this.adapter.setStateAsync(
             `${type}.costs.daily`,
             calculator.roundToDecimals(dailyConsumptionCost, 2),
@@ -185,32 +143,39 @@ class BillingManager {
             calculator.roundToDecimals(totalYearlyCost, 2),
             true,
         );
-        await this.adapter.setStateAsync(
-            `${type}.costs.annualFee`,
-            calculator.roundToDecimals(annualFeeAccumulated, 2),
-            true,
-        );
-        // basicCharge enthält NUR die monatliche Grundgebühr (akkumuliert)
-        // Jahresgebühr ist separat in annualFee
-        await this.adapter.setStateAsync(
-            `${type}.costs.basicCharge`,
-            calculator.roundToDecimals(basicChargeAccumulated, 2),
-            true,
-        );
+        await this.adapter.setStateAsync(`${type}.costs.annualFee`, annualFeeAccumulated, true);
+        await this.adapter.setStateAsync(`${type}.costs.basicCharge`, basicChargeAccumulated, true);
 
-        // Abschlag
+        // Abschlag / Installment
         const abschlagKey = `${configType}Abschlag`;
         const monthlyAbschlag = this.adapter.config[abschlagKey] || 0;
 
-        if (monthlyAbschlag > 0) {
-            const paidTotal = monthlyAbschlag * monthsSinceContract;
-            const balance = totalYearlyCost - paidTotal;
-            await this.adapter.setStateAsync(`${type}.costs.paidTotal`, calculator.roundToDecimals(paidTotal, 2), true);
-            await this.adapter.setStateAsync(`${type}.costs.balance`, calculator.roundToDecimals(balance, 2), true);
-        } else {
-            await this.adapter.setStateAsync(`${type}.costs.paidTotal`, 0, true);
-            await this.adapter.setStateAsync(`${type}.costs.balance`, 0, true);
+        const balanceRes = billingHelper.calculateBalance(monthlyAbschlag, monthsSinceContract, totalYearlyCost);
+        await this.adapter.setStateAsync(`${type}.costs.paidTotal`, balanceRes.paid, true);
+        await this.adapter.setStateAsync(`${type}.costs.balance`, balanceRes.balance, true);
+    }
+
+    /**
+     * Calculates months since contract or year start
+     *
+     * @param {string} type - Utility type
+     * @param {string} configType - Mapped config type
+     * @returns {Promise<number>} Number of months (at least 1)
+     */
+    async _calculateMonthsSinceStart(type, configType) {
+        const contractStartDate = this.adapter.config[`${configType}ContractStart`];
+        let startDate;
+
+        if (contractStartDate) {
+            startDate = calculator.parseGermanDate(contractStartDate);
+        }
+
+        if (!startDate || isNaN(startDate.getTime())) {
+            const lastYearStart = await this.adapter.getStateAsync(`${type}.statistics.lastYearStart`);
+            startDate = new Date(lastYearStart?.val || Date.now());
         }
+
+        return Math.max(1, calculator.getMonthsDifference(startDate, new Date()) + 1);
     }
 
     /**
@@ -232,7 +197,7 @@ class BillingManager {
             return;
         }
 
-        const configType = this.adapter.consumptionManager.getConfigType(type);
+        const configType = getConfigType(type);
         const contractStartKey = `${configType}ContractStart`;
         const contractStart = this.adapter.config[contractStartKey];
 
@@ -454,11 +419,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);
@@ -548,7 +598,7 @@ class BillingManager {
         const types = ['gas', 'water', 'electricity', 'pv'];
 
         for (const type of types) {
-            const configType = this.adapter.consumptionManager.getConfigType(type);
+            const configType = getConfigType(type);
             if (!this.adapter.config[`${configType}Aktiv`]) {
                 continue;
             }
@@ -560,34 +610,126 @@ class BillingManager {
 
             const nowDate = new Date(now);
 
-            // DAILY RESET: All meters reset together at midnight
-            const lastDayStart = await this.adapter.getStateAsync(`${type}.statistics.lastDayStart`);
+            // Get all meters for this type (needed for all reset checks)
+            const meters = this.adapter.multiMeterManager?.getMetersForType(type) || [];
+
+            if (meters.length === 0) {
+                continue;
+            }
+
+            const firstMeter = meters[0];
+            const basePath = `${type}.${firstMeter.name}`;
+
+            // Reset time window: 23:59 (last minute of the day)
+            // This ensures History adapter sees clean day boundaries
+            const isResetTime = nowDate.getHours() === 23 && nowDate.getMinutes() === 59;
+
+            // 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 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`);
             if (lastDayStart?.val) {
-                const lastDay = new Date(lastDayStart.val);
-                if (nowDate.getDate() !== lastDay.getDate()) {
-                    await this.resetDailyCounters(type);
+                const lastResetTime = lastDayStart.val;
+                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, 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, catchUpTime);
                 }
             }
 
-            // MONTHLY RESET: All meters reset together on 1st of month
-            const lastMonthStart = await this.adapter.getStateAsync(`${type}.statistics.lastMonthStart`);
-            if (lastMonthStart?.val) {
-                const lastMonth = new Date(lastMonthStart.val);
-                if (nowDate.getMonth() !== lastMonth.getMonth()) {
-                    await this.resetMonthlyCounters(type);
+            // 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`);
+            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 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, 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, 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`);
+                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 && needsMonthlyReset) {
+                        this.adapter.log.info(`Monatlicher Reset für ${type} um 23:59`);
+                        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, catchUpTime);
+                    }
                 }
             }
 
             // YEARLY RESET: Each meter resets individually based on ITS contract date
-            const meters = this.adapter.multiMeterManager?.getMetersForType(type) || [];
+            // Trigger at 23:59 on the day BEFORE the anniversary (so the new year starts fresh)
             for (const meter of meters) {
-                const basePath = `${type}.${meter.name}`;
-                const lastYearStartState = await this.adapter.getStateAsync(`${basePath}.statistics.lastYearStart`);
+                const meterBasePath = `${type}.${meter.name}`;
+                const lastYearStartState = await this.adapter.getStateAsync(
+                    `${meterBasePath}.statistics.lastYearStart`,
+                );
 
                 if (lastYearStartState?.val) {
                     const lastYearStartDate = new Date(lastYearStartState.val);
-
-                    // Get contract date for THIS specific meter (all meters have config.contractStart)
                     const contractStartDate = meter.config?.contractStart;
 
                     if (contractStartDate) {
@@ -595,30 +737,69 @@ class BillingManager {
                         if (contractStart) {
                             const annMonth = contractStart.getMonth();
                             const annDay = contractStart.getDate();
-                            const isPast =
+
+                            // Check if today is the day BEFORE the anniversary (for 23:59 reset)
+                            // or if we're past it and haven't reset yet (catch-up)
+                            const anniversaryThisYear = new Date(nowDate.getFullYear(), annMonth, annDay);
+                            const dayBeforeAnniversary = new Date(anniversaryThisYear.getTime() - 24 * 60 * 60 * 1000);
+
+                            const isTodayDayBefore =
+                                nowDate.getMonth() === dayBeforeAnniversary.getMonth() &&
+                                nowDate.getDate() === dayBeforeAnniversary.getDate();
+
+                            const isPastAnniversary =
                                 nowDate.getMonth() > annMonth ||
                                 (nowDate.getMonth() === annMonth && nowDate.getDate() >= annDay);
 
-                            if (isPast && lastYearStartDate.getFullYear() !== nowDate.getFullYear()) {
+                            const needsReset = lastYearStartDate.getFullYear() < nowDate.getFullYear();
+
+                            if (isTodayDayBefore && isResetTime && needsReset) {
                                 this.adapter.log.info(
-                                    `Yearly reset for ${basePath} (contract anniversary: ${contractStartDate})`,
+                                    `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, catchUpTime);
 
-                                // Update totals if multiple meters exist
                                 if (meters.length > 1) {
                                     await this.adapter.multiMeterManager.updateTotalCosts(type);
                                 }
                             }
                         }
-                    } else if (nowDate.getFullYear() !== lastYearStartDate.getFullYear()) {
-                        // No contract date: reset on January 1st
-                        this.adapter.log.info(`Yearly reset for ${basePath} (calendar year)`);
-                        await this.resetYearlyCountersForMeter(type, meter);
-
-                        // Update totals if multiple meters exist
-                        if (meters.length > 1) {
-                            await this.adapter.multiMeterManager.updateTotalCosts(type);
+                    } else {
+                        // No contract date: reset at 23:59 on December 31st (or catch up in January)
+                        const isDecember31 = nowDate.getMonth() === 11 && nowDate.getDate() === 31;
+                        const needsReset = nowDate.getFullYear() > lastYearStartDate.getFullYear();
+
+                        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, 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, catchUpTime);
+
+                            if (meters.length > 1) {
+                                await this.adapter.multiMeterManager.updateTotalCosts(type);
+                            }
                         }
                     }
                 }
@@ -630,8 +811,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)
@@ -666,7 +848,7 @@ class BillingManager {
             }
 
             // Reset HT/NT daily counters if enabled
-            const configType = this.adapter.consumptionManager.getConfigType(type);
+            const configType = getConfigType(type);
             const htNtEnabled = this.adapter.config[`${configType}HtNtEnabled`] || false;
             if (htNtEnabled) {
                 const dailyHT = await this.adapter.getStateAsync(`${basePath}.consumption.dailyHT`);
@@ -679,8 +861,9 @@ class BillingManager {
 
             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.lastDayStart`, timestamp, true);
 
             await this.adapter.setStateAsync(
                 `${basePath}.statistics.averageDaily`,
@@ -699,8 +882,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)
@@ -718,17 +902,26 @@ class BillingManager {
 
             this.adapter.log.debug(`Resetting monthly counter for ${basePath} (${label})`);
 
+            // Get current values before reset
             const monthlyState = await this.adapter.getStateAsync(`${basePath}.consumption.monthly`);
             const monthlyValue = monthlyState?.val || 0;
 
-            await this.adapter.setStateAsync(`${basePath}.consumption.monthly`, 0, true);
+            // Save last month consumption
+            await this.adapter.setStateAsync(`${basePath}.statistics.lastMonth`, monthlyValue, 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}.consumption.monthlyVolume`, 0, true);
             }
 
+            // Reset monthly counters
+            await this.adapter.setStateAsync(`${basePath}.consumption.monthly`, 0, true);
+
             // Reset HT/NT monthly counters if enabled
-            const configType = this.adapter.consumptionManager.getConfigType(type);
+            const configType = getConfigType(type);
             const htNtEnabled = this.adapter.config[`${configType}HtNtEnabled`] || false;
             if (htNtEnabled) {
                 await this.adapter.setStateAsync(`${basePath}.consumption.monthlyHT`, 0, true);
@@ -737,8 +930,9 @@ class BillingManager {
 
             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.lastMonthStart`, timestamp, true);
 
             await this.adapter.setStateAsync(
                 `${basePath}.statistics.averageMonthly`,
@@ -801,8 +995,9 @@ 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;
 
@@ -818,8 +1013,58 @@ class BillingManager {
         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.lastYearStart`, timestamp, true);
+    }
+
+    /**
+     * Resets weekly counters
+     *
+     * @param {string} type - Utility type
+     * @param {number} [resetTimestamp] - Optional normalized timestamp (defaults to Date.now())
+     */
+    async resetWeeklyCounters(type, resetTimestamp) {
+        this.adapter.log.info(`Resetting weekly counters for ${type}`);
+
+        const meters = this.adapter.multiMeterManager?.getMetersForType(type) || [];
+        for (const meter of meters) {
+            const basePath = `${type}.${meter.name}`;
+
+            // 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);
+
+            // 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}.consumption.weeklyVolume`, 0, true);
+            }
+
+            // Reset weekly counters
+            await this.adapter.setStateAsync(`${basePath}.consumption.weekly`, 0, true);
+            await this.adapter.setStateAsync(`${basePath}.costs.weekly`, 0, true);
+
+            const configType = getConfigType(type);
+            const htNtEnabled = this.adapter.config[`${configType}HtNtEnabled`] || false;
+            if (htNtEnabled) {
+                await this.adapter.setStateAsync(`${basePath}.consumption.weeklyHT`, 0, true);
+                await this.adapter.setStateAsync(`${basePath}.consumption.weeklyNT`, 0, true);
+                await this.adapter.setStateAsync(`${basePath}.costs.weeklyHT`, 0, true);
+                await this.adapter.setStateAsync(`${basePath}.costs.weeklyNT`, 0, true);
+            }
+
+            // Update lastWeekStart timestamp (use normalized timestamp if provided)
+            const timestamp = resetTimestamp || Date.now();
+            await this.adapter.setStateAsync(`${basePath}.statistics.lastWeekStart`, timestamp, true);
+        }
+
+        if (meters.length > 1) {
+            await this.adapter.multiMeterManager.updateTotalCosts(type);
+        }
     }
 }