iobroker.utility-monitor 1.4.5 → 1.5.0

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);
     }
 
     /**
@@ -70,8 +56,14 @@ class MultiMeterManager {
         // Main meter (always present if type is active)
         const mainActive = this.adapter.config[`${configType}Aktiv`];
         if (mainActive) {
+            // Get main meter name from config and normalize
+            const mainMeterName = this.adapter.config[`${configType}MainMeterName`] || 'main';
+            const normalizedName = helpers.normalizeMeterName(mainMeterName);
+            const displayName = mainMeterName; // Original name for display
+
             meters.push({
-                name: 'main',
+                name: normalizedName,
+                displayName: displayName,
                 config: {
                     sensorDP: this.adapter.config[`${configType}SensorDP`],
                     preis: parseConfigNumber(this.adapter.config[`${configType}Preis`], 0),
@@ -91,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(
@@ -123,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);
     }
 
     /**
@@ -173,22 +165,31 @@ class MultiMeterManager {
      * @returns {Promise<void>}
      */
     async initializeMeter(type, meterName, config, displayName) {
-        const basePath = meterName === 'main' ? type : `${type}.${meterName}`;
+        const basePath = `${type}.${meterName}`;
         const label = displayName || meterName;
 
         this.adapter.log.info(`Initializing ${type} meter: ${label}`);
 
         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}`);
 
@@ -212,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}`);
@@ -221,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}`;
@@ -264,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);
@@ -349,8 +324,10 @@ class MultiMeterManager {
             return;
         }
 
-        const basePath = meterName === 'main' ? type : `${type}.${meterName}`;
-        this.adapter.log.debug(`Sensor update for ${basePath}: ${value}`);
+        const basePath = `${type}.${meterName}`;
+        this.adapter.log.debug(`[${basePath}] handleSensorUpdate: value=${value}, sensorDP=${sensorDP}`);
+
+        const now = Date.now();
 
         // Get meter config
         const meters = this.getMetersForType(type);
@@ -361,92 +338,279 @@ class MultiMeterManager {
         }
 
         const config = meter.config;
-        const now = Date.now();
-        let consumption = value;
-        let consumptionM3 = null;
 
-        this.adapter.log.debug(`[${basePath}] Sensor update: raw=${value}, offset=${config.offset}`);
+        // Pre-process consumption value (offset, gas conversion)
+        const processed = await this._preprocessValue(type, value, config);
+        const { consumption, consumptionM3 } = processed;
 
-        // Apply offset FIRST
-        if (config.offset !== 0) {
-            consumption = consumption - config.offset;
-            this.adapter.log.debug(`[${basePath}] After offset: ${consumption}`);
+        // 1. Initialization Logic (Per Session)
+        if (this.lastSensorValues[sensorDP] === undefined) {
+            await this._handleFirstSensorValue(type, meterName, sensorDP, processed, basePath, config, now);
+            return;
         }
 
-        // For gas, convert m³ to kWh
+        // 2. Update meter reading states
+        await this.adapter.setStateAsync(`${basePath}.info.meterReading`, consumption, 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;
-            consumptionM3 = consumption;
-            await this.adapter.setStateAsync(`${basePath}.info.meterReadingVolume`, consumption, true);
-            consumption = calculator.convertGasM3ToKWh(consumption, brennwert, zZahl);
-            consumption = calculator.roundToDecimals(consumption, 2);
+            await this.adapter.setStateAsync(`${basePath}.info.meterReadingVolume`, consumptionM3 || 0, true);
         }
 
-        // Update meter reading
-        await this.adapter.setStateAsync(`${basePath}.info.meterReading`, consumption, true);
-
-        // Calculate deltas
+        // 3. Delta Calibration & Spike Protection
         const lastValue = this.lastSensorValues[sensorDP];
         this.lastSensorValues[sensorDP] = consumption;
 
-        if (lastValue === undefined || consumption <= lastValue) {
-            if (lastValue !== undefined && consumption < lastValue) {
-                this.adapter.log.warn(
-                    `${type}.${meterName}: Sensor value decreased (${lastValue} -> ${consumption}). Assuming meter reset.`,
-                );
-            }
-            await this.updateCosts(type, meterName, config);
-            await this.updateTotalCosts(type);
+        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;
         }
 
-        const delta = consumption - lastValue;
         this.adapter.log.debug(`${type}.${meterName} delta: ${delta}`);
 
-        // Track volume for gas
+        // 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;
+
+        if (config.offset !== 0) {
+            consumption = consumption - config.offset;
+        }
+
         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 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`);
+            const res = consumptionHelper.calculateGas(consumption, brennwert, zZahl);
+            consumptionM3 = res.volume;
+            consumption = res.energy;
+        }
+
+        return { consumption, consumptionM3 };
+    }
+
+    /**
+     * 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;
+        } else {
+            if (recoveredValue > 0) {
+                this.adapter.log.warn(
+                    `[${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}`,
+                );
+            }
+            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);
+            }
+
+            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);
+    }
+
+    /**
+     * 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') {
@@ -462,21 +626,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);
@@ -491,14 +689,14 @@ class MultiMeterManager {
      * @param {object} config - Meter configuration
      */
     async updateCurrentPrice(type, meterName, config) {
-        const basePath = meterName === 'main' ? type : `${type}.${meterName}`;
+        const basePath = `${type}.${meterName}`;
         const configType = this.getConfigType(type);
 
         let tariffName = 'Standard';
         let activePrice = config.preis || 0;
 
-        // Only main meter supports HT/NT
-        if (meterName === 'main' && config.htNtEnabled) {
+        // Only meters with HT/NT enabled support it
+        if (config.htNtEnabled) {
             const isHT = calculator.isHTTime(this.adapter.config, configType);
             if (isHT) {
                 activePrice = this.adapter.config[`${configType}HtPrice`] || 0;
@@ -516,6 +714,7 @@ class MultiMeterManager {
             true,
         );
         await this.adapter.setStateAsync(`${basePath}.info.currentTariff`, tariffName, true);
+        await this.adapter.setStateAsync(`${basePath}.info.lastSync`, Date.now(), true);
     }
 
     /**
@@ -524,14 +723,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) {
-        const basePath = meterName === 'main' ? type : `${type}.${meterName}`;
+    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;
@@ -542,67 +748,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;
-
-        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;
+        const monthsSinceYearStart = await this._calculateMonthsSinceYearStart(basePath);
 
-        // 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);
     }
 
     /**
@@ -618,21 +823,35 @@ 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;
 
         for (const meter of meters) {
-            const basePath = meter.name === 'main' ? type : `${type}.${meter.name}`;
+            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;
         }
@@ -642,6 +861,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),
@@ -658,6 +882,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),