/**
 * Dashboard — real-time target status overview.
 */

import { apiKey, _dashboardLoading, set_dashboardLoading, dashboardPollInterval, setDashboardPollInterval, colorStripSourcesCache, devicesCache, outputTargetsCache } from '../core/state.ts';
import { API_BASE, getHeaders, fetchWithAuth, escapeHtml, fetchMetricsHistory } from '../core/api.ts';
import { t } from '../core/i18n.ts';
import { showToast, showConfirm, formatUptime, formatCompact, setTabRefreshing } from '../core/ui.ts';
import { renderPerfSection, renderPerfModeToggle, setPerfMode, initPerfCharts, startPerfPolling, stopPerfPolling } from './perf-charts.ts';
import { startAutoRefresh, updateTabBadge } from './tabs.ts';
import {
    ICON_TARGET, ICON_AUTOMATION, ICON_CLOCK, ICON_WARNING, ICON_OK,
    ICON_STOP, ICON_STOP_PLAIN, ICON_START, ICON_PAUSE, ICON_HELP, ICON_SCENE,
    ICON_PLUG, ICON_HOME, ICON_RADIO,
} from '../core/icons.ts';
import { loadScenePresets, renderScenePresetsSection, initScenePresetDelegation } from './scene-presets.ts';
import { cardColorStyle } from '../core/card-colors.ts';
import { createFpsSparkline } from '../core/chart-utils.ts';
import type { Device, OutputTarget, ColorStripSource, ScenePreset, SyncClock, Automation, HomeAssistantConnectionStatus, HomeAssistantStatusResponse, MQTTConnectionStatus, MQTTStatusResponse } from '../types.ts';

const DASHBOARD_COLLAPSED_KEY = 'dashboard_collapsed';
const MAX_FPS_SAMPLES = 120;

interface UptimeBase { seconds: number; timestamp: number; }
interface MetricsRefs { fps: Element | null; errors: Element | null; row: Element | null; }

let _fpsHistory: Record<string, number[]> = {};
let _fpsCurrentHistory: Record<string, number[]> = {};
let _fpsCharts: Record<string, any> = {};
let _lastRunningIds: string[] = [];
let _lastSyncClockIds: string = '';
let _uptimeBase: Record<string, UptimeBase> = {};
let _uptimeTimer: ReturnType<typeof setInterval> | null = null;
let _uptimeElements: Record<string, Element> = {};
let _metricsElements: Map<string, MetricsRefs> = new Map();

function _pushFps(targetId: string, actual: number, current: number): void {
    if (!_fpsHistory[targetId]) _fpsHistory[targetId] = [];
    _fpsHistory[targetId].push(actual);
    if (_fpsHistory[targetId].length > MAX_FPS_SAMPLES) _fpsHistory[targetId].shift();

    if (!_fpsCurrentHistory[targetId]) _fpsCurrentHistory[targetId] = [];
    _fpsCurrentHistory[targetId].push(current);
    if (_fpsCurrentHistory[targetId].length > MAX_FPS_SAMPLES) _fpsCurrentHistory[targetId].shift();
}

function _setUptimeBase(targetId: string, seconds: number): void {
    _uptimeBase[targetId] = { seconds, timestamp: Date.now() };
}

function _getInterpolatedUptime(targetId: string): number | null {
    const base = _uptimeBase[targetId];
    if (!base) return null;
    const elapsed = (Date.now() - base.timestamp) / 1000;
    return base.seconds + elapsed;
}

function _cacheUptimeElements(): void {
    _uptimeElements = {};
    for (const id of _lastRunningIds) {
        const el = document.querySelector(`[data-uptime-text="${CSS.escape(id)}"]`);
        if (el) _uptimeElements[id] = el;
    }
}

function _startUptimeTimer(): void {
    if (_uptimeTimer) return;
    _uptimeTimer = setInterval(() => {
        for (const id of _lastRunningIds) {
            const el = _uptimeElements[id];
            if (!el) continue;
            const seconds = _getInterpolatedUptime(id);
            if (seconds != null) {
                el.innerHTML = `${ICON_CLOCK} ${formatUptime(seconds)}`;
            }
        }
    }, 1000);
}

function _stopUptimeTimer(): void {
    if (_uptimeTimer) {
        clearInterval(_uptimeTimer);
        _uptimeTimer = null;
    }
    _uptimeBase = {};
    _uptimeElements = {};
}

function _destroyFpsCharts(): void {
    for (const id of Object.keys(_fpsCharts)) {
        if (_fpsCharts[id]) { _fpsCharts[id].destroy(); }
    }
    _fpsCharts = {};
}

function _createFpsChart(canvasId: string, actualHistory: number[], currentHistory: number[], fpsTarget: number): any {
    return createFpsSparkline(canvasId, actualHistory, currentHistory, fpsTarget);
}

async function _initFpsCharts(runningTargetIds: string[]): Promise<void> {
    _destroyFpsCharts();

    // Seed FPS history from server ring buffer (on first load and tab switches)
    if (runningTargetIds.length > 0) {
        const data = await fetchMetricsHistory();
        if (data) {
            const serverTargets = data.targets || {};
            for (const id of runningTargetIds) {
                const samples = serverTargets[id] || [];
                _fpsHistory[id] = samples.map(s => s.fps).filter(v => v != null);
                _fpsCurrentHistory[id] = samples.map(s => s.fps_current).filter(v => v != null);
            }
        }
    }

    // Clean up history for targets that are no longer running
    for (const id of Object.keys(_fpsHistory)) {
        if (!runningTargetIds.includes(id)) { delete _fpsHistory[id]; delete _fpsCurrentHistory[id]; }
    }
    for (const id of runningTargetIds) {
        const canvas = document.getElementById(`dashboard-fps-${id}`);
        if (!canvas) continue;
        const actualH = _fpsHistory[id] || [];
        const currentH = _fpsCurrentHistory[id] || [];
        const fpsTarget = parseFloat(canvas.dataset.fpsTarget ?? '30') || 30;
        _fpsCharts[id] = _createFpsChart(`dashboard-fps-${id}`, actualH, currentH, fpsTarget);
    }

    _cacheMetricsElements(runningTargetIds);
}

function _cacheMetricsElements(runningIds: string[]): void {
    _metricsElements.clear();
    for (const id of runningIds) {
        _metricsElements.set(id, {
            fps: document.querySelector(`[data-fps-text="${CSS.escape(id)}"]`),
            errors: document.querySelector(`[data-errors-text="${CSS.escape(id)}"]`),
            row: document.querySelector(`[data-target-id="${CSS.escape(id)}"]`),
        });
    }
}

/** Update running target metrics in-place (no HTML rebuild). */
function _updateRunningMetrics(enrichedRunning: any[]): void {
    for (const target of enrichedRunning) {
        const state = target.state || {};
        const metrics = target.metrics || {};
        const isHA = target.target_type === 'ha_light';
        const fpsTarget = state.fps_target || (target.settings || {}).fps || target.update_rate || '-';
        const fpsCurrent = isHA ? fpsTarget : (state.fps_current ?? 0);
        const fpsActual = isHA ? String(fpsTarget) : (state.fps_actual != null ? state.fps_actual.toFixed(1) : '-');
        const errors = metrics.errors_count || 0;

        // Push FPS and update chart
        if (state.fps_actual != null) {
            _pushFps(target.id, state.fps_actual, fpsCurrent);
        }
        const chart = _fpsCharts[target.id];
        if (chart) {
            const actualH = _fpsHistory[target.id] || [];
            const currentH = _fpsCurrentHistory[target.id] || [];
            // Left-pad with nulls so all charts span full width
            const pad0 = MAX_FPS_SAMPLES - actualH.length;
            const pad1 = MAX_FPS_SAMPLES - currentH.length;
            const ds0 = chart.data.datasets[0].data;
            ds0.length = 0;
            if (pad0 > 0) for (let i = 0; i < pad0; i++) ds0.push(null);
            ds0.push(...actualH);
            const ds1 = chart.data.datasets[1].data;
            ds1.length = 0;
            if (pad1 > 0) for (let i = 0; i < pad1; i++) ds1.push(null);
            ds1.push(...currentH);
            chart.data.labels.length = MAX_FPS_SAMPLES;
            chart.update('none');
        }

        // Refresh uptime base for interpolation
        if (metrics.uptime_seconds != null) {
            _setUptimeBase(target.id, metrics.uptime_seconds);
        }

        // Update text values (use cached refs, fallback to querySelector)
        const cached = _metricsElements.get(target.id);
        const fpsEl = cached?.fps || document.querySelector(`[data-fps-text="${CSS.escape(target.id)}"]`);
        if (fpsEl) {
            const effFps = state.fps_effective;
            const fpsTargetLabel = (effFps != null && effFps < fpsTarget)
                ? `${fpsCurrent}<span class="dashboard-fps-target">/${effFps}↓${fpsTarget}</span>`
                : `${fpsCurrent}<span class="dashboard-fps-target">/${fpsTarget}</span>`;
            const unreachableClass = state.device_streaming_reachable === false ? ' fps-unreachable' : '';
            fpsEl.innerHTML = `<span class="${unreachableClass}">${fpsTargetLabel}</span>`
                + `<span class="dashboard-fps-avg">avg ${fpsActual}</span>`;
        }

        const errorsEl = cached?.errors || document.querySelector(`[data-errors-text="${CSS.escape(target.id)}"]`);
        if (errorsEl) { errorsEl.innerHTML = `${errors > 0 ? ICON_WARNING : ICON_OK} ${formatCompact(errors)}`; (errorsEl as HTMLElement).title = String(errors); }

        // Update health dot — prefer streaming reachability when processing
        const isLed = target.target_type === 'led' || target.target_type === 'wled';
        if (isLed) {
            const row = cached?.row || document.querySelector(`[data-target-id="${CSS.escape(target.id)}"]`);
            if (row) {
                const dot = row.querySelector('.health-dot');
                if (dot) {
                    const streamReachable = state.device_streaming_reachable;
                    if (state.processing && streamReachable != null) {
                        dot.className = `health-dot ${streamReachable ? 'health-online' : 'health-offline'}`;
                    } else if (state.device_last_checked != null) {
                        dot.className = `health-dot ${state.device_online ? 'health-online' : 'health-offline'}`;
                    }
                }
            }
        }
    }

}

function _updateAutomationsInPlace(automations: Automation[]): void {
    for (const a of automations) {
        const card = document.querySelector(`[data-automation-id="${CSS.escape(a.id)}"]`);
        if (!card) continue;
        const badge = card.querySelector('.dashboard-badge-active, .dashboard-badge-stopped');
        if (badge) {
            if (!a.enabled) {
                badge.className = 'dashboard-badge-stopped';
                badge.textContent = t('automations.status.disabled');
            } else if (a.is_active) {
                badge.className = 'dashboard-badge-active';
                badge.textContent = t('automations.status.active');
            } else {
                badge.className = 'dashboard-badge-stopped';
                badge.textContent = t('automations.status.inactive');
            }
        }
        const btn = card.querySelector('.dashboard-target-actions .dashboard-action-btn');
        if (btn) {
            btn.className = `dashboard-action-btn ${a.enabled ? 'stop' : 'start'}`;
            btn.setAttribute('onclick', `dashboardToggleAutomation('${a.id}', ${!a.enabled})`);
            btn.innerHTML = a.enabled ? ICON_STOP_PLAIN : ICON_START;
        }
    }
}

function _updateSyncClocksInPlace(syncClocks: SyncClock[]): void {
    for (const c of syncClocks) {
        const card = document.querySelector(`[data-sync-clock-id="${CSS.escape(c.id)}"]`);
        if (!card) continue;
        const speedEl = card.querySelector('.dashboard-clock-speed');
        if (speedEl) speedEl.textContent = `${c.speed}x`;
        const btn = card.querySelector('.dashboard-target-actions .dashboard-action-btn');
        if (btn) {
            btn.className = `dashboard-action-btn ${c.is_running ? 'stop' : 'start'}`;
            btn.setAttribute('onclick', c.is_running ? `dashboardPauseClock('${c.id}')` : `dashboardResumeClock('${c.id}')`);
            btn.innerHTML = c.is_running ? ICON_PAUSE : ICON_START;
        }
    }
}

function _renderIntegrationCard(conn: HomeAssistantConnectionStatus): string {
    const healthClass = conn.connected ? 'health-online' : 'health-offline';
    const healthTitle = conn.connected
        ? `${t('ha_source.connected')} — ${conn.entity_count} ${t('dashboard.integrations.entities')}`
        : t('ha_source.disconnected');
    const statusDot = `<span class="health-dot ${healthClass}" title="${escapeHtml(healthTitle)}" role="status"></span>`;
    const subtitle = conn.connected
        ? `${conn.entity_count} ${t('dashboard.integrations.entities')}`
        : t('ha_source.disconnected');

    return `<div class="dashboard-target dashboard-autostart dashboard-card-link" data-integration-id="${conn.source_id}" onclick="if(!event.target.closest('button')){navigateToCard('streams','home_assistant','ha-sources','data-id','${conn.source_id}')}">
        <div class="dashboard-target-info">
            <span class="dashboard-target-icon">${ICON_HOME}</span>
            <div>
                <div class="dashboard-target-name"><span class="dashboard-target-name-text">${escapeHtml(conn.name)}</span>${statusDot}</div>
                <div class="dashboard-target-subtitle">${escapeHtml(subtitle)}</div>
            </div>
        </div>
    </div>`;
}

function _renderMQTTIntegrationCard(conn: MQTTConnectionStatus): string {
    const healthClass = conn.connected ? 'health-online' : 'health-offline';
    const healthTitle = conn.connected ? t('mqtt_source.connected') : t('mqtt_source.disconnected');
    const statusDot = `<span class="health-dot ${healthClass}" title="${escapeHtml(healthTitle)}" role="status"></span>`;
    const subtitle = conn.connected ? escapeHtml(conn.broker) : t('mqtt_source.disconnected');

    return `<div class="dashboard-target dashboard-autostart dashboard-card-link" data-integration-id="${conn.source_id}" onclick="if(!event.target.closest('button')){navigateToCard('streams','mqtt','mqtt-sources','data-id','${conn.source_id}')}">
        <div class="dashboard-target-info">
            <span class="dashboard-target-icon">${ICON_RADIO}</span>
            <div>
                <div class="dashboard-target-name"><span class="dashboard-target-name-text">${escapeHtml(conn.name)}</span>${statusDot}</div>
                <div class="dashboard-target-subtitle">${escapeHtml(subtitle)}</div>
            </div>
        </div>
    </div>`;
}

function _updateIntegrationsInPlace(haStatus: HomeAssistantStatusResponse, mqttStatus?: MQTTStatusResponse): void {
    // Update health dots and subtitles for each integration card
    for (const conn of haStatus.connections) {
        const card = document.querySelector(`[data-integration-id="${CSS.escape(conn.source_id)}"]`);
        if (!card) continue;
        const dot = card.querySelector('.health-dot');
        if (dot) {
            dot.className = `health-dot ${conn.connected ? 'health-online' : 'health-offline'}`;
            dot.setAttribute('title', conn.connected
                ? `${t('ha_source.connected')} — ${conn.entity_count} ${t('dashboard.integrations.entities')}`
                : t('ha_source.disconnected'));
        }
        const subtitle = card.querySelector('.dashboard-target-subtitle');
        if (subtitle) {
            subtitle.textContent = conn.connected
                ? `${conn.entity_count} ${t('dashboard.integrations.entities')}`
                : t('ha_source.disconnected');
        }
    }
    // Update MQTT integration cards
    if (mqttStatus) {
        for (const conn of mqttStatus.connections) {
            const card = document.querySelector(`[data-integration-id="${CSS.escape(conn.source_id)}"]`);
            if (!card) continue;
            const dot = card.querySelector('.health-dot');
            if (dot) {
                dot.className = `health-dot ${conn.connected ? 'health-online' : 'health-offline'}`;
                dot.setAttribute('title', conn.connected ? t('mqtt_source.connected') : t('mqtt_source.disconnected'));
            }
            const subtitle = card.querySelector('.dashboard-target-subtitle');
            if (subtitle) {
                subtitle.textContent = conn.connected ? conn.broker : t('mqtt_source.disconnected');
            }
        }
    }
    // Update section count badge
    const totalSources = haStatus.total_sources + (mqttStatus?.total_sources || 0);
    const totalConnected = haStatus.connected_count + (mqttStatus?.connected_count || 0);
    const header = document.querySelector('[data-dashboard-section="integrations"]');
    if (header) {
        const countEl = header.querySelector('.dashboard-section-count');
        if (countEl) countEl.textContent = `${totalConnected}/${totalSources}`;
    }
}

function renderDashboardSyncClock(clock: SyncClock): string {
    const toggleAction = clock.is_running
        ? `dashboardPauseClock('${clock.id}')`
        : `dashboardResumeClock('${clock.id}')`;
    const toggleTitle = clock.is_running ? t('sync_clock.action.pause') : t('sync_clock.action.resume');

    const subtitle = [
        `<span class="dashboard-clock-speed">${clock.speed}x</span>`,
        clock.description ? escapeHtml(clock.description) : '',
    ].filter(Boolean).join(' · ');

    const scStyle = cardColorStyle(clock.id);
    return `<div class="dashboard-target dashboard-autostart dashboard-card-link" data-sync-clock-id="${clock.id}" onclick="if(!event.target.closest('button')){navigateToCard('streams','sync','sync-clocks','data-id','${clock.id}')}"${scStyle ? ` style="${scStyle}"` : ''}>
        <div class="dashboard-target-info">
            <span class="dashboard-target-icon">${ICON_CLOCK}</span>
            <div>
                <div class="dashboard-target-name">${escapeHtml(clock.name)}</div>
                ${subtitle ? `<div class="dashboard-target-subtitle">${subtitle}</div>` : ''}
            </div>
        </div>
        <div class="dashboard-target-actions">
            <button class="dashboard-action-btn ${clock.is_running ? 'stop' : 'start'}" onclick="${toggleAction}" title="${toggleTitle}">
                ${clock.is_running ? ICON_PAUSE : ICON_START}
            </button>
            <button class="dashboard-action-btn" onclick="dashboardResetClock('${clock.id}')" title="${t('sync_clock.action.reset')}">
                ${ICON_CLOCK}
            </button>
        </div>
    </div>`;
}

function _renderPollIntervalSelect(): string {
    const sec = Math.round(dashboardPollInterval / 1000);
    return `<span class="dashboard-poll-wrap"><input type="range" class="dashboard-poll-slider" min="1" max="10" value="${sec}" oninput="changeDashboardPollInterval(this.value)" title="${t('dashboard.poll_interval')}"><span class="dashboard-poll-value">${sec}s</span></span>`;
}

let _pollDebounce: ReturnType<typeof setTimeout> | undefined = undefined;
export function changeDashboardPollInterval(value: string | number): void {
    const label = document.querySelector('.dashboard-poll-value');
    if (label) label.textContent = `${value}s`;
    clearTimeout(_pollDebounce);
    _pollDebounce = setTimeout(() => {
        const ms = parseInt(String(value), 10) * 1000;
        setDashboardPollInterval(ms);
        startAutoRefresh();
        stopPerfPolling();
        startPerfPolling();
    }, 300);
}

function _getCollapsedSections(): Record<string, boolean> {
    try { return JSON.parse(localStorage.getItem(DASHBOARD_COLLAPSED_KEY) ?? '{}') || {}; }
    catch { return {}; }
}

export function toggleDashboardSection(sectionKey: string): void {
    const collapsed = _getCollapsedSections();
    collapsed[sectionKey] = !collapsed[sectionKey];
    localStorage.setItem(DASHBOARD_COLLAPSED_KEY, JSON.stringify(collapsed));
    const header = document.querySelector(`[data-dashboard-section="${CSS.escape(sectionKey)}"]`);
    if (!header) return;
    const content = header.nextElementSibling;
    const chevron = header.querySelector('.dashboard-section-chevron');
    const nowCollapsed = collapsed[sectionKey];
    if (chevron) (chevron as HTMLElement).style.transform = nowCollapsed ? '' : 'rotate(90deg)';

    // Animate collapse/expand unless reduced motion
    const contentEl = content as any;
    if (window.matchMedia('(prefers-reduced-motion: reduce)').matches) {
        contentEl.style.display = nowCollapsed ? 'none' : '';
        return;
    }
    if (contentEl._dsAnim) { contentEl._dsAnim.cancel(); contentEl._dsAnim = null; }
    if (nowCollapsed) {
        const h = contentEl.offsetHeight;
        contentEl.style.overflow = 'hidden';
        const anim = contentEl.animate(
            [{ height: h + 'px', opacity: 1 }, { height: '0px', opacity: 0 }],
            { duration: 200, easing: 'ease-in-out' }
        );
        contentEl._dsAnim = anim;
        anim.onfinish = () => { contentEl.style.display = 'none'; contentEl.style.overflow = ''; contentEl._dsAnim = null; };
    } else {
        contentEl.style.display = '';
        contentEl.style.overflow = 'hidden';
        const h = contentEl.scrollHeight;
        const anim = contentEl.animate(
            [{ height: '0px', opacity: 0 }, { height: h + 'px', opacity: 1 }],
            { duration: 200, easing: 'ease-in-out' }
        );
        contentEl._dsAnim = anim;
        anim.onfinish = () => { contentEl.style.overflow = ''; contentEl._dsAnim = null; };
    }
}

function _sectionHeader(sectionKey: string, label: string, count: number | string, extraHtml: string = ''): string {
    const collapsed = _getCollapsedSections();
    const isCollapsed = !!collapsed[sectionKey];
    const chevronStyle = isCollapsed ? '' : ' style="transform:rotate(90deg)"';
    return `<div class="dashboard-section-header" data-dashboard-section="${sectionKey}">
        <span class="dashboard-section-toggle" onclick="toggleDashboardSection('${sectionKey}')">
            <span class="dashboard-section-chevron"${chevronStyle}>&#9654;</span>
            ${label}
            <span class="dashboard-section-count">${count}</span>
        </span>
        ${extraHtml}
    </div>`;
}

function _sectionContent(sectionKey: string, itemsHtml: string): string {
    const collapsed = _getCollapsedSections();
    const isCollapsed = !!collapsed[sectionKey];
    return `<div class="dashboard-section-content"${isCollapsed ? ' style="display:none"' : ''}>${itemsHtml}</div>`;
}

export async function loadDashboard(forceFullRender: boolean = false): Promise<void> {
    if (_dashboardLoading) return;
    set_dashboardLoading(true);
    const container = document.getElementById('dashboard-content');
    if (!container) { set_dashboardLoading(false); return; }
    if (!container.children.length) setTabRefreshing('dashboard-content', true);

    try {
        // Fire all requests in a single batch to avoid sequential RTTs
        const [targets, automationsResp, devicesArr, cssArr, batchStatesResp, batchMetricsResp, scenePresets, syncClocksResp, haStatusResp, mqttStatusResp] = await Promise.all([
            outputTargetsCache.fetch().catch((): any[] => []),
            fetchWithAuth('/automations').catch(() => null),
            devicesCache.fetch().catch((): any[] => []),
            colorStripSourcesCache.fetch().catch((): any[] => []),
            fetchWithAuth('/output-targets/batch/states').catch(() => null),
            fetchWithAuth('/output-targets/batch/metrics').catch(() => null),
            loadScenePresets(),
            fetchWithAuth('/sync-clocks').catch(() => null),
            fetchWithAuth('/home-assistant/status').catch(() => null),
            fetchWithAuth('/mqtt/status').catch(() => null),
        ]);

        const automationsData = automationsResp && automationsResp.ok ? await automationsResp.json() : { automations: [] };
        const automations = automationsData.automations || [];
        const devicesMap = {};
        for (const d of devicesArr) { devicesMap[d.id] = d; }
        const cssSourceMap = {};
        for (const s of (cssArr || [])) { cssSourceMap[s.id] = s; }
        const syncClocksData = syncClocksResp && syncClocksResp.ok ? await syncClocksResp.json() : { clocks: [] };
        const syncClocks = syncClocksData.clocks || [];
        const haStatus: HomeAssistantStatusResponse = haStatusResp && haStatusResp.ok
            ? await haStatusResp.json()
            : { connections: [], total_sources: 0, connected_count: 0 };
        const mqttStatus: MQTTStatusResponse = mqttStatusResp && mqttStatusResp.ok
            ? await mqttStatusResp.json()
            : { connections: [], total_sources: 0, connected_count: 0 };

        const allStates = batchStatesResp && batchStatesResp.ok ? (await batchStatesResp.json()).states : {};
        const allMetrics = batchMetricsResp && batchMetricsResp.ok ? (await batchMetricsResp.json()).metrics : {};

        // Build dynamic HTML (targets, automations)
        let dynamicHtml = '';
        let runningIds: any[] = [];
        if (targets.length === 0 && automations.length === 0 && scenePresets.length === 0 && syncClocks.length === 0 && haStatus.total_sources === 0 && mqttStatus.total_sources === 0) {
            dynamicHtml = `<div class="dashboard-no-targets">${t('dashboard.no_targets')}</div>`;
        } else {
            const enriched = targets.map(target => ({
                ...target,
                state: allStates[target.id] || {},
                metrics: allMetrics[target.id] || {},
            }));

            const running = enriched.filter(t => t.state && t.state.processing);
            const stopped = enriched.filter(t => !t.state || !t.state.processing);
            updateTabBadge('targets', running.length);

            // Check if we can do an in-place metrics update (same targets, not first load)
            const newRunningIds = running.map(t => t.id).sort().join(',');
            const prevRunningIds = [..._lastRunningIds].sort().join(',');
            const newSyncClockIds = syncClocks.map(c => `${c.id}:${c.is_running}`).sort().join(',');
            const hasExistingDom = !!container.querySelector('.dashboard-perf-persistent');
            const structureUnchanged = hasExistingDom && newRunningIds === prevRunningIds && newSyncClockIds === _lastSyncClockIds;
            if (structureUnchanged && !forceFullRender && running.length > 0) {
                _updateRunningMetrics(running);
                _updateSyncClocksInPlace(syncClocks);
                _updateIntegrationsInPlace(haStatus, mqttStatus);
                _cacheUptimeElements();
                _startUptimeTimer();
                startPerfPolling();
                set_dashboardLoading(false);
                return;
            }
            if (structureUnchanged && forceFullRender) {
                if (running.length > 0) _updateRunningMetrics(running);
                _updateAutomationsInPlace(automations);
                _updateSyncClocksInPlace(syncClocks);
                _updateIntegrationsInPlace(haStatus, mqttStatus);
                _cacheUptimeElements();
                _startUptimeTimer();
                startPerfPolling();
                set_dashboardLoading(false);
                return;
            }

            // Integrations section (HA + MQTT sources)
            const totalIntSources = haStatus.total_sources + mqttStatus.total_sources;
            const totalIntConnected = haStatus.connected_count + mqttStatus.connected_count;
            if (totalIntSources > 0) {
                const haCards = haStatus.connections.map(c => _renderIntegrationCard(c)).join('');
                const mqttCards = mqttStatus.connections.map(c => _renderMQTTIntegrationCard(c)).join('');
                const intGrid = `<div class="dashboard-integrations-grid">${haCards}${mqttCards}</div>`;
                dynamicHtml += `<div class="dashboard-section">
                    ${_sectionHeader('integrations', t('dashboard.section.integrations'), `${totalIntConnected}/${totalIntSources}`)}
                    ${_sectionContent('integrations', intGrid)}
                </div>`;
            }

            if (automations.length > 0) {
                const activeAutomations = automations.filter(a => a.is_active);
                const inactiveAutomations = automations.filter(a => !a.is_active);
                updateTabBadge('automations', activeAutomations.length);
                const sceneMap = new Map(scenePresets.map(s => [s.id, s]));
                const automationItems = [...activeAutomations, ...inactiveAutomations].map(a => renderDashboardAutomation(a, sceneMap)).join('');

                dynamicHtml += `<div class="dashboard-section">
                    ${_sectionHeader('automations', t('dashboard.section.automations'), automations.length)}
                    ${_sectionContent('automations', automationItems)}
                </div>`;
            }

            // Scene Presets section
            if (scenePresets.length > 0) {
                const sceneSec = renderScenePresetsSection(scenePresets);
                if (sceneSec && typeof sceneSec === 'object') {
                    dynamicHtml += `<div class="dashboard-section">
                        ${_sectionHeader('scenes', t('dashboard.section.scenes'), scenePresets.length, sceneSec.headerExtra)}
                        ${_sectionContent('scenes', sceneSec.content)}
                    </div>`;
                }
            }

            // Sync Clocks section
            if (syncClocks.length > 0) {
                const clockCards = syncClocks.map(c => renderDashboardSyncClock(c)).join('');
                const clockGrid = `<div class="dashboard-autostart-grid">${clockCards}</div>`;
                dynamicHtml += `<div class="dashboard-section">
                    ${_sectionHeader('sync-clocks', t('dashboard.section.sync_clocks'), syncClocks.length)}
                    ${_sectionContent('sync-clocks', clockGrid)}
                </div>`;
            }

            if (targets.length > 0) {
                let targetsInner = '';

                if (running.length > 0) {
                    runningIds = running.map(t => t.id);
                    const stopAllBtn = `<button class="btn btn-sm btn-primary dashboard-stop-all" onclick="event.stopPropagation(); dashboardStopAll()" title="${t('dashboard.stop_all')}">${ICON_STOP} ${t('dashboard.stop_all')}</button>`;
                    const runningItems = running.map(target => renderDashboardTarget(target, true, devicesMap, cssSourceMap)).join('');

                    targetsInner += `<div class="dashboard-subsection">
                        ${_sectionHeader('running', t('dashboard.section.running'), running.length, stopAllBtn)}
                        ${_sectionContent('running', runningItems)}
                    </div>`;
                }

                if (stopped.length > 0) {
                    const stoppedItems = stopped.map(target => renderDashboardTarget(target, false, devicesMap, cssSourceMap)).join('');

                    targetsInner += `<div class="dashboard-subsection">
                        ${_sectionHeader('stopped', t('dashboard.section.stopped'), stopped.length)}
                        ${_sectionContent('stopped', stoppedItems)}
                    </div>`;
                }

                dynamicHtml += `<div class="dashboard-section">
                    ${_sectionHeader('targets', t('dashboard.section.targets'), targets.length)}
                    ${_sectionContent('targets', targetsInner)}
                </div>`;
            }
        }

        // First load: build everything in one innerHTML to avoid flicker
        const isFirstLoad = !container.querySelector('.dashboard-perf-persistent');
        const pollSelect = _renderPollIntervalSelect();
        const toolbar = `<div class="stream-tab-bar"><span class="cs-expand-collapse-group">${pollSelect}<button class="tutorial-trigger-btn" onclick="startDashboardTutorial()" title="${t('tour.restart')}">${ICON_HELP}</button></span></div>`;
        if (isFirstLoad) {
            container.innerHTML = `${toolbar}<div class="dashboard-perf-persistent dashboard-section">
                ${_sectionHeader('perf', t('dashboard.section.performance'), '', renderPerfModeToggle())}
                ${_sectionContent('perf', renderPerfSection())}
            </div>
            <div class="dashboard-dynamic">${dynamicHtml}</div>`;
            await initPerfCharts();
            // Event delegation for scene preset cards (attached once, works across innerHTML refreshes)
            initScenePresetDelegation(container);
        } else {
            const dynamic = container.querySelector('.dashboard-dynamic');
            if (dynamic && dynamic.innerHTML !== dynamicHtml) {
                dynamic.innerHTML = dynamicHtml;
            }
        }
        _lastRunningIds = runningIds;
        _lastSyncClockIds = syncClocks.map(c => `${c.id}:${c.is_running}`).sort().join(',');
        _cacheUptimeElements();
        await _initFpsCharts(runningIds);
        _startUptimeTimer();
        startPerfPolling();

    } catch (error) {
        if (error.isAuth) return;
        console.error('Failed to load dashboard:', error);
        container.innerHTML = `<div class="dashboard-no-targets">${t('dashboard.failed')}</div>`;
    } finally {
        set_dashboardLoading(false);
        setTabRefreshing('dashboard-content', false);
    }
}

function renderDashboardTarget(target: any, isRunning: boolean, devicesMap: Record<string, Device> = {}, cssSourceMap: Record<string, ColorStripSource> = {}): string {
    const state = target.state || {};
    const metrics = target.metrics || {};
    const isLed = target.target_type === 'led' || target.target_type === 'wled';
    const isHALight = target.target_type === 'ha_light';
    const icon = ICON_TARGET;
    const typeLabel = isLed ? t('dashboard.type.led') : isHALight ? t('ha_light.section.title') : t('dashboard.type.kc');
    const navSubTab = isHALight ? 'ha-light-targets' : 'led-targets';
    const navSection = isHALight ? 'ha-light-targets' : 'led-targets';
    const navAttr = isHALight ? 'data-ha-target-id' : 'data-target-id';
    const navOnclick = `if(!event.target.closest('button')){navigateToCard('targets','${navSubTab}','${navSection}','${navAttr}','${target.id}')}`;

    let subtitleParts = [typeLabel];
    if (isLed || isHALight) {
        if (isLed) {
            const device = target.device_id ? devicesMap[target.device_id] : null;
            if (device) {
                subtitleParts.push((device.device_type || '').toUpperCase());
            }
        }
        const cssId = target.color_strip_source_id || '';
        if (cssId) {
            const css = cssSourceMap[cssId];
            if (css) {
                subtitleParts.push(t(`color_strip.type.${css.source_type}`) || css.source_type);
            }
        }
    }

    if (isRunning) {
        const fpsTarget = state.fps_target || (target.settings || {}).fps || target.update_rate || '-';
        const fpsCurrent = isHALight ? fpsTarget : (state.fps_current ?? 0);
        const fpsActual = isHALight ? String(fpsTarget) : (state.fps_actual != null ? state.fps_actual.toFixed(1) : '-');
        const uptime = formatUptime(metrics.uptime_seconds);
        const errors = metrics.errors_count || 0;

        // Set uptime base for interpolation
        if (metrics.uptime_seconds != null) {
            _setUptimeBase(target.id, metrics.uptime_seconds);
        }

        // Push FPS samples to history
        if (state.fps_actual != null) {
            _pushFps(target.id, state.fps_actual, fpsCurrent);
        }

        let healthDot = '';
        if (isLed && state.device_last_checked != null) {
            const cls = state.device_online ? 'health-online' : 'health-offline';
            const statusLabel = state.device_online ? t('device.health.online') : t('device.health.offline');
            healthDot = `<span class="health-dot ${cls}" role="status" aria-label="${statusLabel}"></span>`;
        }

        const cStyle = cardColorStyle(target.id);
        return `<div class="dashboard-target dashboard-card-link" data-target-id="${target.id}" onclick="${navOnclick}"${cStyle ? ` style="${cStyle}"` : ''}>
            <div class="dashboard-target-info">
                <span class="dashboard-target-icon">${icon}</span>
                <div>
                    <div class="dashboard-target-name"><span class="dashboard-target-name-text">${escapeHtml(target.name)}</span>${healthDot}</div>
                    ${subtitleParts.length ? `<div class="dashboard-target-subtitle">${escapeHtml(subtitleParts.join(' · '))}</div>` : ''}
                </div>
            </div>
            <div class="dashboard-target-metrics">
                <div class="dashboard-metric dashboard-fps-metric">
                    <div class="dashboard-fps-sparkline">
                        <canvas id="dashboard-fps-${target.id}" data-fps-target="${fpsTarget}"></canvas>
                    </div>
                    <div class="dashboard-fps-label">
                        <span class="dashboard-metric-value" data-fps-text="${target.id}">${fpsCurrent}<span class="dashboard-fps-target">/${fpsTarget}</span><span class="dashboard-fps-avg">avg ${fpsActual}</span></span>
                    </div>
                </div>
                <div class="dashboard-metric" title="${t('dashboard.uptime')}">
                    <div class="dashboard-metric-value" data-uptime-text="${target.id}">${ICON_CLOCK} ${uptime}</div>
                </div>
                <div class="dashboard-metric" title="${t('dashboard.errors')}">
                    <div class="dashboard-metric-value" data-errors-text="${target.id}" title="${errors}">${errors > 0 ? ICON_WARNING : ICON_OK} ${formatCompact(errors)}</div>
                </div>
            </div>
            <div class="dashboard-target-actions">
                <button class="dashboard-action-btn stop" onclick="dashboardStopTarget('${target.id}')" title="${t('device.button.stop')}">${ICON_STOP_PLAIN}</button>
            </div>
        </div>`;
    } else {
        const cStyle2 = cardColorStyle(target.id);
        return `<div class="dashboard-target dashboard-card-link" onclick="${navOnclick}"${cStyle2 ? ` style="${cStyle2}"` : ''}>
            <div class="dashboard-target-info">
                <span class="dashboard-target-icon">${icon}</span>
                <div>
                    <div class="dashboard-target-name">${escapeHtml(target.name)}</div>
                    ${subtitleParts.length ? `<div class="dashboard-target-subtitle">${escapeHtml(subtitleParts.join(' · '))}</div>` : ''}
                </div>
            </div>
            <div class="dashboard-target-metrics"></div>
            <div class="dashboard-target-actions">
                <button class="dashboard-action-btn start" onclick="dashboardStartTarget('${target.id}')" title="${t('device.button.start')}">${ICON_START}</button>
            </div>
        </div>`;
    }
}

function renderDashboardAutomation(automation: Automation, sceneMap: Map<string, ScenePreset> = new Map()): string {
    const isActive = automation.is_active;
    const isDisabled = !automation.enabled;

    let condSummary = '';
    if (automation.rules.length > 0) {
        const parts = automation.rules.map(r => {
            if (r.rule_type === 'application') {
                const apps = (r.apps || []).join(', ');
                const matchLabel = r.match_type === 'topmost' ? t('automations.rule.application.match_type.topmost') : t('automations.rule.application.match_type.running');
                return `${apps} (${matchLabel})`;
            }
            if (r.rule_type === 'startup') return t('automations.rule.startup');
            if (r.rule_type === 'time_of_day') return t('automations.rule.time_of_day');
            return t(`automations.rule.${r.rule_type}`) || r.rule_type;
        });
        const logic = automation.rule_logic === 'and' ? ' & ' : ' | ';
        condSummary = parts.join(logic);
    }

    const statusBadge = isDisabled
        ? `<span class="dashboard-badge-stopped">${t('automations.status.disabled')}</span>`
        : isActive
            ? `<span class="dashboard-badge-active">${t('automations.status.active')}</span>`
            : `<span class="dashboard-badge-stopped">${t('automations.status.inactive')}</span>`;

    // Scene info
    const scene = automation.scene_preset_id ? sceneMap.get(automation.scene_preset_id) : null;
    const sceneName = scene ? escapeHtml(scene.name) : t('automations.scene.none_selected');

    const aStyle = cardColorStyle(automation.id);
    return `<div class="dashboard-target dashboard-automation dashboard-card-link" data-automation-id="${automation.id}" onclick="if(!event.target.closest('button')){navigateToCard('automations',null,'automations','data-automation-id','${automation.id}')}"${aStyle ? ` style="${aStyle}"` : ''}>
        <div class="dashboard-target-info">
            <span class="dashboard-target-icon">${ICON_AUTOMATION}</span>
            <div>
                <div class="dashboard-target-name">${escapeHtml(automation.name)}</div>
                ${condSummary ? `<div class="dashboard-target-subtitle">${escapeHtml(condSummary)}</div>` : ''}
                <div class="dashboard-target-subtitle">${ICON_SCENE} ${sceneName}</div>
            </div>
            ${statusBadge}
        </div>
        <div class="dashboard-target-actions">
            <button class="dashboard-action-btn ${automation.enabled ? 'stop' : 'start'}" onclick="dashboardToggleAutomation('${automation.id}', ${!automation.enabled})" title="${automation.enabled ? t('automations.action.disable') : t('automations.status.active')}">
                ${automation.enabled ? ICON_STOP_PLAIN : ICON_START}
            </button>
        </div>
    </div>`;
}

export async function dashboardToggleAutomation(automationId: string, enable: boolean): Promise<void> {
    try {
        const endpoint = enable ? 'enable' : 'disable';
        const response = await fetchWithAuth(`/automations/${automationId}/${endpoint}`, {
            method: 'POST',
        });
        if (response.ok) {
            loadDashboard();
        }
    } catch (error) {
        if (error.isAuth) return;
        showToast(t('dashboard.error.automation_toggle_failed'), 'error');
    }
}

export async function dashboardStartTarget(targetId: string): Promise<void> {
    try {
        const response = await fetchWithAuth(`/output-targets/${targetId}/start`, {
            method: 'POST',
        });
        if (response.ok) {
            showToast(t('device.started'), 'success');
            loadDashboard();
        } else {
            const error = await response.json();
            showToast(error.detail || t('dashboard.error.start_failed'), 'error');
        }
    } catch (error) {
        if (error.isAuth) return;
        showToast(t('dashboard.error.start_failed'), 'error');
    }
}

export async function dashboardStopTarget(targetId: string): Promise<void> {
    try {
        const response = await fetchWithAuth(`/output-targets/${targetId}/stop`, {
            method: 'POST',
        });
        if (response.ok) {
            showToast(t('device.stopped'), 'success');
            loadDashboard();
        } else {
            const error = await response.json();
            showToast(error.detail || t('dashboard.error.stop_failed'), 'error');
        }
    } catch (error) {
        if (error.isAuth) return;
        showToast(t('dashboard.error.stop_failed'), 'error');
    }
}

export async function dashboardStopAll(): Promise<void> {
    const confirmed = await showConfirm(t('confirm.stop_all'));
    if (!confirmed) return;
    try {
        const [allTargets, statesResp] = await Promise.all([
            outputTargetsCache.fetch().catch((): any[] => []),
            fetchWithAuth('/output-targets/batch/states'),
        ]);
        const statesData = statesResp.ok ? await statesResp.json() : { states: {} };
        const states = statesData.states || {};
        const running = allTargets.filter(t => states[t.id]?.processing);
        await Promise.all(running.map(t =>
            fetchWithAuth(`/output-targets/${t.id}/stop`, { method: 'POST' }).catch(() => {})
        ));
        loadDashboard();
    } catch (error) {
        if (error.isAuth) return;
        showToast(t('dashboard.error.stop_all'), 'error');
    }
}

export async function dashboardPauseClock(clockId: string): Promise<void> {
    try {
        const resp = await fetchWithAuth(`/sync-clocks/${clockId}/pause`, { method: 'POST' });
        if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
        showToast(t('sync_clock.paused'), 'success');
        loadDashboard(true);
    } catch (e) {
        if (e.isAuth) return;
        showToast(e.message, 'error');
    }
}

export async function dashboardResumeClock(clockId: string): Promise<void> {
    try {
        const resp = await fetchWithAuth(`/sync-clocks/${clockId}/resume`, { method: 'POST' });
        if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
        showToast(t('sync_clock.resumed'), 'success');
        loadDashboard(true);
    } catch (e) {
        if (e.isAuth) return;
        showToast(e.message, 'error');
    }
}

export async function dashboardResetClock(clockId: string): Promise<void> {
    try {
        const resp = await fetchWithAuth(`/sync-clocks/${clockId}/reset`, { method: 'POST' });
        if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
        showToast(t('sync_clock.reset_done'), 'success');
        loadDashboard(true);
    } catch (e) {
        if (e.isAuth) return;
        showToast(e.message, 'error');
    }
}

export function stopUptimeTimer(): void {
    _stopUptimeTimer();
}

// React to global server events when dashboard tab is active
function _isDashboardActive(): boolean {
    return (localStorage.getItem('activeTab') || 'dashboard') === 'dashboard';
}

let _eventDebounceTimer: ReturnType<typeof setTimeout> | undefined = undefined;
function _debouncedDashboardReload(forceFullRender: boolean = false): void {
    if (!_isDashboardActive()) return;
    clearTimeout(_eventDebounceTimer);
    _eventDebounceTimer = setTimeout(() => loadDashboard(forceFullRender), 300);
}

document.addEventListener('server:state_change', () => _debouncedDashboardReload());
document.addEventListener('server:automation_state_changed', () => _debouncedDashboardReload(true));
document.addEventListener('server:device_health_changed', () => _debouncedDashboardReload());

const _DASHBOARD_ENTITY_TYPES = new Set(['output_target', 'automation', 'scene_preset', 'sync_clock', 'device', 'home_assistant_source']);
document.addEventListener('server:entity_changed', (e: Event) => {
    const { entity_type } = (e as CustomEvent).detail || {};
    if (_DASHBOARD_ENTITY_TYPES.has(entity_type)) _debouncedDashboardReload(true);
});

// Re-render dashboard when language changes
document.addEventListener('languageChanged', () => {
    if (!apiKey) return;
    // Force perf section rebuild with new locale
    const perfEl = document.querySelector('.dashboard-perf-persistent');
    if (perfEl) perfEl.remove();
    loadDashboard();
});

// Pause uptime timer when browser tab is hidden, resume when visible
document.addEventListener('visibilitychange', () => {
    if (document.hidden) {
        _stopUptimeTimer();
    } else if (_isDashboardActive() && _lastRunningIds.length > 0) {
        _cacheUptimeElements();
        _startUptimeTimer();
    }
});
