iobroker.utility-monitor 1.4.6 → 1.5.1

package/lib/multiMeterManager.js

@@ -3,6 +3,14 @@
 const calculator = require('./calculator');
 const stateManager = require('./stateManager');
 const { parseConfigNumber } = require('./configParser');
+const { getConfigType } = require('./utils/typeMapper');
+const MeterRegistry = require('./meter/MeterRegistry');
+const helpers = require('./utils/helpers');
+const consumptionHelper = require('./utils/consumptionHelper');
+const billingHelper = require('./utils/billingHelper');
+
+// Default constants
+const DEFAULT_SPIKE_THRESHOLD = 500; // Default sensor spike detection limit
 
 /**
  * MultiMeterManager handles multiple meters per utility type
@@ -19,41 +27,19 @@ class MultiMeterManager {
         this.consumptionManager = consumptionManager;
         this.billingManager = billingManager;
         this.lastSensorValues = {};
-        this.meterRegistry = {}; // Maps sensorDP → {type, meterName}
+        this.meterRegistry = new MeterRegistry();
+        this.tempBaselineStore = {}; // Tracks first value after start to prevent peaks
     }
 
     /**
      * Maps internal utility type to config/state name
      *
+     * @deprecated Use getConfigType from utils/typeMapper directly
      * @param {string} type - gas, water, or electricity
      * @returns {string} - gas, wasser, or strom
      */
     getConfigType(type) {
-        const mapping = {
-            electricity: 'strom',
-            water: 'wasser',
-            gas: 'gas',
-        };
-        return mapping[type] || type;
-    }
-
-    /**
-     * Normalizes meter name to valid folder name
-     * Rules: lowercase, alphanumeric only, max 20 chars
-     *
-     * @param {string} name - User-provided meter name
-     * @returns {string} - Normalized name
-     */
-    normalizeMeterName(name) {
-        if (!name || typeof name !== 'string') {
-            return 'unnamed';
-        }
-        return (
-            name
-                .toLowerCase()
-                .replace(/[^a-z0-9]/g, '')
-                .substring(0, 20) || 'unnamed'
-        );
+        return getConfigType(type);
     }
 
     /**
@@ -72,7 +58,7 @@ class MultiMeterManager {
         if (mainActive) {
             // Get main meter name from config and normalize
             const mainMeterName = this.adapter.config[`${configType}MainMeterName`] || 'main';
-            const normalizedName = this.normalizeMeterName(mainMeterName);
+            const normalizedName = helpers.normalizeMeterName(mainMeterName);
             const displayName = mainMeterName; // Original name for display
 
             meters.push({
@@ -97,7 +83,7 @@ class MultiMeterManager {
         if (Array.isArray(additionalMeters)) {
             for (const meterConfig of additionalMeters) {
                 if (meterConfig && meterConfig.name && meterConfig.sensorDP) {
-                    const normalizedName = this.normalizeMeterName(meterConfig.name);
+                    const normalizedName = helpers.normalizeMeterName(meterConfig.name);
 
                     // Debug: Log raw config for troubleshooting
                     this.adapter.log.debug(
@@ -129,13 +115,13 @@ class MultiMeterManager {
     }
 
     /**
-     * Finds meter by sensor datapoint
+     * Finds meters by sensor datapoint
      *
      * @param {string} sensorDP - Sensor datapoint ID
-     * @returns {object|null} - {type, meterName} or null
+     * @returns {Array} - Array of {type, meterName} objects
      */
     findMeterBySensor(sensorDP) {
-        return this.meterRegistry[sensorDP] || null;
+        return this.meterRegistry.findBySensor(sensorDP);
     }
 
     /**
@@ -186,15 +172,24 @@ class MultiMeterManager {
 
         if (!config.sensorDP) {
             this.adapter.log.warn(`${type} meter "${label}" has no sensor datapoint configured!`);
-            await this.adapter.setStateAsync(`${basePath}.info.sensorActive`, false, true);
+            try {
+                await this.adapter.setStateAsync(`${basePath}.info.sensorActive`, false, true);
+            } catch (error) {
+                this.adapter.log.warn(`Could not set sensorActive state for ${basePath}: ${error.message}`);
+            }
             return;
         }
 
-        // Create state structure
-        await stateManager.createMeterStructure(this.adapter, type, meterName, config);
+        // Create state structure with error handling
+        try {
+            await stateManager.createMeterStructure(this.adapter, type, meterName, config);
+        } catch (error) {
+            this.adapter.log.error(`Failed to create state structure for ${basePath}: ${error.message}`);
+            return;
+        }
 
-        // Register sensor in registry
-        this.meterRegistry[config.sensorDP] = { type, meterName };
+        // Register sensor mapping
+        this.meterRegistry.register(config.sensorDP, type, meterName);
 
         this.adapter.log.debug(`Using sensor datapoint for ${type}.${meterName}: ${config.sensorDP}`);
 
@@ -218,8 +213,10 @@ class MultiMeterManager {
         // Initialize with current sensor value
         try {
             const sensorState = await this.adapter.getForeignStateAsync(config.sensorDP);
-            if (sensorState && sensorState.val !== null && typeof sensorState.val === 'number') {
-                await this.handleSensorUpdate(type, meterName, config.sensorDP, sensorState.val);
+            if (sensorState && sensorState.val != null) {
+                // Convert to number (handles strings, German commas, etc.)
+                const numValue = calculator.ensureNumber(sensorState.val);
+                await this.handleSensorUpdate(type, meterName, config.sensorDP, numValue);
             }
         } catch (error) {
             this.adapter.log.warn(`Could not read initial value from ${config.sensorDP}: ${error.message}`);
@@ -227,7 +224,7 @@ class MultiMeterManager {
         }
 
         // Initialize period start timestamps
-        const timestampRoles = ['lastDayStart', 'lastMonthStart', 'lastYearStart'];
+        const timestampRoles = ['lastDayStart', 'lastWeekStart', 'lastMonthStart', 'lastYearStart'];
 
         for (const role of timestampRoles) {
             const statePath = `${basePath}.statistics.${role}`;
@@ -270,37 +267,9 @@ class MultiMeterManager {
             }
         }
 
-        // Initialize yearly consumption from initial reading if set
-        if (config.initialReading > 0) {
-            const sensorState = await this.adapter.getForeignStateAsync(config.sensorDP);
-            if (sensorState && typeof sensorState.val === 'number') {
-                let currentRaw = sensorState.val;
-
-                if (config.offset !== 0) {
-                    currentRaw = currentRaw - config.offset;
-                    this.adapter.log.debug(
-                        `Applied offset for ${type}.${meterName}: -${config.offset}, new value: ${currentRaw}`,
-                    );
-                }
-                let yearlyConsumption = Math.max(0, currentRaw - config.initialReading);
-
-                // For gas: convert m³ to kWh
-                if (type === 'gas') {
-                    const brennwert = this.adapter.config.gasBrennwert || calculator.DEFAULTS.GAS_BRENNWERT;
-                    const zZahl = this.adapter.config.gasZahl || calculator.DEFAULTS.GAS_Z_ZAHL;
-                    const yearlyVolume = yearlyConsumption;
-                    yearlyConsumption = calculator.convertGasM3ToKWh(yearlyConsumption, brennwert, zZahl);
-                    await this.adapter.setStateAsync(`${basePath}.consumption.yearlyVolume`, yearlyVolume, true);
-                    this.adapter.log.info(
-                        `Init yearly ${type}.${meterName}: ${yearlyConsumption.toFixed(2)} kWh = ${(currentRaw - config.initialReading).toFixed(2)} m³`,
-                    );
-                } else {
-                    this.adapter.log.info(`Init yearly ${type}.${meterName}: ${yearlyConsumption.toFixed(2)}`);
-                }
-
-                await this.adapter.setStateAsync(`${basePath}.consumption.yearly`, yearlyConsumption, true);
-            }
-        }
+        // NOTE: Initial yearly consumption is calculated in handleSensorUpdate()
+        // which is called immediately after this initialization (line 224)
+        // This avoids race conditions where state objects aren't fully created yet
 
         // Update current price
         await this.updateCurrentPrice(type, meterName, config);
@@ -338,9 +307,144 @@ class MultiMeterManager {
         // Initial cost calculation
         await this.updateCosts(type, meterName, config);
 
+        // Reconstruct weekly consumption from daily values if needed
+        await this.reconstructPeriodConsumption(type, meterName, basePath);
+
         this.adapter.log.debug(`Meter initialization completed for ${type}.${meterName}`);
     }
 
+    /**
+     * Reconstructs weekly and monthly consumption values after adapter restart
+     * This fixes data loss when adapter was offline and missed delta accumulation
+     *
+     * @param {string} type - Utility type
+     * @param {string} meterName - Meter name
+     * @param {string} basePath - State base path
+     */
+    async reconstructPeriodConsumption(type, meterName, basePath) {
+        const now = Date.now();
+
+        // Get period start timestamps
+        const lastWeekStartState = await this.adapter.getStateAsync(`${basePath}.statistics.lastWeekStart`);
+        const lastDayStartState = await this.adapter.getStateAsync(`${basePath}.statistics.lastDayStart`);
+
+        if (!lastWeekStartState?.val || !lastDayStartState?.val) {
+            this.adapter.log.debug(`[${basePath}] No period timestamps found, skipping reconstruction`);
+            return;
+        }
+
+        const lastWeekStart = lastWeekStartState.val;
+        const lastDayStart = lastDayStartState.val;
+
+        // Calculate days since week start
+        const daysSinceWeekStart = (now - lastWeekStart) / (24 * 60 * 60 * 1000);
+
+        // Only reconstruct if we're within a valid week (0-7 days)
+        if (daysSinceWeekStart < 0 || daysSinceWeekStart > 7) {
+            this.adapter.log.debug(
+                `[${basePath}] Week period out of range (${daysSinceWeekStart.toFixed(1)} days), skipping reconstruction`,
+            );
+            return;
+        }
+
+        // Get current consumption values
+        const weeklyState = await this.adapter.getStateAsync(`${basePath}.consumption.weekly`);
+        const dailyState = await this.adapter.getStateAsync(`${basePath}.consumption.daily`);
+        const lastDayState = await this.adapter.getStateAsync(`${basePath}.statistics.lastDay`);
+
+        const currentWeekly = weeklyState?.val || 0;
+        const currentDaily = dailyState?.val || 0;
+        const lastDay = lastDayState?.val || 0;
+
+        // Calculate expected weekly based on lastDay values accumulated since lastWeekStart
+        // Simple approach: If daily counter was reset today and we have lastDay,
+        // weekly should be at least lastDay + currentDaily
+        const daysSinceDayReset = (now - lastDayStart) / (24 * 60 * 60 * 1000);
+
+        // If daily was reset (daysSinceDayReset < 1) and weekly seems too low
+        if (daysSinceDayReset < 1 && currentWeekly < lastDay + currentDaily) {
+            // Weekly might have missed the lastDay value
+            // This can happen if adapter restarted after daily reset
+            const reconstructedWeekly = calculator.roundToDecimals(currentWeekly + lastDay, 2);
+
+            if (reconstructedWeekly > currentWeekly) {
+                this.adapter.log.info(
+                    `[${basePath}] Reconstructing weekly: ${currentWeekly} -> ${reconstructedWeekly} (added lastDay: ${lastDay})`,
+                );
+                await this.adapter.setStateAsync(`${basePath}.consumption.weekly`, reconstructedWeekly, true);
+
+                // Also reconstruct gas volume if applicable
+                if (type === 'gas') {
+                    const weeklyVolumeState = await this.adapter.getStateAsync(`${basePath}.consumption.weeklyVolume`);
+                    const lastDayVolumeState = await this.adapter.getStateAsync(`${basePath}.statistics.lastDayVolume`);
+                    const currentWeeklyVolume = weeklyVolumeState?.val || 0;
+                    const lastDayVolume = lastDayVolumeState?.val || 0;
+
+                    if (lastDayVolume > 0) {
+                        const reconstructedWeeklyVolume = calculator.roundToDecimals(
+                            currentWeeklyVolume + lastDayVolume,
+                            4,
+                        );
+                        await this.adapter.setStateAsync(
+                            `${basePath}.consumption.weeklyVolume`,
+                            reconstructedWeeklyVolume,
+                            true,
+                        );
+                    }
+                }
+            }
+        }
+
+        // Similar logic for monthly reconstruction
+        const lastMonthStartState = await this.adapter.getStateAsync(`${basePath}.statistics.lastMonthStart`);
+        if (lastMonthStartState?.val) {
+            const lastMonthStart = lastMonthStartState.val;
+            const daysSinceMonthStart = (now - lastMonthStart) / (24 * 60 * 60 * 1000);
+
+            // Only if within valid month range (0-31 days)
+            if (daysSinceMonthStart >= 0 && daysSinceMonthStart <= 31) {
+                const monthlyState = await this.adapter.getStateAsync(`${basePath}.consumption.monthly`);
+                const currentMonthly = monthlyState?.val || 0;
+
+                // If daily was reset and monthly seems to be missing the lastDay
+                if (daysSinceDayReset < 1 && currentMonthly < lastDay + currentDaily) {
+                    const reconstructedMonthly = calculator.roundToDecimals(currentMonthly + lastDay, 2);
+
+                    if (reconstructedMonthly > currentMonthly) {
+                        this.adapter.log.info(
+                            `[${basePath}] Reconstructing monthly: ${currentMonthly} -> ${reconstructedMonthly} (added lastDay: ${lastDay})`,
+                        );
+                        await this.adapter.setStateAsync(`${basePath}.consumption.monthly`, reconstructedMonthly, true);
+
+                        // Also reconstruct gas volume if applicable
+                        if (type === 'gas') {
+                            const monthlyVolumeState = await this.adapter.getStateAsync(
+                                `${basePath}.consumption.monthlyVolume`,
+                            );
+                            const lastDayVolumeState = await this.adapter.getStateAsync(
+                                `${basePath}.statistics.lastDayVolume`,
+                            );
+                            const currentMonthlyVolume = monthlyVolumeState?.val || 0;
+                            const lastDayVolume = lastDayVolumeState?.val || 0;
+
+                            if (lastDayVolume > 0) {
+                                const reconstructedMonthlyVolume = calculator.roundToDecimals(
+                                    currentMonthlyVolume + lastDayVolume,
+                                    4,
+                                );
+                                await this.adapter.setStateAsync(
+                                    `${basePath}.consumption.monthlyVolume`,
+                                    reconstructedMonthlyVolume,
+                                    true,
+                                );
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     /**
      * Handles sensor value updates
      *
@@ -356,7 +460,9 @@ class MultiMeterManager {
         }
 
         const basePath = `${type}.${meterName}`;
-        this.adapter.log.debug(`Sensor update for ${basePath}: ${value}`);
+        this.adapter.log.debug(`[${basePath}] handleSensorUpdate: value=${value}, sensorDP=${sensorDP}`);
+
+        const now = Date.now();
 
         // Get meter config
         const meters = this.getMetersForType(type);
@@ -367,92 +473,328 @@ class MultiMeterManager {
         }
 
         const config = meter.config;
-        const now = Date.now();
+
+        // Pre-process consumption value (offset, gas conversion)
+        const processed = await this._preprocessValue(type, value, config);
+        const { consumption, consumptionM3 } = processed;
+
+        // 1. Initialization Logic (Per Session)
+        if (this.lastSensorValues[sensorDP] === undefined) {
+            await this._handleFirstSensorValue(type, meterName, sensorDP, processed, basePath, config, now);
+            return;
+        }
+
+        // 2. Update meter reading states
+        await this.adapter.setStateAsync(`${basePath}.info.meterReading`, consumption, true);
+        if (type === 'gas') {
+            await this.adapter.setStateAsync(`${basePath}.info.meterReadingVolume`, consumptionM3 || 0, true);
+        }
+
+        // 3. Delta Calibration & Spike Protection
+        const lastValue = this.lastSensorValues[sensorDP];
+        this.lastSensorValues[sensorDP] = consumption;
+
+        if (consumption < lastValue) {
+            await this._handleMeterReset(type, meterName, lastValue, consumption, config);
+            return;
+        }
+
+        const delta = calculator.roundToDecimals(consumption - lastValue, 4);
+        if (delta <= 0) {
+            return;
+        }
+
+        const spikeThreshold = this.adapter.config.sensorSpikeThreshold || DEFAULT_SPIKE_THRESHOLD;
+        if (delta > spikeThreshold) {
+            await this._handleSuspiciousDelta(
+                type,
+                meterName,
+                delta,
+                consumption,
+                consumptionM3,
+                config,
+                basePath,
+                now,
+            );
+            return;
+        }
+
+        this.adapter.log.debug(`${type}.${meterName} delta: ${delta}`);
+
+        // 4. Update Consumption Values (Daily, Weekly, Monthly)
+        const deltaVolume =
+            type === 'gas'
+                ? delta /
+                  ((this.adapter.config.gasBrennwert || calculator.DEFAULTS.GAS_BRENNWERT) *
+                      (this.adapter.config.gasZahl || calculator.DEFAULTS.GAS_Z_ZAHL))
+                : 0;
+        await this._updateTotalConsumptionStates(basePath, type, delta, deltaVolume);
+
+        // 5. HT/NT Tracking
+        await this._updateHTNTConsumptionStates(basePath, type, delta, config);
+
+        // 6. Yearly & Costs
+        const yearlyAmountFinal = await this._updateYearlyConsumption(
+            type,
+            meterName,
+            config,
+            consumption,
+            consumptionM3,
+            delta,
+            basePath,
+        );
+
+        await this.updateCosts(type, meterName, config, yearlyAmountFinal);
+        await this.updateTotalCosts(type);
+
+        await this.adapter.setStateAsync(`${basePath}.consumption.lastUpdate`, now, true);
+        await this.adapter.setStateAsync(`${basePath}.info.lastSync`, now, true);
+    }
+
+    /**
+     * Preprocesses raw sensor value (offset, gas conversion)
+     *
+     * @param {string} type - Utility type
+     * @param {number} value - Raw sensor value
+     * @param {object} config - Meter configuration
+     * @returns {Promise<{consumption: number, consumptionM3: number|null}>} Processed values
+     */
+    async _preprocessValue(type, value, config) {
         let consumption = value;
         let consumptionM3 = null;
 
-        this.adapter.log.debug(`[${basePath}] Sensor update: raw=${value}, offset=${config.offset}`);
-
-        // Apply offset FIRST
         if (config.offset !== 0) {
             consumption = consumption - config.offset;
-            this.adapter.log.debug(`[${basePath}] After offset: ${consumption}`);
         }
 
-        // For gas, convert m³ to kWh
         if (type === 'gas') {
             const brennwert = this.adapter.config.gasBrennwert || calculator.DEFAULTS.GAS_BRENNWERT;
             const zZahl = this.adapter.config.gasZahl || calculator.DEFAULTS.GAS_Z_ZAHL;
-            consumptionM3 = consumption;
-            await this.adapter.setStateAsync(`${basePath}.info.meterReadingVolume`, consumption, true);
-            consumption = calculator.convertGasM3ToKWh(consumption, brennwert, zZahl);
-            consumption = calculator.roundToDecimals(consumption, 2);
-        }
 
-        // Update meter reading
-        await this.adapter.setStateAsync(`${basePath}.info.meterReading`, consumption, true);
+            const res = consumptionHelper.calculateGas(consumption, brennwert, zZahl);
+            consumptionM3 = res.volume;
+            consumption = res.energy;
+        }
 
-        // Calculate deltas
-        const lastValue = this.lastSensorValues[sensorDP];
-        this.lastSensorValues[sensorDP] = consumption;
+        return { consumption, consumptionM3 };
+    }
 
-        if (lastValue === undefined || consumption <= lastValue) {
-            if (lastValue !== undefined && consumption < lastValue) {
+    /**
+     * Handles the very first sensor value in a session (recovery or initial)
+     *
+     * @param {string} type - Utility type
+     * @param {string} meterName - Meter name
+     * @param {string} sensorDP - Sensor data point path
+     * @param {object} processed - Processed consumption values
+     * @param {string} basePath - State base path
+     * @param {object} config - Meter configuration
+     * @param {number} now - Current timestamp
+     */
+    async _handleFirstSensorValue(type, meterName, sensorDP, processed, basePath, config, now) {
+        const { consumption, consumptionM3 } = processed;
+        const currentState = await this.adapter.getStateAsync(`${basePath}.info.meterReading`);
+        const recoveredValue = currentState?.val ?? 0;
+
+        if (recoveredValue > 0 && Math.abs(consumption - recoveredValue) < 100) {
+            this.adapter.log.info(`[${basePath}] Recovered persistent baseline: ${recoveredValue}`);
+            this.lastSensorValues[sensorDP] = recoveredValue;
+
+            // Validate period consumption values against spike threshold
+            // This catches cases where old consumption values are unrealistically high
+            await this._validatePeriodConsumption(type, basePath, now);
+        } else {
+            if (recoveredValue > 0) {
                 this.adapter.log.warn(
-                    `${type}.${meterName}: Sensor value decreased (${lastValue} -> ${consumption}). Assuming meter reset.`,
+                    `[${basePath}] Recovered state (${recoveredValue}) differs significantly from new value (${consumption}).`,
+                );
+            } else {
+                this.adapter.log.info(
+                    `[${basePath}] No previous reading found. Setting initial baseline to ${consumption}`,
                 );
             }
-            await this.updateCosts(type, meterName, config);
-            await this.updateTotalCosts(type);
-            return;
+            this.lastSensorValues[sensorDP] = consumption;
+            await this.adapter.setStateAsync(`${basePath}.info.meterReading`, consumption, true);
+            if (type === 'gas') {
+                await this.adapter.setStateAsync(`${basePath}.info.meterReadingVolume`, consumptionM3 || 0, true);
+            }
+
+            // On baseline reset, validate and potentially reset period consumption values
+            await this._validatePeriodConsumption(type, basePath, now);
+
+            if (config.initialReading > 0) {
+                await this.calculateAbsoluteYearly(type, meterName, config, consumption, consumptionM3 || 0, now);
+                await this.updateCosts(type, meterName, config);
+                await this.updateTotalCosts(type);
+            }
         }
+        await this.adapter.setStateAsync(`${basePath}.info.lastSync`, now, true);
+        await this.adapter.setStateAsync(`${basePath}.consumption.lastUpdate`, now, true);
+    }
 
-        const delta = consumption - lastValue;
-        this.adapter.log.debug(`${type}.${meterName} delta: ${delta}`);
+    /**
+     * Validates period consumption values and resets them if they exceed the spike threshold.
+     * This prevents unrealistic values after adapter restart or database inconsistencies.
+     *
+     * @param {string} type - Utility type
+     * @param {string} basePath - State base path
+     * @param {number} now - Current timestamp
+     */
+    async _validatePeriodConsumption(type, basePath, now) {
+        const spikeThreshold = this.adapter.config.sensorSpikeThreshold || DEFAULT_SPIKE_THRESHOLD;
+
+        // Check and reset period consumption values that exceed the spike threshold
+        const periods = ['daily', 'weekly', 'monthly'];
+        for (const period of periods) {
+            const state = await this.adapter.getStateAsync(`${basePath}.consumption.${period}`);
+            const value = state?.val || 0;
+
+            // Get period start timestamp to calculate expected max consumption
+            const periodStartState = await this.adapter.getStateAsync(
+                `${basePath}.statistics.last${period.charAt(0).toUpperCase() + period.slice(1)}Start`,
+            );
+            const periodStart = periodStartState?.val || now;
+            const daysSincePeriodStart = (now - periodStart) / (24 * 60 * 60 * 1000);
 
-        // Track volume for gas
-        if (type === 'gas') {
-            const brennwert = this.adapter.config.gasBrennwert || calculator.DEFAULTS.GAS_BRENNWERT;
-            const zZahl = this.adapter.config.gasZahl || calculator.DEFAULTS.GAS_Z_ZAHL;
-            const deltaVolume = delta / (brennwert * zZahl);
+            // Calculate reasonable max: spike threshold per day * days in period
+            // Add buffer of 2x for safety
+            const maxReasonableConsumption = spikeThreshold * Math.max(1, daysSincePeriodStart) * 2;
+
+            if (value > maxReasonableConsumption) {
+                this.adapter.log.warn(
+                    `[${basePath}] Resetting ${period} consumption: ${value} exceeds reasonable max of ${maxReasonableConsumption.toFixed(0)} (${daysSincePeriodStart.toFixed(1)} days * ${spikeThreshold} threshold * 2)`,
+                );
+                await this.adapter.setStateAsync(`${basePath}.consumption.${period}`, 0, true);
 
-            const dailyVolume = await this.adapter.getStateAsync(`${basePath}.consumption.dailyVolume`);
-            const monthlyVolume = await this.adapter.getStateAsync(`${basePath}.consumption.monthlyVolume`);
-            const yearlyVolume = await this.adapter.getStateAsync(`${basePath}.consumption.yearlyVolume`);
+                // Also reset volume states for gas
+                if (type === 'gas') {
+                    await this.adapter.setStateAsync(`${basePath}.consumption.${period}Volume`, 0, true);
+                }
+            }
+        }
+    }
+
+    /**
+     * Handles meter reset or replacement condition
+     *
+     * @param {string} type - Utility type
+     * @param {string} meterName - Meter name
+     * @param {number} lastValue - Previous sensor value
+     * @param {number} consumption - Current consumption value
+     * @param {object} config - Meter configuration
+     */
+    async _handleMeterReset(type, meterName, lastValue, consumption, config) {
+        this.adapter.log.warn(
+            `${type}.${meterName}: Zählerstand gesunken (${lastValue} -> ${consumption}). Gehe von Zählerwechsel oder Reset aus.`,
+        );
+        await this.updateCosts(type, meterName, config);
+        await this.updateTotalCosts(type);
+    }
 
+    /**
+     * Handles suspicious delta (spike detection)
+     *
+     * @param {string} type - Utility type
+     * @param {string} meterName - Meter name
+     * @param {number} delta - Calculated delta
+     * @param {number} consumption - Current consumption value
+     * @param {number|null} consumptionM3 - Current gas volume
+     * @param {object} config - Meter configuration
+     * @param {string} basePath - State base path
+     * @param {number} now - Current timestamp
+     */
+    async _handleSuspiciousDelta(type, meterName, delta, consumption, consumptionM3, config, basePath, now) {
+        this.adapter.log.warn(`[${basePath}] Discarding suspicious delta of ${delta}. Treating as baseline reset.`);
+        if (config.initialReading > 0) {
+            await this.calculateAbsoluteYearly(type, meterName, config, consumption, consumptionM3 || 0, now);
+        }
+    }
+
+    /**
+     * Updates all period consumption states
+     *
+     * @param {string} basePath - State base path
+     * @param {string} type - Utility type
+     * @param {number} delta - Consumption delta
+     * @param {number} deltaVolume - Gas volume delta
+     */
+    async _updateTotalConsumptionStates(basePath, type, delta, deltaVolume) {
+        const periods = ['daily', 'weekly', 'monthly'];
+        for (const period of periods) {
+            const state = await this.adapter.getStateAsync(`${basePath}.consumption.${period}`);
             await this.adapter.setStateAsync(
-                `${basePath}.consumption.dailyVolume`,
-                calculator.roundToDecimals((dailyVolume?.val || 0) + deltaVolume, 2),
+                `${basePath}.consumption.${period}`,
+                calculator.roundToDecimals((state?.val || 0) + delta, 2),
                 true,
             );
+
+            if (type === 'gas' && deltaVolume > 0) {
+                const volState = await this.adapter.getStateAsync(`${basePath}.consumption.${period}Volume`);
+                await this.adapter.setStateAsync(
+                    `${basePath}.consumption.${period}Volume`,
+                    calculator.roundToDecimals((volState?.val || 0) + deltaVolume, 2),
+                    true,
+                );
+            }
+        }
+    }
+
+    /**
+     * Updates HT/NT specific consumption states
+     *
+     * @param {string} basePath - State base path
+     * @param {string} type - Utility type
+     * @param {number} delta - Consumption delta
+     * @param {object} config - Meter configuration
+     */
+    async _updateHTNTConsumptionStates(basePath, type, delta, config) {
+        if (!config.htNtEnabled) {
+            return;
+        }
+
+        const configType = this.getConfigType(type);
+        const suffix = consumptionHelper.getHTNTSuffix(this.adapter.config, configType);
+        if (!suffix) {
+            return;
+        }
+
+        const periods = ['daily', 'weekly', 'monthly'];
+        for (const period of periods) {
+            const state = await this.adapter.getStateAsync(`${basePath}.consumption.${period}${suffix}`);
             await this.adapter.setStateAsync(
-                `${basePath}.consumption.monthlyVolume`,
-                calculator.roundToDecimals((monthlyVolume?.val || 0) + deltaVolume, 2),
+                `${basePath}.consumption.${period}${suffix}`,
+                calculator.roundToDecimals((state?.val || 0) + delta, 2),
                 true,
             );
+        }
+
+        if (type === 'gas') {
+            const brennwert = this.adapter.config.gasBrennwert || calculator.DEFAULTS.GAS_BRENNWERT;
+            const zZahl = this.adapter.config.gasZahl || calculator.DEFAULTS.GAS_Z_ZAHL;
+            const deltaVolume = delta / (brennwert * zZahl);
+
+            const state = await this.adapter.getStateAsync(`${basePath}.consumption.weeklyVolume${suffix}`);
             await this.adapter.setStateAsync(
-                `${basePath}.consumption.yearlyVolume`,
-                calculator.roundToDecimals((yearlyVolume?.val || 0) + deltaVolume, 3),
+                `${basePath}.consumption.weeklyVolume${suffix}`,
+                calculator.roundToDecimals((state?.val || 0) + deltaVolume, 2),
                 true,
             );
         }
+    }
 
-        // Update consumption values
-        const dailyState = await this.adapter.getStateAsync(`${basePath}.consumption.daily`);
-        await this.adapter.setStateAsync(
-            `${basePath}.consumption.daily`,
-            calculator.roundToDecimals((dailyState?.val || 0) + delta, 2),
-            true,
-        );
-
-        const monthlyState = await this.adapter.getStateAsync(`${basePath}.consumption.monthly`);
-        await this.adapter.setStateAsync(
-            `${basePath}.consumption.monthly`,
-            calculator.roundToDecimals((monthlyState?.val || 0) + delta, 2),
-            true,
-        );
-
-        // Yearly consumption
+    /**
+     * Updates yearly consumption
+     *
+     * @param {string} type - Utility type
+     * @param {string} meterName - Meter name
+     * @param {object} config - Meter configuration
+     * @param {number} consumption - Current consumption value
+     * @param {number|null} consumptionM3 - Current gas volume
+     * @param {number} delta - Consumption delta
+     * @param {string} basePath - State base path
+     * @returns {Promise<number>} final yearly amount
+     */
+    async _updateYearlyConsumption(type, meterName, config, consumption, consumptionM3, delta, basePath) {
+        let yearlyAmountFinal;
         if (config.initialReading > 0) {
             let yearlyAmount;
             if (type === 'gas') {
@@ -468,21 +810,55 @@ class MultiMeterManager {
             } else {
                 yearlyAmount = Math.max(0, consumption - config.initialReading);
             }
-            await this.adapter.setStateAsync(
-                `${basePath}.consumption.yearly`,
-                calculator.roundToDecimals(yearlyAmount, 2),
-                true,
-            );
+            yearlyAmountFinal = calculator.roundToDecimals(yearlyAmount, 2);
+            await this.adapter.setStateAsync(`${basePath}.consumption.yearly`, yearlyAmountFinal, true);
         } else {
             const yState = await this.adapter.getStateAsync(`${basePath}.consumption.yearly`);
+            yearlyAmountFinal = calculator.roundToDecimals((yState?.val || 0) + delta, 2);
+            await this.adapter.setStateAsync(`${basePath}.consumption.yearly`, yearlyAmountFinal, true);
+        }
+        return yearlyAmountFinal;
+    }
+
+    /**
+     * Helper to calculate absolute yearly consumption (usually on start/reset)
+     *
+     * @param {string} type - Utility type
+     * @param {string} meterName - Meter name
+     * @param {object} config - Meter configuration
+     * @param {number} consumption - Current consumption value
+     * @param {number} consumptionM3 - Current consumption in m³ (for gas)
+     * @param {number} now - Current timestamp
+     */
+    async calculateAbsoluteYearly(type, meterName, config, consumption, consumptionM3, now) {
+        const basePath = `${type}.${meterName}`;
+        let yearlyAmountFinal;
+
+        let yearlyAmount;
+        if (type === 'gas') {
+            const yearlyM3 = Math.max(0, (consumptionM3 || 0) - config.initialReading);
+            this.adapter.log.debug(
+                `[${basePath}] Yearly absolute (Gas): consumptionM3=${consumptionM3}, initialReading=${config.initialReading}, resultM3=${yearlyM3}`,
+            );
             await this.adapter.setStateAsync(
-                `${basePath}.consumption.yearly`,
-                calculator.roundToDecimals((yState?.val || 0) + delta, 2),
+                `${basePath}.consumption.yearlyVolume`,
+                calculator.roundToDecimals(yearlyM3, 2),
                 true,
             );
+            const brennwert = this.adapter.config.gasBrennwert || calculator.DEFAULTS.GAS_BRENNWERT;
+            const zZahl = this.adapter.config.gasZahl || calculator.DEFAULTS.GAS_Z_ZAHL;
+            yearlyAmount = calculator.convertGasM3ToKWh(yearlyM3, brennwert, zZahl);
+        } else {
+            yearlyAmount = Math.max(0, consumption - config.initialReading);
+            this.adapter.log.debug(
+                `[${basePath}] Yearly absolute: consumption=${consumption}, initialReading=${config.initialReading}, result=${yearlyAmount}`,
+            );
         }
+        yearlyAmountFinal = calculator.roundToDecimals(yearlyAmount, 2);
+        await this.adapter.setStateAsync(`${basePath}.consumption.yearly`, yearlyAmountFinal, true);
 
-        await this.updateCosts(type, meterName, config);
+        // Pass direct calculated values to updateCosts to avoid race condition with DB
+        await this.updateCosts(type, meterName, config, yearlyAmountFinal);
         await this.updateTotalCosts(type);
 
         await this.adapter.setStateAsync(`${basePath}.consumption.lastUpdate`, now, true);
@@ -522,6 +898,7 @@ class MultiMeterManager {
             true,
         );
         await this.adapter.setStateAsync(`${basePath}.info.currentTariff`, tariffName, true);
+        await this.adapter.setStateAsync(`${basePath}.info.lastSync`, Date.now(), true);
     }
 
     /**
@@ -530,14 +907,21 @@ class MultiMeterManager {
      * @param {string} type - Utility type
      * @param {string} meterName - Meter name
      * @param {object} config - Meter configuration
+     * @param {number} [forcedYearly] - Optional already calculated yearly consumption (avoids DB race)
      */
-    async updateCosts(type, meterName, config) {
+    async updateCosts(type, meterName, config, forcedYearly) {
         const basePath = `${type}.${meterName}`;
 
         // Get consumption values
         const daily = (await this.adapter.getStateAsync(`${basePath}.consumption.daily`))?.val || 0;
         const monthly = (await this.adapter.getStateAsync(`${basePath}.consumption.monthly`))?.val || 0;
-        const yearly = (await this.adapter.getStateAsync(`${basePath}.consumption.yearly`))?.val || 0;
+
+        let yearly;
+        if (forcedYearly !== undefined && forcedYearly !== null) {
+            yearly = forcedYearly;
+        } else {
+            yearly = (await this.adapter.getStateAsync(`${basePath}.consumption.yearly`))?.val || 0;
+        }
 
         // Get price
         const price = config.preis || 0;
@@ -548,67 +932,66 @@ class MultiMeterManager {
 
         // Calculate consumption costs
         const dailyCost = daily * price;
+        const weeklyState = await this.adapter.getStateAsync(`${basePath}.consumption.weekly`);
+        const weeklyCost = (weeklyState?.val || 0) * price;
         const monthlyCost = monthly * price;
         const yearlyCost = yearly * price;
 
         await this.adapter.setStateAsync(`${basePath}.costs.daily`, calculator.roundToDecimals(dailyCost, 2), true);
+        await this.adapter.setStateAsync(`${basePath}.costs.weekly`, calculator.roundToDecimals(weeklyCost, 2), true);
         await this.adapter.setStateAsync(`${basePath}.costs.monthly`, calculator.roundToDecimals(monthlyCost, 2), true);
         await this.adapter.setStateAsync(`${basePath}.costs.yearly`, calculator.roundToDecimals(yearlyCost, 2), true);
 
         // Calculate accumulated costs based on contract start
-        const yearStartState = await this.adapter.getStateAsync(`${basePath}.statistics.lastYearStart`);
-        let monthsSinceYearStart = 1;
-        let basicChargeAccumulated = 0;
+        const monthsSinceYearStart = await this._calculateMonthsSinceYearStart(basePath);
 
-        if (yearStartState && yearStartState.val) {
-            // yearStartState.val is a timestamp (number)
-            const yearStartDate = new Date(yearStartState.val);
-            if (!isNaN(yearStartDate.getTime())) {
-                const now = new Date();
-
-                // Calculate months since contract start (started months, including current)
-                monthsSinceYearStart = calculator.getMonthsDifference(yearStartDate, now) + 1;
-
-                // Calculate accumulated basic charge (monthly fee × months)
-                basicChargeAccumulated = (config.grundgebuehr || 0) * monthsSinceYearStart;
-            }
-        }
-
-        // Jahresgebühr ist ein FIXER Wert pro Jahr (z.B. 60€)
-        // NICHT pro-rata nach Monaten/Tagen berechnen!
-        const annualFeeAccumulated = config.jahresgebuehr || 0;
-
-        // Update basicCharge with accumulated value (not just monthly!)
-        await this.adapter.setStateAsync(
-            `${basePath}.costs.basicCharge`,
-            calculator.roundToDecimals(basicChargeAccumulated, 2),
-            true,
+        const charges = billingHelper.calculateAccumulatedCharges(
+            config.grundgebuehr,
+            config.jahresgebuehr,
+            monthsSinceYearStart,
         );
+        const basicChargeAccumulated = charges.basicCharge;
+        const annualFeeAccumulated = charges.annualFee;
 
-        await this.adapter.setStateAsync(
-            `${basePath}.costs.annualFee`,
-            calculator.roundToDecimals(annualFeeAccumulated, 2),
-            true,
-        );
+        // Update basicCharge and annualFee states
+        await this.adapter.setStateAsync(`${basePath}.costs.basicCharge`, basicChargeAccumulated, true);
+        await this.adapter.setStateAsync(`${basePath}.costs.annualFee`, annualFeeAccumulated, true);
 
         // Calculate total yearly costs and balance
-        const totalYearlyCost = yearlyCost + basicChargeAccumulated + annualFeeAccumulated;
-
+        const totalYearlyCost = Math.max(0, yearlyCost + charges.total);
         await this.adapter.setStateAsync(
             `${basePath}.costs.totalYearly`,
             calculator.roundToDecimals(totalYearlyCost, 2),
             true,
         );
 
-        const paidTotal = (config.abschlag || 0) * monthsSinceYearStart;
-        const balance = totalYearlyCost - paidTotal;
+        const balanceRes = billingHelper.calculateBalance(config.abschlag, monthsSinceYearStart, totalYearlyCost);
 
         this.adapter.log.debug(
-            `[${basePath}] Balance calculation: grundgebuehr=${config.grundgebuehr}, jahresgebuehr=${config.jahresgebuehr}, abschlag=${config.abschlag}, months=${monthsSinceYearStart}, basicCharge=${basicChargeAccumulated.toFixed(2)}, annualFee=${annualFeeAccumulated.toFixed(2)}, paidTotal=${paidTotal.toFixed(2)}, totalYearly=${totalYearlyCost.toFixed(2)}, balance=${balance.toFixed(2)}`,
+            `[${basePath}] Cost calculation (MultiMeter): daily=${daily}, monthly=${monthly}, yearly=${yearly}, price=${price}, totalYearly=${totalYearlyCost}, paidTotal=${balanceRes.paid}, balance=${balanceRes.balance}`,
         );
 
-        await this.adapter.setStateAsync(`${basePath}.costs.paidTotal`, calculator.roundToDecimals(paidTotal, 2), true);
-        await this.adapter.setStateAsync(`${basePath}.costs.balance`, calculator.roundToDecimals(balance, 2), true);
+        await this.adapter.setStateAsync(`${basePath}.costs.paidTotal`, balanceRes.paid, true);
+        await this.adapter.setStateAsync(`${basePath}.costs.balance`, balanceRes.balance, true);
+    }
+
+    /**
+     * Calculates months since year start for a meter
+     *
+     * @param {string} basePath - State base path
+     * @returns {Promise<number>} Months since start (at least 1)
+     */
+    async _calculateMonthsSinceYearStart(basePath) {
+        const yearStartState = await this.adapter.getStateAsync(`${basePath}.statistics.lastYearStart`);
+        let monthsSinceYearStart = 1;
+
+        if (yearStartState && yearStartState.val) {
+            const yearStartDate = new Date(yearStartState.val);
+            if (!isNaN(yearStartDate.getTime())) {
+                monthsSinceYearStart = calculator.getMonthsDifference(yearStartDate, new Date()) + 1;
+            }
+        }
+        return Math.max(1, monthsSinceYearStart);
     }
 
     /**
@@ -624,10 +1007,22 @@ class MultiMeterManager {
             return;
         }
 
+        // Check if totals structure exists before trying to update
+        const totalsExists = await this.adapter.getObjectAsync(`${type}.totals`);
+        if (!totalsExists) {
+            // Totals structure not yet created, skip update
+            // This happens during initialization when handleSensorUpdate is called
+            // before createTotalsStructure has run
+            this.adapter.log.debug(`Skipping total costs update for ${type} - totals structure not yet created`);
+            return;
+        }
+
         let totalDaily = 0;
+        let totalWeekly = 0;
         let totalMonthly = 0;
         let totalYearly = 0;
         let totalCostsDaily = 0;
+        let totalCostsWeekly = 0;
         let totalCostsMonthly = 0;
         let totalCostsYearly = 0;
 
@@ -635,10 +1030,12 @@ class MultiMeterManager {
             const basePath = `${type}.${meter.name}`;
 
             totalDaily += (await this.adapter.getStateAsync(`${basePath}.consumption.daily`))?.val || 0;
+            totalWeekly += (await this.adapter.getStateAsync(`${basePath}.consumption.weekly`))?.val || 0;
             totalMonthly += (await this.adapter.getStateAsync(`${basePath}.consumption.monthly`))?.val || 0;
             totalYearly += (await this.adapter.getStateAsync(`${basePath}.consumption.yearly`))?.val || 0;
 
             totalCostsDaily += (await this.adapter.getStateAsync(`${basePath}.costs.daily`))?.val || 0;
+            totalCostsWeekly += (await this.adapter.getStateAsync(`${basePath}.costs.weekly`))?.val || 0;
             totalCostsMonthly += (await this.adapter.getStateAsync(`${basePath}.costs.monthly`))?.val || 0;
             totalCostsYearly += (await this.adapter.getStateAsync(`${basePath}.costs.totalYearly`))?.val || 0;
         }
@@ -648,6 +1045,11 @@ class MultiMeterManager {
             calculator.roundToDecimals(totalDaily, 2),
             true,
         );
+        await this.adapter.setStateAsync(
+            `${type}.totals.consumption.weekly`,
+            calculator.roundToDecimals(totalWeekly, 2),
+            true,
+        );
         await this.adapter.setStateAsync(
             `${type}.totals.consumption.monthly`,
             calculator.roundToDecimals(totalMonthly, 2),
@@ -664,6 +1066,11 @@ class MultiMeterManager {
             calculator.roundToDecimals(totalCostsDaily, 2),
             true,
         );
+        await this.adapter.setStateAsync(
+            `${type}.totals.costs.weekly`,
+            calculator.roundToDecimals(totalCostsWeekly, 2),
+            true,
+        );
         await this.adapter.setStateAsync(
             `${type}.totals.costs.monthly`,
             calculator.roundToDecimals(totalCostsMonthly, 2),