iobroker.sun2000 2.4.0 → 2.4.3

package/lib/statistics.js

@@ -15,6 +15,7 @@ in ioBroker VIS using the ioBroker.flexcharts adapter.
 
 'use strict';
 
+const stringify = require('javascript-stringify').stringify;
 const { dataRefreshRate, statisticsType } = require(`${__dirname}/types.js`);
 const tools = require(`${__dirname}/tools.js`);
 
@@ -23,32 +24,17 @@ class statistics {
 		this.adapter = adapterInstance;
 		this.stateCache = stateCache;
 		this.taskTimer = null;
+		this._path = 'statistics';
+		this._initialized = false;
 		this.testing = false; // set to true for testing purposes
-		// initialize to current time to avoid immediate backfill on startup
-		//const nowInit = new Date();
-		this.lastExecution = {
-			hourly: undefined,
-			daily: undefined,
-			weekly: undefined,
-			monthly: undefined,
-			annual: undefined,
-		};
 
 		this.stats = [
 			{
 				sourceId: 'collected.consumptionToday',
 				targetPath: 'consumption',
 				unit: 'kWh',
-				type: statisticsType.deltaReset, // value is a total that resets at the start of the period, so we need to calculate the delta to get the actual consumption for the period
-			},
-			/*
-			{
-				sourceId: 'collected.consumptionSum',
-				targetPath: 'consumptionSum',
-				unit: 'kWh',
-				type: statisticsType.delta,
+				type: statisticsType.deltaReset,
 			},
-			*/
 			{
 				sourceId: 'collected.dailySolarYield',
 				targetPath: 'solarYield',
@@ -56,23 +42,50 @@ class statistics {
 				type: statisticsType.deltaReset,
 			},
 			{ sourceId: 'collected.dailyInputYield', targetPath: 'inputYield', unit: 'kWh', type: statisticsType.deltaReset },
-			{
-				sourceId: 'collected.dailyExternalYield',
-				targetPath: 'externalYield',
-				unit: 'kWh',
-				type: statisticsType.deltaReset,
-			},
+			{ sourceId: 'collected.dailyExternalYield', targetPath: 'externalYield', unit: 'kWh', type: statisticsType.deltaReset },
 			{ sourceId: 'collected.dailyEnergyYield', targetPath: 'energyYield', unit: 'kWh', type: statisticsType.deltaReset },
 			{
 				sourceId: 'collected.SOC',
 				targetPath: 'SOC',
 				unit: '%',
-				type: statisticsType.level, // value is a level that can go up and down, so we take the value as is without calculating delta
+				type: statisticsType.level,
 			},
 			{ sourceId: 'collected.currentDayChargeCapacity', targetPath: 'chargeCapacity', unit: 'kWh', type: statisticsType.deltaReset },
 			{ sourceId: 'collected.currentDayDischargeCapacity', targetPath: 'dischargeCapacity', unit: 'kWh', type: statisticsType.deltaReset },
 			{ sourceId: 'collected.gridExportToday', targetPath: 'gridExport', unit: 'kWh', type: statisticsType.deltaReset },
 			{ sourceId: 'collected.gridImportToday', targetPath: 'gridImport', unit: 'kWh', type: statisticsType.deltaReset },
+			// --- Computed stats ---
+			{
+				targetPath: 'selfSufficiency',
+				unit: '%',
+				type: statisticsType.computed,
+				// unten im FusionSolar Fenster
+				// selfSufficiency = (consumption - gridImport)/consumption * 100
+				// selfSufficiency = (1 - gridImport / consumption) * 100
+				// If consumption = 0 → 100% (no consumption, fully self-sufficient)
+				compute: entry => {
+					const consumption = (entry.consumption?.total != null ? entry.consumption?.total : entry.consumption?.value) ?? 0;
+					const gridImport = (entry.gridImport?.total != null ? entry.gridImport?.total : entry.gridImport?.value) ?? 0;
+					if (consumption <= 0) return 100;
+					return Math.round(Math.max(0, Math.min(100, (1 - gridImport / consumption) * 100)) * 10) / 10;
+				},
+			},
+			{
+				targetPath: 'selfConsumption',
+				unit: '%',
+				type: statisticsType.computed,
+				// oben im FusionSolar Fenster
+				// selfConsumption = (solarYield - gridExport) / solarYield * 100
+				// selfConsumption = (1 - gridExport / solarYield) * 100
+				// If solarYield = 0 → 0% (no generation, no self-consumption possible)
+				compute: entry => {
+					let solarYield = (entry.solarYield?.total != null ? entry.solarYield?.total : entry.solarYield?.value) ?? 0;
+					solarYield += (entry.externalYield?.total != null ? entry.externalYield?.total : entry.externalYield?.value) ?? 0;
+					const gridExport = (entry.gridExport?.total != null ? entry.gridExport?.total : entry.gridExport?.value) ?? 0;
+					if (solarYield <= 0) return 0;
+					return Math.round(Math.max(0, Math.min(100, (1 - gridExport / solarYield) * 100)) * 10) / 10;
+				},
+			},
 		];
 
 		this.postProcessHooks = [
@@ -119,17 +132,102 @@ class statistics {
 						desc: 'Annual consumption per year',
 						initVal: '[]',
 					},
-					// a state where users may store a Flexcharts/eCharts options template
-					/*
+					// Today summary state
+					{
+						id: 'statistics.jsonToday',
+						name: 'Today summary',
+						type: 'string',
+						role: 'json',
+						desc: "Live summary of today's energy values",
+						initVal: '{}',
+					},
+					// Templates: one per chart type
+					{
+						id: 'statistics.flexCharts.template.hourly',
+						name: 'Flexcharts template hourly',
+						type: 'string',
+						role: 'json',
+						desc: 'Optional eCharts template for hourly chart. Leave empty {} for built-in layout.',
+						write: true,
+						initVal: '{}',
+					},
 					{
-						id: 'statistics.flexChartTemplate',
-						name: 'Flexcharts template',
+						id: 'statistics.flexCharts.template.daily',
+						name: 'Flexcharts template daily',
 						type: 'string',
 						role: 'json',
-						desc: 'Optional eCharts option object that will be merged into the default chart. Leave empty for the built‑in layout.',
+						desc: 'Optional eCharts template for daily chart. Leave empty {} for built-in layout.',
+						write: true,
+						initVal: '{}',
+					},
+					{
+						id: 'statistics.flexCharts.template.weekly',
+						name: 'Flexcharts template weekly',
+						type: 'string',
+						role: 'json',
+						desc: 'Optional eCharts template for weekly chart. Leave empty {} for built-in layout.',
+						write: true,
+						initVal: '{}',
+					},
+					{
+						id: 'statistics.flexCharts.template.monthly',
+						name: 'Flexcharts template monthly',
+						type: 'string',
+						role: 'json',
+						desc: 'Optional eCharts template for monthly chart. Leave empty {} for built-in layout.',
+						write: true,
+						initVal: '{}',
+					},
+					{
+						id: 'statistics.flexCharts.template.annual',
+						name: 'Flexcharts template annual',
+						type: 'string',
+						role: 'json',
+						desc: 'Optional eCharts template for annual chart. Leave empty {} for built-in layout.',
+						write: true,
+						initVal: '{}',
+					},
+					// Output: one per chart type
+					{
+						id: 'statistics.flexCharts.jsonOutput.hourly',
+						name: 'Flexcharts output hourly',
+						type: 'string',
+						role: 'json',
+						desc: 'ECharts configuration for hourly chart',
+						initVal: '{}',
+					},
+					{
+						id: 'statistics.flexCharts.jsonOutput.daily',
+						name: 'Flexcharts output daily',
+						type: 'string',
+						role: 'json',
+						desc: 'ECharts configuration for daily chart',
+						initVal: '{}',
+					},
+					{
+						id: 'statistics.flexCharts.jsonOutput.weekly',
+						name: 'Flexcharts output weekly',
+						type: 'string',
+						role: 'json',
+						desc: 'ECharts configuration for weekly chart',
+						initVal: '{}',
+					},
+					{
+						id: 'statistics.flexCharts.jsonOutput.monthly',
+						name: 'Flexcharts output monthly',
+						type: 'string',
+						role: 'json',
+						desc: 'ECharts configuration for monthly chart',
+						initVal: '{}',
+					},
+					{
+						id: 'statistics.flexCharts.jsonOutput.annual',
+						name: 'Flexcharts output annual',
+						type: 'string',
+						role: 'json',
+						desc: 'ECharts configuration for annual chart',
 						initVal: '{}',
 					},
-					*/
 				],
 			},
 		];
@@ -166,13 +264,11 @@ class statistics {
 	 * Generic function to calculate consumption statistics for different time periods.
 	 *
 	 * @param {string} stateId - The state ID for storing the JSON
-	 * @param {string} consumptionKey - The state key for consumption value
 	 * @param {Date} periodStart - The start of the current period
-	 * @param {string} periodType - The type of period (hourly, daily, weekly, monthly, annual)
-	 * @returns {Promise<void>}
+	 * @param {Date} periodEnde - The end of the current period
+	 * @returns {boolean} true if a new entry was appended, false otherwise.
 	 */
-
-	async _calculateGeneric(stateId, periodStart, periodEnde) {
+	_calculateGeneric(stateId, periodStart, periodEnde) {
 		const toStr = this._localIsoWithOffset(periodEnde);
 		let jsonStr = this.stateCache.get(stateId)?.value ?? '[]';
 		let arr = [];
@@ -186,7 +282,6 @@ class statistics {
 		let last = {};
 		if (arr.length > 0) {
 			last = arr[arr.length - 1];
-			// avoid duplicates
 			if (last.to === toStr) return false;
 			const lastToDate = new Date(last.to);
 			const toDate = new Date(toStr);
@@ -200,7 +295,10 @@ class statistics {
 			to: toStr,
 		};
 
+		// First pass: deltaReset, delta, level stats
 		for (const stat of this.stats) {
+			if (stat.type === statisticsType.computed) continue;
+
 			const source = this.stateCache.get(stat.sourceId)?.value;
 			if (source === null || source === undefined) {
 				this.adapter.logger.warn(`Source state ${stat.sourceId} not found statistic hook`);
@@ -210,64 +308,55 @@ class statistics {
 			if (stat.type === statisticsType.delta || stat.type === statisticsType.deltaReset) {
 				const lastTotal = Number(last[stat.targetPath]?.['total'] ?? 0);
 				if (stat.type === statisticsType.deltaReset) {
-					//if (value >= lastTotal * 0.5) {
 					if (fromDate.getTime() !== periodStart.getTime()) {
-						// Delta-Berechnung
 						value -= lastTotal;
 					}
 				} else {
-					// Ein lastTotal-Wert vorhanden –> normale Delta-Berechnung
 					if (last[stat.targetPath]?.['total'] === undefined) {
-						// Kein lastTotal-Wert vorhanden –> wahrscheinlich erster Eintrag, Delta-Berechnung nicht möglich
 						this.adapter.logger.debug(`No total value found for ${stat.targetPath} in last entry, setting delta to 0`);
 						value = 0;
 					} else {
-						// Delta-Berechnung
 						value -= lastTotal;
 					}
 				}
 			}
 			value = Math.round((Number(value) + Number.EPSILON) * 1000) / 1000;
-			entry[stat.targetPath] = {
-				value: Number(value.toFixed(3)),
-			};
-
+			entry[stat.targetPath] = { value: Number(value.toFixed(3)) };
 			if (stat.type === statisticsType.delta || stat.type === statisticsType.deltaReset) {
 				entry[stat.targetPath].total = Number(source.toFixed(3));
 			}
-			entry[stat.targetPath].unit = stat.unit || 'kWh'; // can be extended for other stats with different units
+			entry[stat.targetPath].unit = stat.unit || 'kWh';
 		}
-		arr.push(entry);
 
-		arr.sort((a, b) => Date.parse(a.to) - Date.parse(b.to));
+		// Second pass: computed stats (all other values are now in entry)
+		for (const stat of this.stats) {
+			if (stat.type !== statisticsType.computed) continue;
+			try {
+				const value = stat.compute(entry);
+				entry[stat.targetPath] = {
+					value: Number(Number(value).toFixed(3)),
+					unit: stat.unit || '%',
+				};
+			} catch (e) {
+				this.adapter.logger.warn(`statistics: error computing ${stat.targetPath}: ${e.message}`);
+				entry[stat.targetPath] = { value: 0, unit: stat.unit || '%' };
+			}
+		}
 
+		arr.push(entry);
+		arr.sort((a, b) => Date.parse(a.to) - Date.parse(b.to));
 		this.stateCache.set(stateId, JSON.stringify(arr), { type: 'string' });
 		this.adapter.logger.debug(`Appended ${stateId} statistic ${toStr}`);
+		return arr.length > 0;
 	}
 
 	/**
-	 * Calculates and updates hourly consumption statistics.
-	 *
-	 * This function calculates the hourly consumption statistics based on the current day's data.
-	 * It retrieves the consumption data and updates the hourly consumption JSON accordingly.
+	 * Removes entries older than periodStart from the given state.
 	 *
-	 * @returns {void}
+	 * @param {string} stateId
+	 * @param {Date} periodStart
 	 */
-	async _calculateHourly() {
-		const now = new Date();
-		if (this.testing) {
-			const state = await this.adapter.getState('statistics.jsonHourly');
-			this.stateCache.set('statistics.jsonHourly', state?.val ?? '[]', { type: 'string', stored: true });
-			now.setDate(now.getDate() + 1); // set to start of day for testing to have consistent results
-			now.setHours(1, 0, 0, 1); // set to 1ms after midnight to trigger hourly calculation for the new day
-		}
-		const startOfDay = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 0, 0, 0, 0);
-		const lastHour = new Date(now.getFullYear(), now.getMonth(), now.getDate(), now.getHours(), 0, 0, 0);
-		this.adapter.log.debug('### Hourly execution triggered ###');
-		this._calculateGeneric('statistics.jsonHourly', startOfDay, lastHour) && (this.lastExecution.hourly = now); // only update last execution time if calculation was performed to avoid backfilling multiple hours at startup
-	}
-
-	async _clearGeneric(stateId, periodStart) {
+	_clearGeneric(stateId, periodStart) {
 		let jsonStr = this.stateCache.get(stateId)?.value ?? '[]';
 		let arr = [];
 		try {
@@ -276,29 +365,163 @@ class statistics {
 		} catch {
 			arr = [];
 		}
-
-		// Keep only entries within the window
 		arr = arr.filter(item => {
 			const ts = Date.parse(item.from);
 			return !Number.isNaN(ts) && ts >= periodStart.getTime();
 		});
-
 		this.stateCache.set(stateId, JSON.stringify(arr), { type: 'string' });
 	}
 
+	// eslint-disable-next-line jsdoc/require-returns-check
 	/**
-	 * Calculates and aggregates consumption statistics based on the given parameters.
+	 * Calculates and aggregates statistics for a given time window.
+	 * If the window end is in the future (current period), the last entry
+	 * is updated in place on every call — effectively a live running total.
+	 * If the window end is in the past (completed period), a new entry is
+	 * appended only once and never touched again.
 	 *
-	 * This function calculates and aggregates the consumption statistics based on the source entries within a specific window.
-	 * It retrieves the source entries, filters them based on the window, calculates the sum of consumption, and appends the result to the target array.
+	 * @param {string} sourceStateId
+	 * @param {string} targetStateId
+	 * @param {Function} getWindow - returns { from: Date, to: Date }
+	 *   where to is the natural end of the period (e.g. tomorrow 0:00)
+	 * @param {string} periodType
+	 * @returns {boolean} true if a new entry was appended, false otherwise
+	 */
+	_calculateAggregation(sourceStateId, targetStateId, getWindow, periodType) {
+		try {
+			const now = new Date();
+			const window = getWindow(now);
+			const fromDate = window.from;
+			const toDate = window.to;
+
+			// Effective end: either the natural period end (past) or now (running)
+			const isRunning = now < toDate;
+			const effectiveTo = isRunning ? now : toDate;
+			const toStr = this._localIsoWithOffset(effectiveTo);
+
+			let jsonTarget = this.stateCache.get(targetStateId)?.value ?? '[]';
+			let targetArray = [];
+			try {
+				targetArray = JSON.parse(jsonTarget);
+				if (!Array.isArray(targetArray)) targetArray = [];
+			} catch {
+				targetArray = [];
+			}
+
+			// Find existing entry for this window (matched by from date)
+			const fromStr = this._localIsoWithOffset(fromDate);
+			const existingIdx = targetArray.findLastIndex(e => (isRunning ? e._live === true : e.from === fromStr));
+			//const existing = existingIdx >= 0 ? targetArray[existingIdx] : null;
+
+			// For completed periods: skip if already finalized (to matches natural end)
+			if (!isRunning && existingIdx >= 0) {
+				//const naturalToStr = this._localIsoWithOffset(toDate);
+				if (targetArray[existingIdx] === this._localIsoWithOffset(toDate)) {
+					this.adapter.logger.debug(`statistics.js: ${periodType} entry already finalized, skipping`);
+					return false;
+				}
+			}
+
+			const target = {
+				from: fromStr,
+				to: toStr,
+			};
+
+			if (isRunning) {
+				target._live = true;
+			}
+
+			// Load source entries within the window
+			let jsonStr = this.stateCache.get(sourceStateId)?.value ?? '[]';
+			let sourceEntries = [];
+			try {
+				sourceEntries = JSON.parse(jsonStr);
+				if (!Array.isArray(sourceEntries)) sourceEntries = [];
+			} catch {
+				sourceEntries = [];
+			}
+
+			sourceEntries = sourceEntries.filter(item => {
+				const ts = Date.parse(item.from);
+				//return !Number.isNaN(ts) && ts >= fromDate.getTime() && ts < effectiveTo.getTime(); //toDate ?
+				return !Number.isNaN(ts) && ts >= fromDate.getTime() && ts < toDate.getTime();
+			});
+
+			if (sourceEntries.length === 0) {
+				/*
+				this.adapter.logger.debug(
+					`statistics.js: No source entries for ${periodType} between ${fromDate.toISOString()} and ${effectiveTo.toISOString()}, skipping`,
+				);
+				*/
+				this.adapter.logger.debug(
+					`statistics.js: No source entries for ${periodType} between ${fromDate.toISOString()} and ${toDate.toISOString()}, skipping`,
+				);
+				return false;
+			}
+
+			this.adapter.logger.debug(
+				`statistics.js: ${sourceEntries.length} source entries for ${periodType} between ${fromDate.toISOString()} and ${effectiveTo.toISOString()} (running=${isRunning})`,
+			);
+
+			// First pass: sum delta/deltaReset stats
+			for (const stat of this.stats) {
+				if (stat.type === statisticsType.level) continue;
+				if (stat.type === statisticsType.computed) continue;
+
+				let sum = 0;
+				try {
+					sourceEntries.forEach(entry => {
+						sum += Number(entry[stat.targetPath]?.['value'] ?? 0);
+					});
+				} catch (e) {
+					this.adapter.logger.warn(`statistics.js: Error during ${periodType} aggregation: ${e.message}`);
+				}
+				sum = Math.round((Number(sum) + Number.EPSILON) * 1000) / 1000;
+				target[stat.targetPath] = { value: Number(sum.toFixed(3)), unit: stat.unit || 'kWh' };
+			}
+
+			// Second pass: computed stats
+			for (const stat of this.stats) {
+				if (stat.type !== statisticsType.computed) continue;
+				try {
+					const value = stat.compute(target);
+					target[stat.targetPath] = {
+						value: Number(Number(value).toFixed(3)),
+						unit: stat.unit || '%',
+					};
+				} catch (e) {
+					this.adapter.logger.warn(`statistics: error computing ${stat.targetPath}: ${e.message}`);
+					target[stat.targetPath] = { value: 0, unit: stat.unit || '%' };
+				}
+			}
+
+			// Update in place or append
+			if (existingIdx >= 0) {
+				targetArray[existingIdx] = target;
+				this.adapter.logger.debug(`statistics.js: Updated ${periodType} entry (running=${isRunning})`);
+			} else {
+				targetArray.push(target);
+				this.adapter.logger.debug(`statistics.js: Appended ${periodType} entry (running=${isRunning})`);
+			}
+
+			targetArray.sort((a, b) => Date.parse(a.to) - Date.parse(b.to));
+			this.stateCache.set(targetStateId, JSON.stringify(targetArray), { type: 'string' });
+			return targetArray.length > 0;
+		} catch (err) {
+			this.adapter.logger.warn(`Error during ${periodType} aggregation: ${err.message}`);
+		}
+	}
+	// eslint-disable-next-line jsdoc/require-returns-check
+	/**
+	 * Calculates and aggregates consumption statistics based on the given parameters.
 	 *
-	 * @param {string} sourceStateId - The ID of the source state to retrieve entries from.
-	 * @param {string} targetStateId - The ID of the target state to append the aggregated result.
-	 * @param {Function} getWindow - A function that returns the start and end date of the window based on the current date.
-	 * @param {string} periodType - The type of period for which the aggregation is performed.
-	 * @returns {void}
+	 * @param {string} sourceStateId
+	 * @param {string} targetStateId
+	 * @param {Function} getWindow
+	 * @param {string} periodType
+	 * @returns {boolean} true if a new entry was appended, false otherwise.
 	 */
-	async _calculateAggregation(sourceStateId, targetStateId, getWindow, periodType) {
+	_calculateAggregation_old(sourceStateId, targetStateId, getWindow, periodType) {
 		try {
 			const now = new Date();
 			const window = getWindow(now);
@@ -306,11 +529,11 @@ class statistics {
 			const toDate = window.to;
 			if (now < toDate) {
 				this.adapter.logger.debug(`statistics.js: Skipping ${periodType} aggregation because current time is before end of aggregation window`);
-				return;
+				return false;
 			}
 			const toStr = this._localIsoWithOffset(toDate);
+			//const fromStr = this._localIsoWithOffset(fromDate);
 
-			// Load target array
 			let jsonTarget = this.stateCache.get(targetStateId)?.value ?? '[]';
 			let targetArray = [];
 			try {
@@ -320,16 +543,15 @@ class statistics {
 				targetArray = [];
 			}
 
-			// Avoid duplicates
 			const last = targetArray.length > 0 ? targetArray[targetArray.length - 1] : {};
-			if (last.to === toStr) return;
+
+			if (last.to === toStr) return false;
 
 			const target = {
 				from: this._localIsoWithOffset(fromDate),
 				to: toStr,
 			};
 
-			// Load source entries
 			let jsonStr = this.stateCache.get(sourceStateId)?.value ?? '[]';
 			let sourceEntries = [];
 			try {
@@ -339,27 +561,22 @@ class statistics {
 				sourceEntries = [];
 			}
 
-			// Keep only entries within the window
 			sourceEntries = sourceEntries.filter(item => {
 				const ts = Date.parse(item.from);
 				return !Number.isNaN(ts) && ts >= fromDate.getTime() && ts < toDate.getTime();
 			});
-			// If there are no source entries, we can skip the aggregation and avoid creating empty entries in the target array
+
 			if (sourceEntries.length > 0) {
 				this.adapter.logger.debug(
 					`statistics.js: Found ${sourceEntries.length} source entries for ${periodType} aggregation between ${fromDate.toISOString()} and ${toDate.toISOString()}`,
 				);
 
+				// First pass: sum delta/deltaReset stats
 				for (const stat of this.stats) {
-					// Sum consumption for the window
-					if (stat.type === statisticsType.level) continue; // Skip level statistics
+					if (stat.type === statisticsType.level) continue;
+					if (stat.type === statisticsType.computed) continue;
 
 					let sum = 0;
-					/*
-					if (stat.type === statisticsType.average) {
-						stat.sum = sourceEntries.length > 0 ? sourceEntries[sourceEntries.length - 1]?.[stat.targetPath]?.['total'] : 0;
-					} else {
-					*/
 					try {
 						sourceEntries.forEach(entry => {
 							sum += Number(entry[stat.targetPath]?.['value'] ?? 0);
@@ -367,154 +584,277 @@ class statistics {
 					} catch (e) {
 						this.adapter.logger.warn(`statistics.js: Error during ${periodType} statistic aggregation: ${e.message}`);
 					}
-
 					sum = Math.round((Number(sum) + Number.EPSILON) * 1000) / 1000;
+					target[stat.targetPath] = { value: Number(sum.toFixed(3)), unit: stat.unit || 'kWh' };
+				}
 
-					target[stat.targetPath] = {
-						value: Number(sum.toFixed(3)),
-						unit: stat.unit || 'kWh',
-					};
+				// Second pass: compute derived stats from aggregated values
+				for (const stat of this.stats) {
+					if (stat.type !== statisticsType.computed) continue;
+					try {
+						const value = stat.compute(target);
+						target[stat.targetPath] = {
+							value: Number(Number(value).toFixed(3)),
+							unit: stat.unit || '%',
+						};
+					} catch (e) {
+						this.adapter.logger.warn(`statistics: error computing aggregated ${stat.targetPath}: ${e.message}`);
+						target[stat.targetPath] = { value: 0, unit: stat.unit || '%' };
+					}
 				}
 
 				targetArray.push(target);
 			}
 
-			// Retention: keep entries from retention start onwards
-			/*
-			const retentionStart = getRetentionStart(now);
-			targetArray = targetArray.filter(item => {
-				const ts = Date.parse(item.from);
-				return !Number.isNaN(ts) && ts >= retentionStart.getTime();
-			});
-			*/
-
 			targetArray.sort((a, b) => Date.parse(a.to) - Date.parse(b.to));
 			this.stateCache.set(targetStateId, JSON.stringify(targetArray), { type: 'string' });
-			this.adapter.logger.debug(`Appended ${periodType} statistic ${toStr} `);
-			return true;
+			this.adapter.logger.debug(`Appended ${periodType} statistic ${toStr}`);
+			return targetArray.length > 0;
 		} catch (err) {
 			this.adapter.logger.warn(`Error during ${periodType} aggregation: ${err.message}`);
 		}
 	}
 
 	/**
-	 * Calculates and updates daily consumption statistics from hourly data.
-	 *
-	 * @returns {void}
+	 * Updates the statistics.jsonToday state with the current live day values.
+	 * Reads directly from the stateCache (collected.*) and computes derived values.
+	 */
+	updateJsonToday() {
+		if (!this._initialized) {
+			this.adapter.logger.debug('statistics: updateJsonToday called before initialization');
+			return;
+		}
+
+		try {
+			const now = new Date();
+			const today = {};
+
+			// Read all non-computed stats directly from stateCache
+			for (const stat of this.stats) {
+				if (stat.type === statisticsType.computed) continue;
+				if (stat.type === statisticsType.level) {
+					const val = this.stateCache.get(stat.sourceId)?.value;
+					today[stat.targetPath] = {
+						value: val != null ? Number(Number(val).toFixed(3)) : null,
+						unit: stat.unit,
+					};
+				} else {
+					// deltaReset: value is the current day total from the source state
+					const val = this.stateCache.get(stat.sourceId)?.value;
+					today[stat.targetPath] = {
+						value: val != null ? Number(Number(val).toFixed(3)) : null,
+						unit: stat.unit,
+					};
+				}
+			}
+
+			// Compute derived stats
+			for (const stat of this.stats) {
+				if (stat.type !== statisticsType.computed) continue;
+				try {
+					// Build a proxy entry using the raw today values
+					const proxyEntry = {};
+					for (const key of Object.keys(today)) {
+						proxyEntry[key] = today[key];
+					}
+					const value = stat.compute(proxyEntry);
+					today[stat.targetPath] = {
+						value: Number(Number(value).toFixed(3)),
+						unit: stat.unit || '%',
+					};
+				} catch (e) {
+					this.adapter.logger.warn(`statistics: error computing today.${stat.targetPath}: ${e.message}`);
+					today[stat.targetPath] = { value: 0, unit: stat.unit || '%' };
+				}
+			}
+
+			today.updatedAt = this._localIsoWithOffset(now);
+
+			const todayStr = JSON.stringify(today);
+			this.stateCache.set('statistics.jsonToday', todayStr, { type: 'string' });
+			this.adapter.logger.debug('statistics: jsonToday state updated');
+		} catch (err) {
+			this.adapter.logger.warn(`statistics: error updating today state: ${err.message}`);
+		}
+	}
+
+	/**
+	 * Calculates and updates hourly consumption statistics.
 	 */
-	async _calculateDaily() {
+	_calculateHourly() {
+		const now = new Date();
+		if (this.testing) {
+			const state = this.adapter.getState('statistics.jsonHourly');
+			this.stateCache.set('statistics.jsonHourly', state?.val ?? '[]', { type: 'string', stored: true });
+			now.setDate(now.getDate() + 1);
+			now.setHours(1, 0, 0, 1);
+		}
+		const startOfDay = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 0, 0, 0, 0);
+		const lastHour = new Date(now.getFullYear(), now.getMonth(), now.getDate(), now.getHours(), 0, 0, 0);
+		this.adapter.log.debug(`### Hourly execution triggered with lastHour: ${lastHour.toLocaleTimeString()} ###`);
+		if (this._calculateGeneric('statistics.jsonHourly', startOfDay, lastHour)) {
+			this._buildFlexchart('hourly');
+		}
+	}
+
+	_calculateDaily() {
 		this.adapter.log.debug('### Daily execution triggered ###');
+
+		// Abgeschlossener Vortag — normaler Eintrag
 		this._calculateAggregation(
 			'statistics.jsonHourly',
 			'statistics.jsonDaily',
 			now => {
-				// aggregation window: previous day (day that just ended)
 				const today = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 0, 0, 0, 0);
 				const yesterday = new Date(today);
 				yesterday.setDate(today.getDate() - 1);
 				return { from: yesterday, to: today };
 			},
 			'daily',
-		) && (this.lastExecution.daily = new Date()); // only update last execution time if aggregation was performed to avoid backfilling multiple days at startup
+		);
+		// Laufender heutiger Tag — live entry aus jsonHourly aggregieren
+		this._calculateAggregation(
+			'statistics.jsonHourly',
+			'statistics.jsonDaily',
+			now => {
+				const today = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 0, 0, 0, 0);
+				const tomorrow = new Date(today);
+				tomorrow.setDate(today.getDate() + 1);
+				return { from: today, to: tomorrow };
+			},
+			'daily-live',
+		);
+		this._buildFlexchart('daily');
 	}
 
 	/**
 	 * Calculates and updates weekly consumption statistics from daily data.
-	 *
-	 * @returns {void}
 	 */
-	async _calculateWeekly() {
+	_calculateWeekly() {
 		this.adapter.log.debug('### Weekly execution triggered ###');
 		this._calculateAggregation(
 			'statistics.jsonDaily',
 			'statistics.jsonWeekly',
 			now => {
-				// aggregation window: Monday to Sunday of the previous week (week that just ended)
-				const startday = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 0, 0, 0, 0);
-				const lastday = new Date(startday);
-				// set to Monday of previous week
-				lastday.setDate(now.getDate() - (now.getDay() || 7) + 1); // set to Monday of actual week
-				startday.setDate(lastday.getDate() - 7); // set to Monday of previous week
-				return { from: startday, to: lastday };
+				// Previous week (completed)
+				const monday = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 0, 0, 0, 0);
+				monday.setDate(now.getDate() - (now.getDay() || 7) + 1);
+				const prevMonday = new Date(monday);
+				prevMonday.setDate(monday.getDate() - 7);
+				const nextMonday = new Date(monday);
+				nextMonday.setDate(monday.getDate() + 7);
+				// Window: previous Monday → next Monday (covers both last and current week)
+				return { from: prevMonday, to: nextMonday };
 			},
 			'weekly',
-		) && (this.lastExecution.weekly = new Date()); // only update last execution time if aggregation was performed to avoid backfilling multiple weeks at startup
+		);
+
+		// Laufende Woche — live entry
+		this._calculateAggregation(
+			'statistics.jsonDaily',
+			'statistics.jsonWeekly',
+			now => {
+				const monday = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 0, 0, 0, 0);
+				monday.setDate(now.getDate() - (now.getDay() || 7) + 1);
+				const nextMonday = new Date(monday);
+				nextMonday.setDate(monday.getDate() + 7);
+				return { from: monday, to: nextMonday };
+			},
+			'weekly-live',
+		);
+		this._buildFlexchart('weekly');
 	}
 
 	/**
 	 * Calculates and updates monthly consumption statistics from daily data.
-	 *
-	 * @returns {void}
 	 */
-	async _calculateMonthly() {
+	_calculateMonthly() {
 		this.adapter.log.debug('### Monthly execution triggered ###');
 		this._calculateAggregation(
 			'statistics.jsonDaily',
 			'statistics.jsonMonthly',
 			now => {
-				// aggregation windowStart: previous month (month that just ended)
 				const thisMonth = new Date(now.getFullYear(), now.getMonth(), 1, 0, 0, 0, 0);
 				const prevMonth = new Date(now.getFullYear(), now.getMonth() - 1, 1, 0, 0, 0, 0);
 				return { from: prevMonth, to: thisMonth };
 			},
 			'monthly',
-		) && (this.lastExecution.monthly = new Date()); // only update last execution time if aggregation was performed to avoid backfilling multiple months at startup
+		);
+		// Laufender Monat — live entry
+		this._calculateAggregation(
+			'statistics.jsonDaily',
+			'statistics.jsonMonthly',
+			now => {
+				const thisMonth = new Date(now.getFullYear(), now.getMonth(), 1, 0, 0, 0, 0);
+				const nextMonth = new Date(now.getFullYear(), now.getMonth() + 1, 1, 0, 0, 0, 0);
+				return { from: thisMonth, to: nextMonth };
+			},
+			'monthly-live',
+		);
+		this._buildFlexchart('monthly');
 	}
 
 	/**
 	 * Calculates and updates annual consumption statistics from daily data.
-	 *
-	 * @returns {void}
 	 */
-	async _calculateAnnual() {
+	_calculateAnnual() {
 		this.adapter.log.debug('### Annual execution triggered ###');
 		this._calculateAggregation(
 			'statistics.jsonDaily',
 			'statistics.jsonAnnual',
 			now => {
-				// aggregation window: previous year (year that just ended)
 				const thisYear = new Date(now.getFullYear(), 0, 1, 0, 0, 0, 0);
 				const prevYear = new Date(now.getFullYear() - 1, 0, 1, 0, 0, 0, 0);
 				return { from: prevYear, to: thisYear };
 			},
 			'annual',
-		) && (this.lastExecution.annual = new Date()); // only update last execution time if aggregation was performed to avoid backfilling multiple years at startup
+		);
+		// Laufendes Jahr — live entry
+		this._calculateAggregation(
+			'statistics.jsonDaily',
+			'statistics.jsonAnnual',
+			now => {
+				const thisYear = new Date(now.getFullYear(), 0, 1, 0, 0, 0, 0);
+				const nextYear = new Date(now.getFullYear() + 1, 0, 1, 0, 0, 0, 0);
+				return { from: thisYear, to: nextYear };
+			},
+			'annual-live',
+		);
+		this._buildFlexchart('annual');
 	}
 
 	/**
 	 * Initialize and schedule the unified task manager.
-	 * This task runs every minute and checks which statistics need to be calculated.
+	 * Runs every full hour.
 	 */
-	async _initializeTask() {
+	_initializeTask() {
 		const scheduleNextRun = () => {
 			const now = new Date();
+
 			const next = new Date(now);
 			if (this.testing) {
-				next.setMinutes(now.getMinutes() + 1, 0, 0); //every minute
+				next.setMinutes(now.getMinutes() + 1, 0, 0);
 			} else {
-				next.setHours(next.getHours() + 1, 0, 0, 0); //every hour
+				next.setHours(next.getHours() + 1, 0, 0, 100);
 			}
-
-			// Skip executing tasks exactly at midnight to avoid running aggregated jobs
 			if (next.getHours() === 0 && next.getMinutes() === 0) {
-				next.setHours(next.getHours() + 1, 0, 0, 0); //every hour
+				next.setHours(next.getHours() + 1, 0, 0, 0);
 			}
 			const msToNextHour = next.getTime() - now.getTime();
+			this.adapter.logger.debug(`### Statistics - Scheduler start ${now.toLocaleTimeString()} next ${next.toLocaleTimeString()}`);
 
 			if (this.taskTimer) {
 				this.adapter.clearTimeout(this.taskTimer);
 			}
-
-			this.taskTimer = this.adapter.setTimeout(async () => {
-				await this._executeScheduledTasks();
-				scheduleNextRun(); // reschedule for next hour
+			this.taskTimer = this.adapter.setTimeout(() => {
+				this._executeScheduledTasks();
+				scheduleNextRun();
 			}, msToNextHour);
 		};
-		//await this._executeScheduledTasks(); // execute immediately on startup to catch up on any missed runs while the adapter was not running
-		// Schedule the next run
 		scheduleNextRun();
 	}
-	async _executeScheduledTasks() {
+
+	_executeScheduledTasks() {
 		this._calculateHourly();
 		this._calculateDaily();
 		this._calculateWeekly();
@@ -523,23 +863,21 @@ class statistics {
 	}
 
 	/**
-	 * Executes every midnight and performs the following tasks:
-	 * - Execute all scheduled tasks to ensure that statistics are up to date.
-	 * - Clear old data based on retention policies.
+	 * Executes every midnight:
+	 * - Runs all scheduled tasks
+	 * - Clears old data based on retention policies
 	 */
-	async mitNightProcess() {
+	mitNightProcess() {
 		const now = new Date();
-		await this._executeScheduledTasks();
-		// Clear old data based on retention policies
+		this._executeScheduledTasks();
 		const startOfYear = new Date(now.getFullYear(), 0, 1, 0, 0, 0, 0);
-		await this._clearGeneric('statistics.jsonDaily', startOfYear);
-		await this._clearGeneric('statistics.jsonWeekly', startOfYear);
-		await this._clearGeneric('statistics.jsonMonthly', startOfYear);
-		await this._clearGeneric('statistics.jsonHourly', new Date(now.getFullYear(), now.getMonth(), now.getDate() - 1, 0, 0, 0, 0));
+		this._clearGeneric('statistics.jsonDaily', startOfYear);
+		this._clearGeneric('statistics.jsonWeekly', startOfYear);
+		this._clearGeneric('statistics.jsonMonthly', startOfYear);
+		this._clearGeneric('statistics.jsonHourly', new Date(now.getFullYear(), now.getMonth(), now.getDate() - 1, 0, 0, 0, 0));
 	}
 
 	async initialize() {
-		// load consumption JSON states (keep as string)
 		let state = await this.adapter.getState('statistics.jsonHourly');
 		this.stateCache.set('statistics.jsonHourly', state?.val ?? '[]', { type: 'string', stored: true });
 
@@ -555,30 +893,39 @@ class statistics {
 		state = await this.adapter.getState('statistics.jsonAnnual');
 		this.stateCache.set('statistics.jsonAnnual', state?.val ?? '[]', { type: 'string', stored: true });
 
-		// load optional flexchart template
-		/*
-		state = await this.adapter.getState('statistics.flexChartTemplate');
-		this.stateCache.set('statistics.flexChartTemplate', state?.val ?? '{}', { type: 'string', stored: true });
-        */
-		// wait until consumptionToday and so on is available to avoid running the task before the initial state is loaded
-		/*
-		await tools.waitForValue(() => this.stateCache.get('collected.consumptionToday')?.value, 60000);
-		await tools.waitForValue(() => this.stateCache.get('collected.dailySolarYield')?.value, 60000);
-		await tools.waitForValue(() => this.stateCache.get('collected.SOC')?.value, 60000);
-		*/
+		state = await this.adapter.getState('statistics.jsonToday');
+		this.stateCache.set('statistics.jsonToday', state?.val ?? '{}', { type: 'string', stored: true });
+
 		await tools.waitForValue(() => this.stateCache.get('collected.accumulatedEnergyYield')?.value, 60000);
-		this.mitNightProcess(); // execute once on startup to catch up on any missed runs while the adapter was not running
+
+		// Load templates — one per chart type
+		for (const chartType of ['hourly', 'daily', 'weekly', 'monthly', 'annual']) {
+			const templateStateId = `statistics.flexCharts.template.${chartType}`;
+			state = await this.adapter.getState(templateStateId);
+			this.stateCache.set(templateStateId, state?.val ?? '{}', { type: 'string', stored: true });
+			if (state?.ack === false) {
+				this.stateCache.set(templateStateId, state.val, { type: 'string' });
+				await this.adapter.setState(templateStateId, { val: state.val, ack: true });
+				this._buildFlexchart(chartType);
+			}
+		}
+
+		this.mitNightProcess();
 		this._initializeTask();
+		this.adapter.subscribeStates(`${this._path}.*`);
+		this._initialized = true;
 	}
 
 	/**
-	 * Build a flexcharts/eCharts option object from stored statistics.
-	 * The returned object may be sent to a callback for flexcharts' script source.
+	 * Builds and updates the Flexchart configuration for the specified chart type.
 	 *
-	 * @param {string} myChart - one of 'hourly','daily','weekly','monthly','annual'
-	 * @returns {object} chart configuration
+	 * @param {string} myChart - 'hourly' | 'daily' | 'weekly' | 'monthly' | 'annual'
+	 * @param {string} [chartStyle] - 'line' | 'bar' — defaults to 'line' for hourly, 'bar' for others
+	 * @returns {string} The generated chart configuration as a javascript-stringify string
 	 */
-	_buildFlexchart(myChart) {
+	_buildFlexchart(myChart, chartStyle) {
+		chartStyle = chartStyle || (myChart === 'hourly' ? 'line' : 'bar');
+
 		const IDS = {
 			hourly: 'statistics.jsonHourly',
 			daily: 'statistics.jsonDaily',
@@ -594,134 +941,528 @@ class statistics {
 			data = [];
 		}
 
-		// default chart configuration (based on flexcharts discussion example)
-		const chart = {
-			tooltip: { trigger: 'axis', axisPointer: { type: 'cross' } },
-			legend: { show: true, orient: 'horizontal', left: 'center', top: 25 },
-			title: { left: 'center', text: 'Statistics ' },
-			grid: { right: '20%' },
-			toolbox: { feature: { dataView: { show: true, readOnly: false }, restore: { show: true }, saveAsImage: { show: true } } },
-			xAxis: [{ type: 'category', axisTick: { alignWithLabel: true }, data: [] }],
-			yAxis: [{ type: 'value', position: 'left', alignTicks: true, axisLine: { show: true }, axisLabel: { formatter: '{value}' } }],
-			series: [],
-		};
-
-		// merge with user-provided template if available
-		const templateStr = this.stateCache.get('statistics.flexChartTemplate')?.value;
-		if (templateStr) {
-			try {
-				const templ = JSON.parse(templateStr);
-				for (const key of Object.keys(templ)) {
-					if (chart[key] && typeof chart[key] === 'object' && typeof templ[key] === 'object') {
-						// merge sub-objects shallowly
-						Object.assign(chart[key], templ[key]);
-					} else {
-						chart[key] = templ[key];
-					}
+		// --- X-Axis labels ---
+		const xAxisData = data.map(entry => {
+			const from = new Date(entry.from);
+			const to = new Date(entry.to);
+			if (myChart === 'hourly') {
+				return `${to.toLocaleDateString('de-DE', { year: 'numeric', month: '2-digit', day: '2-digit' })} ${to.toLocaleTimeString('de-DE', {
+					hour12: false,
+					hour: '2-digit',
+					minute: '2-digit',
+				})}`;
+			}
+			if (myChart === 'weekly') {
+				const toDay = new Date(to);
+				//mitnight -> the day before
+				if (toDay.getHours() === 0 && toDay.getMinutes() === 0) {
+					toDay.setDate(toDay.getDate() - 1);
 				}
-			} catch (e) {
-				this.adapter.logger.warn(`statistics: invalid flexChartTemplate JSON: ${e.message}`);
+				return `${from.toLocaleDateString('de-DE', { month: '2-digit', day: '2-digit' })}-${toDay.toLocaleDateString('de-DE', { month: '2-digit', day: '2-digit' })}`;
 			}
+			if (myChart === 'monthly') {
+				return from.toLocaleDateString('de-DE', { year: 'numeric', month: '2-digit' });
+			}
+			if (myChart === 'annual') {
+				return from.toLocaleDateString('de-DE', { year: 'numeric' });
+			}
+			return from.toLocaleDateString('de-DE', { year: 'numeric', month: '2-digit', day: '2-digit' });
+		});
+
+		const xAxisDataShort = myChart === 'hourly' ? xAxisData.map(label => label.split(' ')[1]) : xAxisData;
+
+		// --- Day areas (hourly only) ---
+		const dayAreas = [];
+		if (myChart === 'hourly' && xAxisData.length > 0) {
+			const dayBoundaries = [0];
+			xAxisData.forEach((label, i) => {
+				if (i === 0) return;
+				const date = label.split(' ')[0];
+				const prevDate = xAxisData[i - 1].split(' ')[0];
+				if (date !== prevDate) dayBoundaries.push(i);
+			});
+			dayBoundaries.push(xAxisData.length);
+
+			dayBoundaries.forEach((startIdx, d) => {
+				if (d >= dayBoundaries.length - 1) return;
+				const endIdx = dayBoundaries[d + 1];
+				const date = xAxisData[startIdx].split(' ')[0];
+				const shaded = d % 2 === 1;
+				dayAreas.push([
+					{
+						xAxis: startIdx - 0.5,
+						label: {
+							show: true,
+							position: 'insideTop',
+							formatter: date,
+							color: '#555',
+							fontSize: 11,
+							fontWeight: 'bold',
+							backgroundColor: 'rgba(255,255,255,0.7)',
+							padding: [2, 4],
+							borderRadius: 3,
+						},
+					},
+					{
+						xAxis: endIdx - 0.5,
+						itemStyle: shaded
+							? { color: 'rgba(180,180,180,0.15)', borderColor: 'rgba(120,120,120,0.3)', borderWidth: 1, borderType: 'dashed' }
+							: { color: 'rgba(255,255,255,0)' },
+					},
+				]);
+			});
 		}
 
-		// fill data arrays and collect units from stats definitions
-		const xAxis = [];
-		const seriesData = {};
-		const unitMap = {}; // targetPath -> unit string
+		// --- Series data extraction ---
+		const extract = key => data.map(e => Number(Number(e[key]?.value ?? 0).toFixed(3)));
+		const negate = arr => arr.map(v => Number((-v).toFixed(3)));
 
+		// Build seriesData from all this.stats entries (targetPath as key)
+		const seriesData = {};
 		for (const stat of this.stats) {
-			unitMap[stat.targetPath] = stat.unit || '';
+			const values = extract(stat.targetPath);
+			seriesData[stat.targetPath] = values;
+			seriesData[`${stat.targetPath}Neg`] = negate(values);
 		}
 
-		for (const entry of data) {
-			const from = new Date(entry.from);
-			//const to = new Date(entry.to);
-			const xVal =
-				myChart === 'hourly'
-					? from.toLocaleTimeString('de-DE', { hour12: false, hour: '2-digit', minute: '2-digit' })
-					: from.toLocaleDateString('de-DE', { year: 'numeric', month: '2-digit', day: '2-digit' });
-			xAxis.push(xVal);
-			for (const stat of this.stats) {
-				const val = Number(entry[stat.targetPath]?.value ?? 0);
-				if (!seriesData[stat.targetPath]) {
-					seriesData[stat.targetPath] = [];
-				}
-				seriesData[stat.targetPath].push(Number(val.toFixed(3)));
+		// --- Tooltip formatter ---
+		const tooltipFormatter = params => {
+			if (!Array.isArray(params)) params = [params];
+			return params
+				.filter(p => p.seriesName !== 'DayBreak')
+				.map(p => {
+					const negatedSeries = ['Grid Export', 'Charge'];
+					const val = negatedSeries.includes(p.seriesName) ? Math.abs(p.value) : p.value;
+					const unit = ['SOC', 'Self-sufficiency', 'Self-consumption'].includes(p.seriesName) ? ' %' : ' kWh';
+					const seriesName =
+						myChart === 'hourly' && ['Self-sufficiency', 'Self-consumption'].includes(p.seriesName) ? `${p.seriesName} today` : p.seriesName;
+					return `${p.marker}${seriesName}: <b>${val}${unit}</b>`;
+				})
+				.join('<br/>');
+		};
+
+		// --- Load chart-type specific template ---
+		const templateStateId = `statistics.flexCharts.template.${myChart}`;
+		const outputStateId = `statistics.flexCharts.jsonOutput.${myChart}`;
+
+		const templateStr = this.stateCache.get(templateStateId)?.value ?? '{}';
+		let chartStr = '{}';
+
+		try {
+			const templ = JSON.parse(templateStr);
+			if (Object.keys(templ).length === 0) {
+				chartStr = this._buildDefaultChart(myChart, chartStyle, xAxisData, xAxisDataShort, dayAreas, seriesData);
+			} else {
+				chartStr = stringify(templ);
 			}
+		} catch (e) {
+			this.adapter.logger.warn(`statistics: invalid template for ${myChart}: ${e.message}`);
+			chartStr = this._buildDefaultChart(myChart, chartStyle, xAxisData, xAxisDataShort, dayAreas, seriesData);
 		}
-		chart.xAxis[0].data = xAxis;
-
-		// apply unit information to axis/tooltip if there is a single unit or per-series
-		const units = new Set(Object.values(unitMap).filter(u => u));
-		if (units.size === 1) {
-			const singleUnit = [...units][0];
-			// update default yAxis label and tooltip formatter
-			chart.yAxis[0].name = singleUnit ? `(${singleUnit})` : '';
-			chart.yAxis[0].axisLabel.formatter = `{value}${singleUnit ? ` ${singleUnit}` : ''}`;
-			chart.tooltip.formatter = params => {
-				if (!Array.isArray(params)) params = [params];
-				return params.map(p => `${p.seriesName}: ${p.value}${singleUnit ? ` ${singleUnit}` : ''}`).join('<br/>');
-			};
-		} else if (units.size > 1) {
-			// multiple units – show per-series unit in tooltip
-			chart.tooltip.formatter = params => {
-				if (!Array.isArray(params)) params = [params];
-				return params
-					.map(p => {
-						const u = unitMap[p.seriesName] || '';
-						return `${p.seriesName}: ${p.value}${u ? ` ${u}` : ''}`;
-					})
-					.join('<br/>');
-			};
+
+		// --- Replace placeholders ---
+		chartStr = chartStr
+			.replace("'%%xAxisData%%'", JSON.stringify(xAxisData))
+			.replace("'%%xAxisDataShort%%'", JSON.stringify(xAxisDataShort))
+			.replace("'%%xAxisMax%%'", String(xAxisData.length - 1))
+			.replace("'%%chartTitle%%'", JSON.stringify(`PV Statistics — ${myChart}`))
+			.replace("'%%dayAreas%%'", JSON.stringify(dayAreas))
+			.replace("'%%tooltipFormatter%%'", stringify(tooltipFormatter));
+
+		// All this.stats entries dynamically — both positive and negated
+		for (const stat of this.stats) {
+			const key = stat.targetPath;
+			chartStr = chartStr.replace(`'%%${key}%%'`, JSON.stringify(seriesData[key])).replace(`'%%${key}Neg%%'`, JSON.stringify(seriesData[`${key}Neg`]));
 		}
 
-		// if chart.series was pre-populated by template use names, otherwise create default series
-		if (chart.series && chart.series.length > 0) {
-			chart.series.forEach(s => {
-				// try exact name first, otherwise case-insensitive lookup
-				let key = s.name;
-				if (seriesData[key]) {
-					s.data = seriesData[key];
-				} else {
-					// find matching key ignoring case
-					const found = Object.keys(seriesData).find(k => k.toLowerCase() === String(key).toLowerCase());
-					if (found) {
-						s.data = seriesData[found];
-					} else {
-						s.data = [];
-					}
-				}
-				// ensure unit is added from stats definitions if not present
-				if (!s.unit) {
-					let unitVal = unitMap[key];
-					if (!unitVal) {
-						const foundu = Object.keys(unitMap).find(k => k.toLowerCase() === String(key).toLowerCase());
-						if (foundu) unitVal = unitMap[foundu];
-					}
-					s.unit = unitVal || '';
-				}
-			});
-		} else {
-			chart.series = Object.keys(seriesData).map(name => ({
-				name,
-				type: 'line',
-				data: seriesData[name],
-				unit: unitMap[name] || '',
-			}));
+		this.stateCache.set(outputStateId, chartStr, { type: 'string' });
+		this.adapter.logger.debug(`statistics: flexCharts built for ${myChart}/${chartStyle}`);
+
+		return chartStr;
+	}
+
+	/**
+	 * Build the default chart configuration as javascript-stringify string.
+	 * Used when no template is provided.
+	 * @param myChart
+	 * @param chartStyle
+	 * @param xAxisData
+	 * @param xAxisDataShort
+	 * @param dayAreas
+	 * @param seriesData
+	 */
+	_buildDefaultChart(myChart, chartStyle, xAxisData, xAxisDataShort, dayAreas, seriesData) {
+		const xAxisFormatterHourly = value => {
+			if (value.includes('|')) return value;
+			return value.split(' ')[1] ?? value;
+		};
+
+		const seriesType = chartStyle === 'line' ? 'line' : 'bar';
+		const lineOptions =
+			chartStyle === 'line' ? { smooth: true, symbol: 'circle', symbolSize: 4, lineStyle: { width: 2 }, areaStyle: { opacity: 0.15 } } : {};
+
+		const negate = arr => arr.map(v => Number((-v).toFixed(3)));
+		const showSOC = myChart === 'hourly';
+
+		// No-data hint — chart-type specific
+		const noDataHints = {
+			hourly: 'No data yet — first entry available after the next full hour.',
+			daily: 'No data yet — first entry available tomorrow after midnight.',
+			weekly: 'No data yet — first entry available after the current week ends.',
+			monthly: 'No data yet — first entry available after the current month ends.',
+			annual: 'No data yet — first entry available after the current year ends.',
+		};
+
+		const tooltipFormatter = params => {
+			if (!Array.isArray(params)) params = [params];
+			return params
+				.filter(p => p.seriesName !== 'DayBreak')
+				.map(p => {
+					const negatedSeries = ['Grid Export', 'Charge'];
+					const val = negatedSeries.includes(p.seriesName) ? Math.abs(p.value) : p.value;
+					const unit = ['SOC', 'Self-sufficiency', 'Self-consumption'].includes(p.seriesName) ? ' %' : ' kWh';
+					const seriesName =
+						myChart === 'hourly' && ['Self-sufficiency', 'Self-consumption'].includes(p.seriesName) ? `${p.seriesName} today` : p.seriesName;
+					return `${p.marker}${seriesName}: <b>${val}${unit}</b>`;
+				})
+				.join('<br/>');
+		};
+
+		// --- Slider start position — show recent entries by default ---
+		// For hourly: show last 25 entries (~1 day)
+		// For daily: show last 7 entries (~1 week)
+		// For weekly: show last 8 entries (~2 months)
+		// For monthly: show last 13 entries (~1 year)
+		// For annual: show full range
+		const sliderDefaults = {
+			hourly: { start: Math.max(0, Math.round((1 - 25 / Math.max(xAxisData.length, 1)) * 100)), end: 100 },
+			daily: { start: Math.max(0, Math.round((1 - 7 / Math.max(xAxisData.length, 1)) * 100)), end: 100 },
+			weekly: { start: Math.max(0, Math.round((1 - 8 / Math.max(xAxisData.length, 1)) * 100)), end: 100 },
+			monthly: { start: Math.max(0, Math.round((1 - 13 / Math.max(xAxisData.length, 1)) * 100)), end: 100 },
+			annual: { start: 0, end: 100 },
+		};
+		const slider = sliderDefaults[myChart] ?? { start: 0, end: 100 };
+
+		const chart = {
+			backgroundColor: '#fff',
+			animation: false,
+			title: {
+				left: 'center',
+				text: `SUN2000 - PV Statistics - ${myChart}`,
+			},
+			legend: {
+				top: 35,
+				left: 'center',
+				data: [
+					'Solar Yield',
+					'Grid Export',
+					'Grid Import',
+					'Charge',
+					'Discharge',
+					...(showSOC ? ['SOC'] : []),
+					'Self-sufficiency',
+					'Self-consumption',
+					'Consumption',
+				],
+			},
+			tooltip: {
+				trigger: 'axis',
+				axisPointer: { type: 'cross' },
+				backgroundColor: 'rgba(245,245,245,0.95)',
+				borderWidth: 1,
+				borderColor: '#ccc',
+				padding: 10,
+				textStyle: { color: '#000' },
+				formatter: '%%tooltipFormatter%%',
+				position: (pos, params, el, elRect, size) => {
+					const obj = { top: 10 };
+					obj[pos[0] < size.viewSize[0] / 2 ? 'left' : 'right'] = 30;
+					return obj;
+				},
+			},
+			axisPointer: {
+				link: [{ xAxisIndex: 'all' }],
+				label: { backgroundColor: '#777' },
+			},
+			toolbox: {
+				feature: {
+					dataZoom: { yAxisIndex: false },
+					dataView: { show: true, readOnly: false },
+					restore: { show: true },
+					saveAsImage: { show: true },
+				},
+			},
+			// No-data graphic — shown only when data is empty
+			graphic:
+				xAxisData.length === 0
+					? [
+							{
+								type: 'text',
+								left: 'center',
+								top: 'middle',
+								style: {
+									text: noDataHints[myChart] || 'No data available yet.',
+									fontSize: 14,
+									fill: '#999',
+								},
+							},
+						]
+					: [],
+			grid: [
+				{ left: '8%', right: showSOC ? '8%' : '4%', top: 80, height: '45%' },
+				{ left: '8%', right: showSOC ? '8%' : '4%', top: '72%', height: '15%' },
+			],
+			xAxis: [
+				{
+					type: 'category',
+					data: xAxisDataShort,
+					scale: true,
+					boundaryGap: chartStyle !== 'line',
+					axisLine: { onZero: false },
+					splitLine: { show: false },
+					axisPointer: { z: 100 },
+					min: 0,
+					max: xAxisDataShort.length - 1,
+					axisLabel: {
+						interval: 0,
+						lineHeight: 16,
+						fontSize: 11,
+						formatter: '%%xAxisFormatter%%',
+					},
+				},
+				{
+					type: 'category',
+					gridIndex: 1,
+					data: xAxisData,
+					scale: true,
+					boundaryGap: chartStyle !== 'line',
+					axisLine: { onZero: false },
+					axisTick: { show: false },
+					splitLine: { show: false },
+					axisLabel: { show: false },
+					min: 0,
+					max: xAxisData.length - 1,
+				},
+			],
+			yAxis: [
+				// Index 0 — Energy left axis
+				{
+					scale: false,
+					splitArea: { show: true },
+					name: 'Energy (kWh)',
+					nameLocation: 'middle',
+					nameGap: 50,
+					axisLabel: { formatter: '{value} kWh' },
+					splitLine: { show: true },
+					axisLine: { show: true },
+				},
+				// Index 1 — SOC / ratio right axis
+				{
+					type: 'value',
+					min: 0,
+					max: 100,
+					name: showSOC ? 'SOC / Ratio (%)' : 'Ratio (%)',
+					nameLocation: 'middle',
+					nameGap: 50,
+					axisLabel: { formatter: '{value} %' },
+					splitLine: { show: false },
+					axisLine: { show: true },
+				},
+				// Index 2 — Consumption lower grid
+				{
+					scale: true,
+					gridIndex: 1,
+					splitNumber: 3,
+					axisLine: { show: false },
+					axisTick: { show: false },
+					splitLine: { show: false },
+					name: 'Consumption\n(kWh)',
+					nameLocation: 'middle',
+					nameGap: 50,
+					axisLabel: { formatter: '{value}' },
+				},
+			],
+			dataZoom: [
+				{
+					type: 'inside',
+					xAxisIndex: [0, 1],
+					start: slider.start,
+					end: slider.end,
+				},
+				{
+					show: true,
+					xAxisIndex: [0, 1],
+					type: 'slider',
+					bottom: 5,
+					start: slider.start,
+					end: slider.end,
+				},
+			],
+			series: [
+				// Positive values (above zero line)
+				{
+					name: 'Solar Yield',
+					type: seriesType,
+					data: seriesData.solarYield,
+					itemStyle: { color: '#f6c94e' },
+					emphasis: { focus: 'series' },
+					...lineOptions,
+				},
+				// Negative values (below zero line)
+				{
+					name: 'Grid Export',
+					type: seriesType,
+					data: negate(seriesData.gridExport),
+					itemStyle: { color: '#5cb85c' },
+					emphasis: { focus: 'series' },
+					...lineOptions,
+				},
+				{
+					name: 'Grid Import',
+					type: seriesType,
+					data: seriesData.gridImport,
+					itemStyle: { color: '#ec0000' },
+					emphasis: { focus: 'series' },
+					...lineOptions,
+				},
+				{
+					name: 'Charge',
+					type: seriesType,
+					data: negate(seriesData.chargeCapacity),
+					itemStyle: { color: '#5bc0de' },
+					emphasis: { focus: 'series' },
+					...lineOptions,
+				},
+				{
+					name: 'Discharge',
+					type: seriesType,
+					data: seriesData.dischargeCapacity,
+					itemStyle: { color: '#ed50e0' },
+					emphasis: { focus: 'series' },
+					...lineOptions,
+				},
+				// SOC — hourly only, on right axis
+				...(showSOC
+					? [
+							{
+								name: 'SOC',
+								type: 'line',
+								yAxisIndex: 1,
+								data: seriesData.SOC,
+								itemStyle: { color: '#985e24' },
+								lineStyle: { width: 2, type: 'dashed' },
+								symbol: 'none',
+								smooth: true,
+							},
+						]
+					: []),
+				// Self-sufficiency — right axis
+				{
+					name: 'Self-sufficiency',
+					type: 'line',
+					yAxisIndex: 1,
+					data: seriesData.selfSufficiency,
+					itemStyle: { color: '#9c27b0' },
+					lineStyle: { width: 2, type: 'dashed' },
+					symbol: 'circle',
+					symbolSize: 4,
+					smooth: true,
+				},
+				// Self-consumption — right axis
+				{
+					name: 'Self-consumption',
+					type: 'line',
+					yAxisIndex: 1,
+					data: seriesData.selfConsumption,
+					itemStyle: { color: '#ff9800' },
+					lineStyle: { width: 2, type: 'dashed' },
+					symbol: 'circle',
+					symbolSize: 4,
+					smooth: true,
+				},
+				// Consumption in lower grid — always yAxisIndex 2
+				{
+					name: 'Consumption',
+					type: seriesType,
+					data: seriesData.consumption,
+					itemStyle: { color: '#337ab7' },
+					xAxisIndex: 1,
+					yAxisIndex: 2,
+					...lineOptions,
+				},
+				// Day-break areas (hourly only)
+				...(dayAreas.length > 0
+					? [
+							{
+								name: 'DayBreak',
+								type: 'bar',
+								barWidth: 0,
+								data: [],
+								legendHoverLink: false,
+								silent: true,
+								markArea: { silent: true, data: dayAreas },
+							},
+						]
+					: []),
+			],
+		};
+
+		return stringify(chart).replace("'%%xAxisFormatter%%'", stringify(xAxisFormatterHourly)).replace("'%%tooltipFormatter%%'", stringify(tooltipFormatter));
+	}
+
+	/**
+	 * Merges two objects deeply.
+	 * @param target
+	 * @param source
+	 */
+	_deepMerge(target, source) {
+		for (const key of Object.keys(source)) {
+			if (
+				source[key] !== null &&
+				typeof source[key] === 'object' &&
+				!Array.isArray(source[key]) &&
+				target[key] !== null &&
+				typeof target[key] === 'object' &&
+				!Array.isArray(target[key])
+			) {
+				this._deepMerge(target[key], source[key]);
+			} else {
+				target[key] = source[key];
+			}
+		}
+		return target;
+	}
+
+	/**
+	 * Handles a template state change — updates cache, acknowledges and rebuilds chart.
+	 * @param chartType
+	 * @param state
+	 */
+	async handleTemplateChange(chartType, state) {
+		const templateStateId = `statistics.flexCharts.template.${chartType}`;
+		const template = this.stateCache.get(templateStateId)?.value;
+		if (template === null || template === undefined) {
+			this.adapter.logger.warn(`Template state ${templateStateId} not found for handleTemplateChange`);
+			return;
+		}
+		if (state?.val != null) {
+			this.adapter.logger.debug(`statistics: Event - state: ${chartType} changed: ${state.val} ack: ${state.ack}`);
+			this.stateCache.set(templateStateId, state.val, { type: 'string', stored: true });
+			await this.adapter.setState(templateStateId, { val: state.val, ack: true });
+			this._buildFlexchart(chartType);
 		}
-		chart.title.text += myChart;
-		return chart;
 	}
 
 	/**
 	 * Entry point for adapter to handle messages related to statistics/flexcharts.
 	 *
-	 * @param {{chart?: string}} message
+	 * @param {{chart?: string, style?: string}} message
 	 * @param {Function} callback
 	 */
 	handleFlexMessage(message, callback) {
 		const chartType = message?.chart || 'hourly';
-		const result = this._buildFlexchart(chartType);
+		const chartStyle = message?.style;
+		const result = this._buildFlexchart(chartType, chartStyle);
 		if (callback && typeof callback === 'function') {
 			callback(result);
 		}