from __future__ import annotations

import asyncio
import os
from collections.abc import AsyncIterator
from contextlib import asynccontextmanager, suppress

from fastapi import FastAPI
from fastapi.responses import HTMLResponse
from pydantic import BaseModel, Field

from app.core.decision import DecisionEngineV2
from app.core.event_core import EventCore
from app.core.ha_client import FutureHaClient, HaClientConfig, service_for_state
from app.core.handoff import HandoffMatrix
from app.core.models import (
    AuditEvent,
    BackupBundle,
    BehaviorPatternV2,
    ControlProfile,
    ControlState,
    EntityState,
    HandoffMode,
    LearningProfile,
    LearningState,
    RuntimeState,
    SafetyStage,
    StateEvent,
)
from app.core.stores import FutureStores

stores = FutureStores(os.getenv("SILLYHOME_FUTURE_STORE", ".future_store"))
event_core = EventCore(stores)
handoff = HandoffMatrix()
ha_client: FutureHaClient | None = None


class ControlStageUpdate(BaseModel):
    stage: SafetyStage
    min_confidence: float = Field(default=0.82, ge=0.0, le=1.0)
    manual_block: bool = False
    cooldown_seconds: int = Field(default=900, ge=0)


class PatternCreateRequest(BaseModel):
    trigger_entity_id: str
    trigger_state: str | None = None
    target_state: str
    confidence: float = Field(default=0.9, ge=0.0, le=1.0)
    support: int = Field(default=3, ge=1)
    source: str = Field(default="dashboard", max_length=40)


class GlobalControlUpdate(BaseModel):
    enabled: bool


class SimulationRequest(BaseModel):
    actuator_entity_id: str
    trigger_entity_id: str
    trigger_state: str | None = None


class ActiveReadiness(BaseModel):
    actuator_entity_id: str
    ready: bool
    reason: str
    dry_run_events: int
    dry_run_successes: int
    dry_run_failures: int


@asynccontextmanager
async def lifespan(app: FastAPI) -> AsyncIterator[None]:
    global ha_client
    listener_task: asyncio.Task[None] | None = None
    ha_client = _ha_client_from_env()
    if ha_client is not None:
        _load_initial_ha_states(ha_client)
        listener_task = asyncio.create_task(_ha_listener_loop(ha_client))
    try:
        yield
    finally:
        if listener_task is not None:
            listener_task.cancel()
            with suppress(asyncio.CancelledError):
                await listener_task


app = FastAPI(
    title="SillyHome Future API",
    description="SillyHome v2 event-core side project.",
    version="2.0.0-alpha.9",
    lifespan=lifespan,
)


@app.get("/health")
def health() -> dict[str, str]:
    runtime = stores.runtime()
    return {
        "status": "ok",
        "version": app.version,
        "ha": runtime.websocket_status,
    }


@app.get("/v2/health")
def detailed_health() -> dict[str, object]:
    runtime = stores.runtime()
    control = stores.control()
    return {
        "api": "ok",
        "version": app.version,
        "websocket": runtime.websocket_status,
        "store": "ok",
        "global_enabled": control.global_enabled,
        "entities": len(runtime.entities),
        "audit_events": len(runtime.audit),
    }


@app.get("/", response_class=HTMLResponse)
def dashboard() -> str:
    return _dashboard_html()


@app.get("/v2/dashboard")
def dashboard_data() -> dict[str, object]:
    runtime = stores.runtime()
    learning = stores.learning()
    control = stores.control()
    latest_audit = runtime.audit[-20:]
    actuator_entities = [
        entity
        for entity in runtime.entities.values()
        if entity.domain in {"light", "switch", "fan", "cover", "humidifier"}
    ]
    return {
        "websocket_status": runtime.websocket_status,
        "entity_count": len(runtime.entities),
        "actuator_count": len(actuator_entities),
        "global_enabled": control.global_enabled,
        "learning_profiles": len(learning.profiles),
        "control_profiles": len(control.profiles),
        "rooms": list(learning.rooms.values()),
        "scenes": list(learning.scenes.values()),
        "audit": latest_audit,
    }


@app.post("/v2/events/state", response_model=list[AuditEvent])
def ingest_state_event(event: StateEvent) -> list[AuditEvent]:
    return event_core.process_state_event(event, execute=_execute_ha_decision)


@app.get("/v2/runtime", response_model=RuntimeState)
def get_runtime() -> RuntimeState:
    return stores.runtime()


@app.get("/v2/entities", response_model=list[EntityState])
def list_entities(domain: str | None = None, q: str | None = None) -> list[EntityState]:
    entities = list(stores.runtime().entities.values())
    if domain:
        wanted = {item.strip() for item in domain.split(",") if item.strip()}
        entities = [entity for entity in entities if entity.domain in wanted]
    if q:
        needle = q.casefold()
        entities = [
            entity
            for entity in entities
            if needle in entity.entity_id.casefold()
            or (entity.friendly_name is not None and needle in entity.friendly_name.casefold())
        ]
    return sorted(entities, key=lambda entity: entity.entity_id)[:500]


@app.get("/v2/entities/groups")
def entity_groups() -> dict[str, list[EntityState]]:
    grouped: dict[str, list[EntityState]] = {}
    for entity in stores.runtime().entities.values():
        key = entity.area_name or entity.domain
        grouped.setdefault(key, []).append(entity)
    return {
        key: sorted(values, key=lambda entity: entity.entity_id)[:250]
        for key, values in sorted(grouped.items())
    }


@app.get("/v2/learning", response_model=LearningState)
def get_learning() -> LearningState:
    return stores.learning()


@app.put("/v2/learning", response_model=LearningState)
def put_learning(state: LearningState) -> LearningState:
    return stores.save_learning(state)


@app.get("/v2/control", response_model=ControlState)
def get_control() -> ControlState:
    return stores.control()


@app.post("/v2/control/global", response_model=ControlState)
def set_global_control(update: GlobalControlUpdate) -> ControlState:
    state = stores.control().model_copy(update={"global_enabled": update.enabled})
    stores.save_control(state)
    _append_audit(
        "safety",
        None,
        "Globaler Not-Aus deaktiviert." if update.enabled else "Globaler Not-Aus aktiviert.",
    )
    return state


@app.put("/v2/control/{actuator_entity_id}", response_model=ControlProfile)
def put_control(actuator_entity_id: str, profile: ControlProfile) -> ControlProfile:
    state = stores.control()
    state.profiles[actuator_entity_id] = profile
    stores.save_control(state)
    return profile


@app.post("/v2/control/{actuator_entity_id}/stage", response_model=ControlProfile)
def update_control_stage(
    actuator_entity_id: str,
    update: ControlStageUpdate,
) -> ControlProfile:
    state = stores.control()
    profile = state.profiles.get(
        actuator_entity_id,
        ControlProfile(actuator_entity_id=actuator_entity_id),
    )
    requested_stage = update.stage
    if requested_stage is SafetyStage.ACTIVE and not profile.active_ready:
        requested_stage = SafetyStage.DRY_RUN
    updated = profile.model_copy(
        update={
            "stage": requested_stage,
            "min_confidence": update.min_confidence,
            "manual_block": update.manual_block,
            "cooldown_seconds": update.cooldown_seconds,
            "handoff_mode": handoff.classify(profile),
        }
    )
    state.profiles[actuator_entity_id] = updated
    stores.save_control(state)
    _append_audit(
        "safety",
        actuator_entity_id,
        f"Stage gesetzt auf {updated.stage}."
        if updated.stage == update.stage
        else f"Active blockiert: {updated.active_readiness_reason}",
    )
    return updated


@app.get("/v2/control/{actuator_entity_id}/readiness", response_model=ActiveReadiness)
def active_readiness(actuator_entity_id: str) -> ActiveReadiness:
    profile = stores.control().profiles.get(
        actuator_entity_id,
        ControlProfile(actuator_entity_id=actuator_entity_id),
    )
    return ActiveReadiness(
        actuator_entity_id=actuator_entity_id,
        ready=profile.active_ready,
        reason=profile.active_readiness_reason,
        dry_run_events=profile.dry_run_events,
        dry_run_successes=profile.dry_run_successes,
        dry_run_failures=profile.dry_run_failures,
    )


@app.post("/v2/learning/{actuator_entity_id}/patterns", response_model=LearningProfile)
def create_learning_pattern(
    actuator_entity_id: str,
    pattern: PatternCreateRequest,
) -> LearningProfile:
    state = stores.learning()
    profile = state.profiles.get(
        actuator_entity_id,
        LearningProfile(actuator_entity_id=actuator_entity_id),
    )
    updated = profile.model_copy(
        update={
            "patterns": [
                *profile.patterns,
                BehaviorPatternV2(
                    actuator_entity_id=actuator_entity_id,
                    target_state=pattern.target_state,
                    trigger_entity_id=pattern.trigger_entity_id,
                    trigger_state=pattern.trigger_state,
                    support=pattern.support,
                    confidence=pattern.confidence,
                    source=pattern.source,
                ),
            ],
            "model_version": "dashboard-v1",
        }
    )
    state.profiles[actuator_entity_id] = updated
    stores.save_learning(state)
    return updated


@app.post("/v2/simulate")
def simulate_decision(request: SimulationRequest) -> dict[str, object]:
    runtime = stores.runtime()
    learning = stores.learning()
    control = stores.control()
    runtime.entities[request.trigger_entity_id] = EntityState(
        entity_id=request.trigger_entity_id,
        domain=request.trigger_entity_id.split(".", 1)[0],
        state=request.trigger_state,
    )
    profile = learning.profiles.get(
        request.actuator_entity_id,
        LearningProfile(actuator_entity_id=request.actuator_entity_id),
    )
    control_profile = control.profiles.get(
        request.actuator_entity_id,
        ControlProfile(actuator_entity_id=request.actuator_entity_id),
    )
    decision = DecisionEngineV2().decide(
        actuator_entity_id=request.actuator_entity_id,
        trigger_entity_id=request.trigger_entity_id,
        runtime=runtime,
        learning=profile,
        control=control_profile,
    )
    service = service_for_state(
        request.actuator_entity_id.split(".", 1)[0],
        decision.target_state,
    )
    return {
        "decision": decision,
        "would_call_service": service is not None and decision.allowed and not decision.dry_run,
        "service": service,
    }


@app.get("/v2/audit/{actuator_entity_id}", response_model=list[AuditEvent])
def actuator_audit(actuator_entity_id: str) -> list[AuditEvent]:
    return [
        item
        for item in stores.runtime().audit
        if item.entity_id == actuator_entity_id or (
            item.decision is not None and item.decision.actuator_entity_id == actuator_entity_id
        )
    ][-50:]


@app.post("/v2/handoff/{actuator_entity_id}/assume", response_model=ControlProfile)
def assume_control(actuator_entity_id: str) -> ControlProfile:
    state = stores.control()
    profile = state.profiles.get(
        actuator_entity_id,
        ControlProfile(actuator_entity_id=actuator_entity_id),
    )
    updated = handoff.assume_control(profile)
    state.profiles[actuator_entity_id] = updated
    stores.save_control(state)
    return updated


@app.post("/v2/handoff/{actuator_entity_id}/rollback", response_model=ControlProfile)
def rollback_control(actuator_entity_id: str) -> ControlProfile:
    state = stores.control()
    profile = state.profiles.get(
        actuator_entity_id,
        ControlProfile(actuator_entity_id=actuator_entity_id),
    )
    updated = handoff.rollback(profile)
    state.profiles[actuator_entity_id] = updated
    stores.save_control(state)
    return updated


@app.get("/v2/handoff/{actuator_entity_id}", response_model=HandoffMode)
def classify_handoff(actuator_entity_id: str) -> HandoffMode:
    profile = stores.control().profiles.get(
        actuator_entity_id,
        ControlProfile(actuator_entity_id=actuator_entity_id),
    )
    return handoff.classify(profile)


@app.get("/v2/backup/export", response_model=BackupBundle)
def export_backup() -> BackupBundle:
    return stores.export_backup()


@app.post("/v2/backup/restore")
def restore_backup(bundle: BackupBundle) -> dict[str, str]:
    stores.restore_backup(bundle)
    return {"status": "restored"}


def _ha_client_from_env() -> FutureHaClient | None:
    token = os.getenv("SUPERVISOR_TOKEN") or os.getenv("SILLYHOME_FUTURE_HA_TOKEN")
    if not token:
        return None
    core_url = os.getenv("SILLYHOME_FUTURE_HA_CORE_URL", "http://supervisor/core")
    websocket_url = os.getenv("SILLYHOME_FUTURE_HA_WS_URL")
    return FutureHaClient(
        HaClientConfig(core_url=core_url, token=token, websocket_url=websocket_url)
    )


def _load_initial_ha_states(client: FutureHaClient) -> None:
    runtime = stores.runtime()
    try:
        for entity in client.read_states():
            runtime.entities[entity.entity_id] = entity
        runtime.websocket_status = "initial_state_loaded"
    except Exception as exc:
        runtime.websocket_status = f"initial_state_error: {exc}"
    stores.save_runtime(runtime)


async def _ha_listener_loop(client: FutureHaClient) -> None:
    routed_triggers: set[str] = set()
    next_route_refresh = 0.0
    pending_unrouted: list[StateEvent] = []
    last_unrouted_flush = 0.0
    while True:
        await asyncio.to_thread(_set_websocket_status, "connecting")
        try:
            async for event in client.listen_state_events():
                loop_time = asyncio.get_running_loop().time()
                if loop_time >= next_route_refresh:
                    routed_triggers = await asyncio.to_thread(_routed_trigger_ids)
                    next_route_refresh = loop_time + 5
                await asyncio.to_thread(_set_websocket_status, "connected")
                if event.entity_id in routed_triggers:
                    if pending_unrouted:
                        await asyncio.to_thread(_merge_unrouted_events, pending_unrouted)
                        pending_unrouted = []
                    await asyncio.to_thread(
                        event_core.process_state_event,
                        event,
                        execute=_execute_ha_decision,
                    )
                else:
                    pending_unrouted.append(event)
                    if len(pending_unrouted) >= 100 or loop_time - last_unrouted_flush >= 2:
                        await asyncio.to_thread(_merge_unrouted_events, pending_unrouted)
                        pending_unrouted = []
                        last_unrouted_flush = loop_time
                await asyncio.sleep(0)
        except asyncio.CancelledError:
            raise
        except Exception as exc:
            await asyncio.to_thread(_set_websocket_status, f"reconnecting: {exc}")
            await asyncio.sleep(2)


def _set_websocket_status(status: str) -> None:
    runtime = stores.runtime()
    if runtime.websocket_status == status:
        return
    runtime.websocket_status = status
    stores.save_runtime(runtime)


def _routed_trigger_ids() -> set[str]:
    result: set[str] = set()
    for profile in stores.learning().profiles.values():
        for pattern in profile.patterns:
            if pattern.trigger_entity_id is not None:
                result.add(pattern.trigger_entity_id)
    return result


def _merge_unrouted_events(events: list[StateEvent]) -> None:
    if not events:
        return
    runtime = stores.runtime()
    for event in events:
        runtime.entities[event.entity_id] = EntityState(
            entity_id=event.entity_id,
            domain=event.entity_id.split(".", 1)[0],
            state=event.new_state,
            changed_at=event.changed_at,
            area_name=event.attributes.get("area_name"),
            device_id=event.attributes.get("device_id"),
            friendly_name=event.attributes.get("friendly_name"),
        )
    stores.save_runtime(runtime)


def _append_audit(kind: str, entity_id: str | None, message: str) -> None:
    runtime = stores.runtime()
    event = AuditEvent(
        event_id=f"{kind}-{len(runtime.audit) + 1}",
        kind=kind,
        entity_id=entity_id,
        message=message,
    )
    runtime.audit = [*runtime.audit, event][-200:]
    stores.save_runtime(runtime)


def _execute_ha_decision(decision: object) -> bool:
    if ha_client is None or not hasattr(decision, "actuator_entity_id"):
        return False
    actuator_entity_id = str(decision.actuator_entity_id)
    target_state = getattr(decision, "target_state", None)
    service = service_for_state(actuator_entity_id.split(".", 1)[0], target_state)
    if service is None:
        return False
    domain, service_name = service
    ha_client.call_service(domain, service_name, {"entity_id": actuator_entity_id})
    return True


def _dashboard_html() -> str:
    return """<!doctype html>
<html lang="de">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>SillyHome Future</title>
  <style>
    :root { color-scheme: dark; --bg: #101418; --panel: #171d23; --line: #2c3640; --text: #eef3f6; --muted: #9fb0bd; --accent: #42d392; --warn: #f3c969; }
    * { box-sizing: border-box; }
    body { font-family: system-ui, sans-serif; margin: 0; background: var(--bg); color: var(--text); }
    main { max-width: 1180px; margin: 0 auto; padding: 20px; }
    h1 { font-size: 28px; margin: 0 0 18px; }
    h2 { font-size: 18px; margin: 24px 0 10px; }
    .grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(170px, 1fr)); gap: 12px; }
    .split { display: grid; grid-template-columns: minmax(260px, 1fr) minmax(320px, 1.2fr); gap: 14px; align-items: start; }
    .card { border: 1px solid var(--line); border-radius: 8px; padding: 14px; background: var(--panel); }
    .label { color: #9fb0bd; font-size: 13px; }
    .value { font-size: 24px; margin-top: 4px; }
    label { display: block; color: var(--muted); font-size: 13px; margin: 10px 0 5px; }
    input, select, button { width: 100%; border: 1px solid var(--line); border-radius: 7px; background: #0c1014; color: var(--text); font: inherit; padding: 10px; }
    button { cursor: pointer; background: #20303a; }
    button:hover { border-color: var(--accent); }
    .row { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 10px; }
    .stages { display: grid; grid-template-columns: repeat(4, 1fr); gap: 8px; margin-top: 8px; }
    .stages button.active { border-color: var(--accent); color: var(--accent); }
    .primary { background: #17402c; border-color: #256f4a; }
    .status { min-height: 24px; color: var(--warn); margin-top: 10px; }
    pre { max-height: 360px; overflow: auto; white-space: pre-wrap; word-break: break-word; background: #0c1014; padding: 14px; border-radius: 8px; }
    @media (max-width: 800px) { .split, .row, .stages { grid-template-columns: 1fr; } }
  </style>
</head>
<body>
  <main>
    <h1>SillyHome Future</h1>
    <section class="grid" id="metrics"></section>
    <section class="split">
      <div class="card">
        <h2>Control</h2>
        <label for="entitySearch">Suche</label>
        <input id="entitySearch" placeholder="light., switch., sensor..." autocomplete="off">
        <label for="actuator">Aktor</label>
        <select id="actuator"></select>
        <div class="row">
          <div>
            <label for="minConfidence">Min. Confidence</label>
            <input id="minConfidence" type="number" min="0" max="1" step="0.01" value="0.82">
          </div>
          <div>
            <label for="cooldown">Cooldown Sekunden</label>
            <input id="cooldown" type="number" min="0" step="30" value="900">
          </div>
        </div>
        <label><input id="manualBlock" type="checkbox" style="width:auto;margin-right:6px"> Manuell blockieren</label>
        <div class="stages" id="stages"></div>
        <button class="primary" id="saveControl">Control speichern</button>
        <button id="globalToggle">Globaler Not-Aus</button>
        <div class="status" id="readiness">Ready-Status wird geladen...</div>
        <div class="status" id="controlStatus"></div>
      </div>
      <div class="card">
        <h2>Learning Pattern</h2>
        <div class="row">
          <div>
            <label for="trigger">Trigger</label>
            <select id="trigger"></select>
          </div>
          <div>
            <label for="triggerState">Trigger State</label>
            <input id="triggerState" placeholder="on, off, open...">
          </div>
        </div>
        <div class="row">
          <div>
            <label for="targetState">Zielzustand</label>
            <input id="targetState" value="on">
          </div>
          <div>
            <label for="patternConfidence">Confidence</label>
            <input id="patternConfidence" type="number" min="0" max="1" step="0.01" value="0.9">
          </div>
        </div>
        <button class="primary" id="addPattern">Pattern anlegen</button>
        <button id="simulatePattern">Pattern simulieren</button>
        <div class="status" id="patternStatus"></div>
        <h2>Aktuelles Profil</h2>
        <pre id="profile">Lade...</pre>
      </div>
    </section>
    <h2>Audit</h2>
    <pre id="audit">Lade...</pre>
  </main>
  <script>
    const stages = ['observe', 'dry_run', 'active', 'blocked'];
    const state = { entities: [], control: {}, learning: {}, selectedStage: 'observe' };

    function optionText(entity) {
      const name = entity.friendly_name ? ` - ${entity.friendly_name}` : '';
      const current = entity.state == null ? '' : ` (${entity.state})`;
      return `${entity.entity_id}${current}${name}`;
    }

    function setStatus(id, text) {
      document.getElementById(id).textContent = text;
      if (text) setTimeout(() => document.getElementById(id).textContent = '', 4000);
    }

    function renderStages() {
      document.getElementById('stages').innerHTML = stages.map(stage =>
        `<button type="button" data-stage="${stage}" class="${stage === state.selectedStage ? 'active' : ''}">${stage}</button>`
      ).join('');
      document.querySelectorAll('[data-stage]').forEach(button => {
        button.onclick = () => { state.selectedStage = button.dataset.stage; renderStages(); };
      });
    }

    function renderEntities() {
      const actuator = document.getElementById('actuator');
      const trigger = document.getElementById('trigger');
      const query = document.getElementById('entitySearch').value.toLowerCase();
      const shown = state.entities.filter(entity =>
        !query || optionText(entity).toLowerCase().includes(query)
      );
      const actuators = shown.filter(entity => ['light', 'switch', 'fan', 'cover', 'humidifier'].includes(entity.domain));
      actuator.innerHTML = actuators.map(entity => `<option value="${entity.entity_id}">${optionText(entity)}</option>`).join('');
      trigger.innerHTML = shown.map(entity => `<option value="${entity.entity_id}">${optionText(entity)}</option>`).join('');
      renderProfile();
    }

    function renderProfile() {
      const id = document.getElementById('actuator').value;
      const profile = {
        control: state.control.profiles?.[id] || null,
        learning: state.learning.profiles?.[id] || null,
      };
      if (profile.control) {
        state.selectedStage = profile.control.stage;
        document.getElementById('minConfidence').value = profile.control.min_confidence;
        document.getElementById('cooldown').value = profile.control.cooldown_seconds;
        document.getElementById('manualBlock').checked = profile.control.manual_block;
        renderStages();
      }
      document.getElementById('profile').textContent = JSON.stringify(profile, null, 2);
    }

    async function loadDashboard() {
      const [dashResponse, entitiesResponse, controlResponse, learningResponse] = await Promise.all([
        fetch('/v2/dashboard'),
        fetch('/v2/entities?domain=light,switch,fan,cover,humidifier,binary_sensor,sensor'),
        fetch('/v2/control'),
        fetch('/v2/learning'),
      ]);
      const data = await dashResponse.json();
      state.entities = await entitiesResponse.json();
      state.control = await controlResponse.json();
      state.learning = await learningResponse.json();
      const metrics = [
        ['WebSocket', data.websocket_status],
        ['Entities', data.entity_count],
        ['Actuators', data.actuator_count],
        ['Global', data.global_enabled ? 'on' : 'off'],
        ['Learning', data.learning_profiles],
        ['Control', data.control_profiles],
        ['Rooms', data.rooms.length],
        ['Scenes', data.scenes.length],
      ];
      document.getElementById('metrics').innerHTML = metrics.map(([label, value]) =>
        `<div class="card"><div class="label">${label}</div><div class="value">${value}</div></div>`
      ).join('');
      renderEntities();
      await loadReadiness();
      document.getElementById('audit').textContent = JSON.stringify(data.audit, null, 2);
    }

    async function loadReadiness() {
      const id = document.getElementById('actuator').value;
      if (!id) return;
      const response = await fetch(`/v2/control/${encodeURIComponent(id)}/readiness`);
      const data = await response.json();
      document.getElementById('readiness').textContent =
        `${data.ready ? 'ready for active' : 'nicht active-ready'} - ${data.reason}`;
    }

    document.getElementById('entitySearch').oninput = renderEntities;
    document.getElementById('actuator').onchange = () => { renderProfile(); loadReadiness(); };
    document.getElementById('saveControl').onclick = async () => {
      const id = document.getElementById('actuator').value;
      const response = await fetch(`/v2/control/${encodeURIComponent(id)}/stage`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          stage: state.selectedStage,
          min_confidence: Number(document.getElementById('minConfidence').value),
          manual_block: document.getElementById('manualBlock').checked,
          cooldown_seconds: Number(document.getElementById('cooldown').value),
        }),
      });
      if (!response.ok) throw new Error(await response.text());
      setStatus('controlStatus', 'Gespeichert');
      await loadDashboard();
      await loadReadiness();
    };
    document.getElementById('addPattern').onclick = async () => {
      const id = document.getElementById('actuator').value;
      const response = await fetch(`/v2/learning/${encodeURIComponent(id)}/patterns`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          trigger_entity_id: document.getElementById('trigger').value,
          trigger_state: document.getElementById('triggerState').value || null,
          target_state: document.getElementById('targetState').value,
          confidence: Number(document.getElementById('patternConfidence').value),
        }),
      });
      if (!response.ok) throw new Error(await response.text());
      setStatus('patternStatus', 'Pattern angelegt');
      await loadDashboard();
    };
    document.getElementById('simulatePattern').onclick = async () => {
      const id = document.getElementById('actuator').value;
      const response = await fetch('/v2/simulate', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          actuator_entity_id: id,
          trigger_entity_id: document.getElementById('trigger').value,
          trigger_state: document.getElementById('triggerState').value || null,
        }),
      });
      document.getElementById('profile').textContent = JSON.stringify(await response.json(), null, 2);
    };
    document.getElementById('globalToggle').onclick = async () => {
      const dash = await (await fetch('/v2/dashboard')).json();
      await fetch('/v2/control/global', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ enabled: !dash.global_enabled }),
      });
      await loadDashboard();
    };
    renderStages();
    loadDashboard();
    setInterval(loadDashboard, 5000);
  </script>
</body>
</html>"""