iobroker.sun2000 2.4.2 → 2.4.3

package/lib/statistics.js

@@ -25,6 +25,7 @@ class statistics {
 		this.stateCache = stateCache;
 		this.taskTimer = null;
 		this._path = 'statistics';
+		this._initialized = false;
 		this.testing = false; // set to true for testing purposes
 
 		this.stats = [
@@ -32,7 +33,7 @@ class statistics {
 				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
+				type: statisticsType.deltaReset,
 			},
 			{
 				sourceId: 'collected.dailySolarYield',
@@ -41,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 = [
@@ -104,8 +132,16 @@ class statistics {
 						desc: 'Annual consumption per year',
 						initVal: '[]',
 					},
-					// a state where users may store a Flexcharts/eCharts options template
-					// --- Templates: eines pro Chart-Typ ---
+					// 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',
@@ -151,7 +187,7 @@ class statistics {
 						write: true,
 						initVal: '{}',
 					},
-					// --- Output: eines pro Chart-Typ ---
+					// Output: one per chart type
 					{
 						id: 'statistics.flexCharts.jsonOutput.hourly',
 						name: 'Flexcharts output hourly',
@@ -228,12 +264,10 @@ 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.
 	 */
-
 	_calculateGeneric(stateId, periodStart, periodEnde) {
 		const toStr = this._localIsoWithOffset(periodEnde);
 		let jsonStr = this.stateCache.get(stateId)?.value ?? '[]';
@@ -248,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);
@@ -262,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`);
@@ -272,42 +308,54 @@ 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;
 	}
 
+	/**
+	 * Removes entries older than periodStart from the given state.
+	 *
+	 * @param {string} stateId
+	 * @param {Date} periodStart
+	 */
 	_clearGeneric(stateId, periodStart) {
 		let jsonStr = this.stateCache.get(stateId)?.value ?? '[]';
 		let arr = [];
@@ -317,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 - 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 - 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
+	 * @param {string} targetStateId
+	 * @param {Function} getWindow
+	 * @param {string} periodType
+	 * @returns {boolean} true if a new entry was appended, false otherwise.
+	 */
+	_calculateAggregation_old(sourceStateId, targetStateId, getWindow, periodType) {
 		try {
 			const now = new Date();
 			const window = getWindow(now);
@@ -350,8 +532,8 @@ class statistics {
 				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 {
@@ -361,8 +543,8 @@ class statistics {
 				targetArray = [];
 			}
 
-			// Avoid duplicates
 			const last = targetArray.length > 0 ? targetArray[targetArray.length - 1] : {};
+
 			if (last.to === toStr) return false;
 
 			const target = {
@@ -370,7 +552,6 @@ class statistics {
 				to: toStr,
 			};
 
-			// Load source entries
 			let jsonStr = this.stateCache.get(sourceStateId)?.value ?? '[]';
 			let sourceEntries = [];
 			try {
@@ -380,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);
@@ -408,13 +584,23 @@ 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);
@@ -422,89 +608,165 @@ class statistics {
 
 			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} `);
+			this.adapter.logger.debug(`Appended ${periodType} statistic ${toStr}`);
 			return targetArray.length > 0;
 		} catch (err) {
 			this.adapter.logger.warn(`Error during ${periodType} aggregation: ${err.message}`);
 		}
 	}
 
+	/**
+	 * 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.
-	 *
-	 * 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.
-	 *
-	 * @returns {void}
 	 */
 	_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); // 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
+			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 ###');
+		this.adapter.log.debug(`### Hourly execution triggered with lastHour: ${lastHour.toLocaleTimeString()} ###`);
 		if (this._calculateGeneric('statistics.jsonHourly', startOfDay, lastHour)) {
 			this._buildFlexchart('hourly');
 		}
 	}
 
-	/**
-	 * Calculates and updates daily consumption statistics from hourly data.
-	 *
-	 * @returns {void}
-	 */
 	_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._buildFlexchart('daily'); // 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}
 	 */
 	_calculateWeekly() {
 		this.adapter.log.debug('### Weekly execution triggered ###');
-		if (
-			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 };
-				},
-				'weekly',
-			)
-		) {
-			this._buildFlexchart('weekly');
-		} // only update last execution time if aggregation was performed to avoid backfilling multiple weeks at startup
+		this._calculateAggregation(
+			'statistics.jsonDaily',
+			'statistics.jsonWeekly',
+			now => {
+				// 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',
+		);
+
+		// 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}
 	 */
 	_calculateMonthly() {
 		this.adapter.log.debug('### Monthly execution triggered ###');
@@ -512,19 +774,28 @@ class statistics {
 			'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._buildFlexchart('monthly'); // 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}
 	 */
 	_calculateAnnual() {
 		this.adapter.log.debug('### Annual execution triggered ###');
@@ -532,47 +803,57 @@ class statistics {
 			'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._buildFlexchart('annual'); // 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.
 	 */
 	_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(() => {
 				this._executeScheduledTasks();
-				scheduleNextRun(); // reschedule for next hour
+				scheduleNextRun();
 			}, msToNextHour);
 		};
-		// Schedule the next run
 		scheduleNextRun();
 	}
+
 	_executeScheduledTasks() {
 		this._calculateHourly();
 		this._calculateDaily();
@@ -582,14 +863,13 @@ 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
 	 */
 	mitNightProcess() {
 		const now = new Date();
 		this._executeScheduledTasks();
-		// Clear old data based on retention policies
 		const startOfYear = new Date(now.getFullYear(), 0, 1, 0, 0, 0, 0);
 		this._clearGeneric('statistics.jsonDaily', startOfYear);
 		this._clearGeneric('statistics.jsonWeekly', startOfYear);
@@ -598,7 +878,6 @@ class statistics {
 	}
 
 	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 });
 
@@ -606,7 +885,7 @@ class statistics {
 		this.stateCache.set('statistics.jsonDaily', state?.val ?? '[]', { type: 'string', stored: true });
 
 		state = await this.adapter.getState('statistics.jsonWeekly');
-		this.stateCache.set('statistics.jsonWeekly', state?.val ?? '[]', { type: 'string', stored: true }); //is already stored
+		this.stateCache.set('statistics.jsonWeekly', state?.val ?? '[]', { type: 'string', stored: true });
 
 		state = await this.adapter.getState('statistics.jsonMonthly');
 		this.stateCache.set('statistics.jsonMonthly', state?.val ?? '[]', { type: 'string', stored: true });
@@ -614,10 +893,12 @@ class statistics {
 		state = await this.adapter.getState('statistics.jsonAnnual');
 		this.stateCache.set('statistics.jsonAnnual', 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
+		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);
 
-		// load templates — eines pro Chart-Typ
+		// 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);
@@ -629,13 +910,22 @@ class statistics {
 			}
 		}
 
-		this.mitNightProcess(); // execute once on startup to catch up on any missed runs while the adapter was not running
+		this.mitNightProcess();
 		this._initializeTask();
 		this.adapter.subscribeStates(`${this._path}.*`);
+		this._initialized = true;
 	}
 
+	/**
+	 * Builds and updates the Flexchart configuration for the specified chart type.
+	 *
+	 * @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, chartStyle) {
-		chartStyle = chartStyle || (myChart === 'hourly' ? 'line' : 'bar'); // default styles: line for hourly (to better see the curve), bar for others
+		chartStyle = chartStyle || (myChart === 'hourly' ? 'line' : 'bar');
+
 		const IDS = {
 			hourly: 'statistics.jsonHourly',
 			daily: 'statistics.jsonDaily',
@@ -663,9 +953,12 @@ class statistics {
 				})}`;
 			}
 			if (myChart === 'weekly') {
-				const yesterday = new Date(to);
-				yesterday.setDate(yesterday.getDate() - 1);
-				return `${from.toLocaleDateString('de-DE', { month: '2-digit', day: '2-digit' })}..${yesterday.toLocaleTimeString('de-DE', { month: '2-digit', day: '2-digit' })}`;
+				const toDay = new Date(to);
+				//mitnight -> the day before
+				if (toDay.getHours() === 0 && toDay.getMinutes() === 0) {
+					toDay.setDate(toDay.getDate() - 1);
+				}
+				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' });
@@ -673,22 +966,12 @@ class statistics {
 			if (myChart === 'annual') {
 				return from.toLocaleDateString('de-DE', { year: 'numeric' });
 			}
-
 			return from.toLocaleDateString('de-DE', { year: 'numeric', month: '2-digit', day: '2-digit' });
-			/*
-			return myChart === 'hourly'
-				? `${to.toLocaleDateString('de-DE', { year: 'numeric', month: '2-digit', day: '2-digit' })} ${to.toLocaleTimeString('de-DE', {
-						hour12: false,
-						hour: '2-digit',
-						minute: '2-digit',
-					})}`
-				: from.toLocaleDateString('de-DE', { year: 'numeric', month: '2-digit', day: '2-digit' });
-			*/
 		});
 
 		const xAxisDataShort = myChart === 'hourly' ? xAxisData.map(label => label.split(' ')[1]) : xAxisData;
 
-		// --- Tagesbereiche ---
+		// --- Day areas (hourly only) ---
 		const dayAreas = [];
 		if (myChart === 'hourly' && xAxisData.length > 0) {
 			const dayBoundaries = [0];
@@ -734,19 +1017,15 @@ class statistics {
 		const extract = key => data.map(e => Number(Number(e[key]?.value ?? 0).toFixed(3)));
 		const negate = arr => arr.map(v => Number((-v).toFixed(3)));
 
-		const seriesData = {
-			solarYield: extract('solarYield'),
-			consumption: extract('consumption'),
-			gridExport: extract('gridExport'),
-			gridImport: extract('gridImport'),
-			chargeCapacity: extract('chargeCapacity'),
-			dischargeCapacity: extract('dischargeCapacity'),
-			SOC: extract('SOC'),
-			gridExportNeg: negate(extract('gridExport')),
-			chargeCapacityNeg: negate(extract('chargeCapacity')),
-		};
+		// Build seriesData from all this.stats entries (targetPath as key)
+		const seriesData = {};
+		for (const stat of this.stats) {
+			const values = extract(stat.targetPath);
+			seriesData[stat.targetPath] = values;
+			seriesData[`${stat.targetPath}Neg`] = negate(values);
+		}
 
-		// --- Tooltip formatter (zeigt immer positive Werte, filtert DayBreak heraus) ---
+		// --- Tooltip formatter ---
 		const tooltipFormatter = params => {
 			if (!Array.isArray(params)) params = [params];
 			return params
@@ -754,8 +1033,10 @@ class statistics {
 				.map(p => {
 					const negatedSeries = ['Grid Export', 'Charge'];
 					const val = negatedSeries.includes(p.seriesName) ? Math.abs(p.value) : p.value;
-					const unit = p.seriesName === 'SOC' ? ' %' : ' kWh';
-					return `${p.marker}${p.seriesName}: <b>${val}${unit}</b>`;
+					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/>');
 		};
@@ -769,12 +1050,9 @@ class statistics {
 
 		try {
 			const templ = JSON.parse(templateStr);
-
 			if (Object.keys(templ).length === 0) {
-				// Kein Template → built-in Default
 				chartStr = this._buildDefaultChart(myChart, chartStyle, xAxisData, xAxisDataShort, dayAreas, seriesData);
 			} else {
-				// Template vorhanden → mit javascript-stringify serialisieren
 				chartStr = stringify(templ);
 			}
 		} catch (e) {
@@ -782,30 +1060,21 @@ class statistics {
 			chartStr = this._buildDefaultChart(myChart, chartStyle, xAxisData, xAxisDataShort, dayAreas, seriesData);
 		}
 
-		// --- Replace data placeholders ---
+		// --- Replace placeholders ---
 		chartStr = chartStr
-			// X-Achse
 			.replace("'%%xAxisData%%'", JSON.stringify(xAxisData))
 			.replace("'%%xAxisDataShort%%'", JSON.stringify(xAxisDataShort))
 			.replace("'%%xAxisMax%%'", String(xAxisData.length - 1))
-			// Originaldaten (immer positiv)
-			.replace("'%%solarYield%%'", JSON.stringify(seriesData.solarYield))
-			.replace("'%%consumption%%'", JSON.stringify(seriesData.consumption))
-			.replace("'%%gridExport%%'", JSON.stringify(seriesData.gridExport))
-			.replace("'%%gridImport%%'", JSON.stringify(seriesData.gridImport))
-			.replace("'%%chargeCapacity%%'", JSON.stringify(seriesData.chargeCapacity))
-			.replace("'%%dischargeCapacity%%'", JSON.stringify(seriesData.dischargeCapacity))
-			.replace("'%%SOC%%'", JSON.stringify(seriesData.SOC))
-			// Negierte Varianten für gegenläufige Darstellung
-			.replace("'%%gridExportNeg%%'", JSON.stringify(seriesData.gridExportNeg))
-			.replace("'%%chargeCapacityNeg%%'", JSON.stringify(seriesData.chargeCapacityNeg))
-			// Sonstiges
-			.replace("'%%dayAreas%%'", JSON.stringify(dayAreas))
 			.replace("'%%chartTitle%%'", JSON.stringify(`PV Statistics — ${myChart}`))
-			// Funktionen
+			.replace("'%%dayAreas%%'", JSON.stringify(dayAreas))
 			.replace("'%%tooltipFormatter%%'", stringify(tooltipFormatter));
 
-		// --- In chart-type specific output state speichern ---
+		// 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`]));
+		}
+
 		this.stateCache.set(outputStateId, chartStr, { type: 'string' });
 		this.adapter.logger.debug(`statistics: flexCharts built for ${myChart}/${chartStyle}`);
 
@@ -835,7 +1104,15 @@ class statistics {
 		const negate = arr => arr.map(v => Number((-v).toFixed(3)));
 		const showSOC = myChart === 'hourly';
 
-		// Tooltip formatter — zeigt immer positive Werte, filtert DayBreak heraus
+		// 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
@@ -843,12 +1120,29 @@ class statistics {
 				.map(p => {
 					const negatedSeries = ['Grid Export', 'Charge'];
 					const val = negatedSeries.includes(p.seriesName) ? Math.abs(p.value) : p.value;
-					const unit = p.seriesName === 'SOC' ? ' %' : ' kWh';
-					return `${p.marker}${p.seriesName}: <b>${val}${unit}</b>`;
+					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,
@@ -859,7 +1153,17 @@ class statistics {
 			legend: {
 				top: 35,
 				left: 'center',
-				data: ['Solar Yield', 'Consumption', 'Grid Export', 'Grid Import', 'Charge', 'Discharge', ...(showSOC ? ['SOC'] : [])],
+				data: [
+					'Solar Yield',
+					'Grid Export',
+					'Grid Import',
+					'Charge',
+					'Discharge',
+					...(showSOC ? ['SOC'] : []),
+					'Self-sufficiency',
+					'Self-consumption',
+					'Consumption',
+				],
 			},
 			tooltip: {
 				trigger: 'axis',
@@ -888,9 +1192,25 @@ class statistics {
 					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: '50%' },
-				{ left: '8%', right: showSOC ? '8%' : '4%', top: '75%', height: '15%' },
+				{ left: '8%', right: showSOC ? '8%' : '4%', top: 80, height: '45%' },
+				{ left: '8%', right: showSOC ? '8%' : '4%', top: '72%', height: '15%' },
 			],
 			xAxis: [
 				{
@@ -915,7 +1235,7 @@ class statistics {
 					gridIndex: 1,
 					data: xAxisData,
 					scale: true,
-					boundaryGap: false,
+					boundaryGap: chartStyle !== 'line',
 					axisLine: { onZero: false },
 					axisTick: { show: false },
 					splitLine: { show: false },
@@ -925,7 +1245,7 @@ class statistics {
 				},
 			],
 			yAxis: [
-				// Index 0 — Energie links
+				// Index 0 — Energy left axis
 				{
 					scale: false,
 					splitArea: { show: true },
@@ -936,23 +1256,19 @@ class statistics {
 					splitLine: { show: true },
 					axisLine: { show: true },
 				},
-				// Index 1 — SOC rechts (nur bei hourly)
-				...(showSOC
-					? [
-							{
-								type: 'value',
-								min: 0,
-								max: 100,
-								name: 'SOC (%)',
-								nameLocation: 'middle',
-								nameGap: 40,
-								axisLabel: { formatter: '{value} %' },
-								splitLine: { show: false },
-								axisLine: { show: true },
-							},
-						]
-					: []),
-				// Index 1 oder 2 — Consumption unteres Grid
+				// 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,
@@ -967,11 +1283,23 @@ class statistics {
 				},
 			],
 			dataZoom: [
-				{ type: 'inside', xAxisIndex: [0, 1], start: 0, end: 100 },
-				{ show: true, xAxisIndex: [0, 1], type: 'slider', bottom: 5, start: 0, end: 100 },
+				{
+					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 Werte
+				// Positive values (above zero line)
 				{
 					name: 'Solar Yield',
 					type: seriesType,
@@ -980,40 +1308,40 @@ class statistics {
 					emphasis: { focus: 'series' },
 					...lineOptions,
 				},
+				// Negative values (below zero line)
 				{
-					name: 'Grid Import',
+					name: 'Grid Export',
 					type: seriesType,
-					data: seriesData.gridImport,
-					itemStyle: { color: '#ec0000' },
+					data: negate(seriesData.gridExport),
+					itemStyle: { color: '#5cb85c' },
 					emphasis: { focus: 'series' },
 					...lineOptions,
 				},
 				{
-					name: 'Discharge',
+					name: 'Grid Import',
 					type: seriesType,
-					data: seriesData.dischargeCapacity,
-					itemStyle: { color: '#ed50e0' },
+					data: seriesData.gridImport,
+					itemStyle: { color: '#ec0000' },
 					emphasis: { focus: 'series' },
 					...lineOptions,
 				},
-				// Negative Werte (unterhalb Nulllinie)
 				{
-					name: 'Grid Export',
+					name: 'Charge',
 					type: seriesType,
-					data: negate(seriesData.gridExport),
-					itemStyle: { color: '#5cb85c' },
+					data: negate(seriesData.chargeCapacity),
+					itemStyle: { color: '#5bc0de' },
 					emphasis: { focus: 'series' },
 					...lineOptions,
 				},
 				{
-					name: 'Charge',
+					name: 'Discharge',
 					type: seriesType,
-					data: negate(seriesData.chargeCapacity),
-					itemStyle: { color: '#5bc0de' },
+					data: seriesData.dischargeCapacity,
+					itemStyle: { color: '#ed50e0' },
 					emphasis: { focus: 'series' },
 					...lineOptions,
 				},
-				// SOC — nur bei hourly
+				// SOC — hourly only, on right axis
 				...(showSOC
 					? [
 							{
@@ -1028,18 +1356,41 @@ class statistics {
 							},
 						]
 					: []),
-				// Consumption im unteren Grid
-				// yAxisIndex passt sich an: 2 wenn SOC vorhanden, sonst 1
+				// 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: showSOC ? 2 : 1,
+					yAxisIndex: 2,
 					...lineOptions,
 				},
-				// Tages-Bereiche
+				// Day-break areas (hourly only)
 				...(dayAreas.length > 0
 					? [
 							{
@@ -1059,6 +1410,11 @@ class statistics {
 		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 (
@@ -1069,16 +1425,19 @@ class statistics {
 				typeof target[key] === 'object' &&
 				!Array.isArray(target[key])
 			) {
-				// Rekursiv für verschachtelte Objekte
 				this._deepMerge(target[key], source[key]);
 			} else {
-				// Primitive, Arrays direkt überschreiben
 				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;
@@ -1097,7 +1456,7 @@ class statistics {
 	/**
 	 * 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) {