#!/usr/bin/env python3
"""Native Linux AI Cockpit: JSON state renderer + event writer."""

from __future__ import annotations

import sys
from typing import Any

import gi

from state_store import StateStore

gi.require_version("Adw", "1")
gi.require_version("Gtk", "4.0")
from gi.repository import Adw, Gio, Gtk, Pango  # noqa: E402


APP_ID = "dev.sidecarcommando.AICockpit"

SIDECAR_ICONS = {
    "focus": "system-run-symbolic",
    "scope": "media-playlist-shuffle-symbolic",
    "finish": "emblem-ok-symbolic",
    "reality": "edit-find-symbolic",
    "regulation": "preferences-system-symbolic",
}


CSS = """
window {
  background: #030b13;
  color: #f3f7ff;
}

.app-shell {
  background: radial-gradient(circle at 72% 0%, rgba(74, 42, 120, 0.16), transparent 34%),
              linear-gradient(135deg, #030912, #081522 46%, #06101a);
}

.sidebar {
  padding: 22px 14px 16px 14px;
  background: rgba(4, 13, 22, 0.94);
  border-right: 1px solid rgba(144, 166, 196, 0.18);
}

.main {
  padding: 18px 22px 18px 22px;
}

.brand-title {
  font-size: 23px;
  font-weight: 800;
}

.brand-subtitle,
.muted {
  color: #a7b2c3;
}

.nav-item {
  padding: 12px 14px;
  border-radius: 8px;
  color: #aab6c8;
}

.nav-item-active {
  color: #bd8cff;
  background: rgba(108, 72, 170, 0.17);
  border-left: 2px solid #8e5aff;
}

.nav-icon,
.work-icon {
  color: #9aa9bd;
}

.sidebar-focus {
  padding: 14px;
  border-radius: 8px;
  background: rgba(11, 24, 39, 0.82);
  border: 1px solid rgba(144, 166, 196, 0.16);
}

.sidebar-focus-dot {
  color: #59e17b;
}

.sidebar-focus-name {
  font-weight: 800;
  color: #f3f7ff;
}

.focus-panel,
.lead-card,
.sidecar-card,
.next-step,
.work-panel,
.work-section,
.code-panel {
  border: 1px solid rgba(144, 166, 196, 0.24);
  border-radius: 8px;
  background: rgba(13, 25, 40, 0.92);
  box-shadow: 0 12px 32px rgba(0, 0, 0, 0.24);
}

.focus-panel {
  padding: 18px 20px;
}

.focus-target {
  border-left: 1px solid rgba(144, 166, 196, 0.18);
  padding-left: 22px;
}

.work-panel {
  padding: 14px;
}

.eyebrow {
  color: #9b6dff;
  font-weight: 800;
  font-size: 12px;
  letter-spacing: 0.06em;
}

.focus-subtitle {
  color: #d4dbea;
  font-size: 17px;
}

.focus-goal {
  color: #59e17b;
  font-size: 13px;
  font-weight: 800;
}

.focus-action-button,
.owner-button {
  padding: 8px 12px;
  border-radius: 7px;
  background: rgba(36, 50, 68, 0.74);
  border: 1px solid rgba(144, 166, 196, 0.22);
}

.section-title {
  font-size: 14px;
  font-weight: 800;
  color: #9b6dff;
}

.field-label {
  color: #9aa9bd;
  font-size: 12px;
  font-weight: 700;
}

entry,
textview {
  color: #edf4ff;
  background: #0b1725;
  border: 1px solid rgba(144, 166, 196, 0.22);
  border-radius: 8px;
}

.focus-entry {
  color: #f3f7ff;
  background: transparent;
  border: 0;
  box-shadow: none;
  padding: 0;
  font-size: 30px;
  font-weight: 800;
}

.code-panel {
  background: rgba(7, 17, 29, 0.96);
}

.code-header {
  padding: 10px 12px;
  border-bottom: 1px solid rgba(144, 166, 196, 0.18);
}

.code-text {
  font-family: monospace;
  color: #cdd8e7;
  padding: 12px;
  font-size: 14px;
}

.work-section {
  padding: 12px;
}

.todo-row {
  color: #d7e0ee;
}

.todo-done {
  color: #59e17b;
}

.action-grid {
  margin-top: 2px;
}

.work-footer {
  color: #8f9cad;
  font-size: 12px;
}

.lead-card {
  padding: 22px 20px;
  border-color: #9b6dff;
  background: linear-gradient(135deg, rgba(44, 22, 79, 0.84), rgba(11, 21, 35, 0.96));
}

.lead-title {
  font-size: 26px;
  font-weight: 800;
}

.lead-copy {
  font-size: 16px;
  line-height: 1.55;
}

.sidecar-card {
  padding: 18px;
  min-height: 194px;
}

.sidecar-title {
  font-size: 19px;
  font-weight: 800;
}

.sidecar-copy {
  color: #d8e1ee;
  font-size: 14px;
  line-height: 1.45;
}

.badge {
  border-radius: 7px;
  padding: 5px 10px;
  font-size: 12px;
  font-weight: 800;
}

.badge-hard {
  color: #bd8cff;
  border: 1px solid #8e5aff;
  background: rgba(98, 57, 160, 0.18);
}

.badge-medium {
  color: #59e17b;
  border: 1px solid #2bb457;
  background: rgba(43, 180, 87, 0.14);
}

.badge-low {
  color: #4da9ff;
  border: 1px solid #2580d7;
  background: rgba(37, 128, 215, 0.13);
}

.sidecar-icon {
  min-width: 48px;
  min-height: 48px;
  border-radius: 999px;
  border: 1px solid currentColor;
  background: rgba(255, 255, 255, 0.04);
}

.lead-card .sidecar-icon {
  min-width: 58px;
  min-height: 58px;
}

.sidecar-focus {
  color: #bd8cff;
  border-color: #9b6dff;
}

.sidecar-scope {
  color: #59e17b;
  border-color: #2bb457;
  background: linear-gradient(135deg, rgba(20, 71, 50, 0.48), rgba(11, 24, 32, 0.95));
}

.sidecar-finish {
  color: #f4d044;
  border-color: #d5b900;
  background: linear-gradient(135deg, rgba(82, 68, 13, 0.38), rgba(16, 25, 27, 0.95));
}

.sidecar-reality {
  color: #4da9ff;
  border-color: #2580d7;
  background: linear-gradient(135deg, rgba(18, 57, 92, 0.42), rgba(10, 22, 34, 0.95));
}

.sidecar-regulation {
  color: #ff8a25;
  border-color: #e56f00;
  background: linear-gradient(135deg, rgba(87, 42, 8, 0.36), rgba(19, 22, 24, 0.95));
}

.next-step {
  padding: 16px 20px;
  border-color: #2387d6;
  background: rgba(9, 35, 58, 0.92);
}

.next-label {
  color: #4da9ff;
  font-size: 13px;
  font-weight: 800;
}

.next-copy {
  font-size: 18px;
  font-weight: 650;
}

.hint {
  color: #8793a4;
  font-size: 12px;
}
"""


def text(value: Any, fallback: str = "") -> str:
    return value if isinstance(value, str) else fallback


def set_text_view(view: Gtk.TextView, value: str) -> None:
    view.get_buffer().set_text(value)


def focus_name(state: dict[str, Any]) -> str:
    return text(state.get("active_focus", {}).get("name"), "miniZentrale")


class SidecarCard(Gtk.Box):
    def __init__(self, sidecar: dict[str, Any], lead: bool = False) -> None:
        super().__init__(orientation=Gtk.Orientation.VERTICAL, spacing=12)
        self.sidecar = sidecar
        self.lead = lead

        sidecar_id = text(sidecar.get("id"), "unknown")
        tone = text(sidecar.get("tone"), "LOW")

        self.add_css_class("lead-card" if lead else "sidecar-card")
        self.add_css_class(f"sidecar-{sidecar_id}")
        if not lead:
            self.set_hexpand(True)
            self.set_vexpand(True)

        header = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=12)
        header.set_valign(Gtk.Align.START)
        self.append(header)

        icon = Gtk.Box()
        icon.set_size_request(58 if lead else 48, 58 if lead else 48)
        icon.set_halign(Gtk.Align.START)
        icon.set_valign(Gtk.Align.START)
        icon.add_css_class("sidecar-icon")
        icon_image = Gtk.Image.new_from_icon_name(SIDECAR_ICONS.get(sidecar_id, "dialog-information-symbolic"))
        icon_image.set_pixel_size(30 if lead else 24)
        icon_image.set_halign(Gtk.Align.CENTER)
        icon_image.set_valign(Gtk.Align.CENTER)
        icon.append(icon_image)
        header.append(icon)

        title_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=2)
        title_box.set_hexpand(True)
        header.append(title_box)

        if lead:
            eyebrow = Gtk.Label(label="LEAD SIDECAR")
            eyebrow.set_xalign(0)
            eyebrow.add_css_class("eyebrow")
            title_box.append(eyebrow)

        title = Gtk.Label(label=text(sidecar.get("title"), "Sidecar"))
        title.set_xalign(0)
        title.set_wrap(True)
        title.add_css_class("lead-title" if lead else "sidecar-title")
        title_box.append(title)

        badge = Gtk.Label(label=tone)
        badge.add_css_class("badge")
        badge.add_css_class(f"badge-{tone.lower()}")
        header.append(badge)

        self.copy = Gtk.Label()
        self.copy.set_xalign(0)
        self.copy.set_valign(Gtk.Align.START)
        self.copy.set_wrap(True)
        self.copy.set_wrap_mode(Pango.WrapMode.WORD_CHAR)
        self.copy.add_css_class("lead-copy" if lead else "sidecar-copy")
        self.append(self.copy)

    def update(self, sentences: list[str]) -> None:
        self.copy.set_label("\n".join(sentences[:3]))


class CockpitWindow(Adw.ApplicationWindow):
    def __init__(self, app: Adw.Application) -> None:
        super().__init__(application=app, title="AI Cockpit")
        self.set_default_size(1120, 760)

        self.store = StateStore()
        self.state = self.store.load_state()

        self.focus_entry = Gtk.Entry()
        self.focus_entry.set_has_frame(False)
        self.focus_entry.set_hexpand(True)
        self.focus_entry.set_editable(False)
        self.focus_entry.add_css_class("focus-entry")

        self.focus_subtitle = Gtk.Label()
        self.focus_goal_copy = Gtk.Label()
        self.sidebar_focus_name = Gtk.Label()
        self.active_time_label = Gtk.Label()
        self.file_label = Gtk.Label()
        self.work_status_label = Gtk.Label()
        self.code_label = Gtk.Label()
        self.notes_view = Gtk.TextView()
        self.threads_view = Gtk.TextView()
        self.todo_list = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=9)
        self.saved_label = Gtk.Label()
        self.language_label = Gtk.Label()
        self.lead_slot = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
        self.quiet_grid = Gtk.Grid(column_spacing=14, row_spacing=14)
        self.next_copy = Gtk.Label()

        self._build()
        self.render_state()

    def _build(self) -> None:
        shell = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=0)
        shell.add_css_class("app-shell")
        self.set_content(shell)

        shell.append(self._build_sidebar())

        scroller = Gtk.ScrolledWindow()
        scroller.set_hexpand(True)
        shell.append(scroller)

        root = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=16)
        root.add_css_class("main")
        scroller.set_child(root)

        root.append(self._build_focus_panel())

        body = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=16)
        body.set_hexpand(True)
        body.set_vexpand(True)
        root.append(body)

        work_panel = self._build_work_panel()
        work_panel.set_size_request(430, -1)
        body.append(work_panel)

        output = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=16)
        output.set_hexpand(True)
        output.set_vexpand(True)
        body.append(output)

        self.lead_slot.set_hexpand(True)
        output.append(self.lead_slot)

        self.quiet_grid.set_column_homogeneous(True)
        self.quiet_grid.set_row_homogeneous(True)
        self.quiet_grid.set_hexpand(True)
        self.quiet_grid.set_vexpand(True)
        output.append(self.quiet_grid)

        root.append(self._build_next_step())

        hint = Gtk.Label(label="Hinweis: Nur ein Sidecar ist Lead. Die anderen sind leise Karten.")
        hint.set_halign(Gtk.Align.CENTER)
        hint.add_css_class("hint")
        root.append(hint)

    def _build_sidebar(self) -> Gtk.Box:
        sidebar = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=18)
        sidebar.add_css_class("sidebar")
        sidebar.set_size_request(214, -1)

        brand = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=10)
        sidebar.append(brand)

        brand_icon = Gtk.Image.new_from_icon_name("applications-science-symbolic")
        brand_icon.set_pixel_size(36)
        brand_icon.add_css_class("sidecar-focus")
        brand.append(brand_icon)

        brand_text = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=2)
        brand.append(brand_text)

        title = Gtk.Label(label="AI Cockpit")
        title.set_xalign(0)
        title.add_css_class("brand-title")
        brand_text.append(title)

        subtitle = Gtk.Label(label="Dein agentischer Leitstand")
        subtitle.set_xalign(0)
        subtitle.add_css_class("brand-subtitle")
        brand_text.append(subtitle)

        nav = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=4)
        sidebar.append(nav)
        for index, (icon_name, label) in enumerate(
            (
                ("view-dashboard-symbolic", "Cockpit"),
                ("find-location-symbolic", "Fokus"),
                ("package-x-generic-symbolic", "Komponenten"),
                ("folder-symbolic", "Parks"),
                ("text-x-generic-symbolic", "Beweise"),
                ("utilities-system-monitor-symbolic", "AI Log"),
                ("preferences-system-symbolic", "Einstellungen"),
            )
        ):
            nav.append(self._nav_item(icon_name, label, active=index == 0))

        spacer = Gtk.Box()
        spacer.set_vexpand(True)
        sidebar.append(spacer)

        focus_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=9)
        focus_box.add_css_class("sidebar-focus")
        sidebar.append(focus_box)

        focus_label = Gtk.Label(label="Aktiver Fokus")
        focus_label.set_xalign(0)
        focus_label.add_css_class("muted")
        focus_box.append(focus_label)

        focus_row = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=7)
        focus_box.append(focus_row)

        dot = Gtk.Label(label="●")
        dot.add_css_class("sidebar-focus-dot")
        focus_row.append(dot)

        self.sidebar_focus_name.set_xalign(0)
        self.sidebar_focus_name.add_css_class("sidebar-focus-name")
        focus_row.append(self.sidebar_focus_name)

        self.active_time_label.set_xalign(0)
        self.active_time_label.add_css_class("muted")
        focus_box.append(self.active_time_label)

        return sidebar

    def _nav_item(self, icon_name: str, label: str, active: bool = False) -> Gtk.Box:
        item = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=12)
        item.add_css_class("nav-item")
        if active:
            item.add_css_class("nav-item-active")

        icon = Gtk.Image.new_from_icon_name(icon_name)
        icon.set_pixel_size(24)
        icon.add_css_class("nav-icon")
        item.append(icon)

        item_label = Gtk.Label(label=label)
        item_label.set_xalign(0)
        item.append(item_label)

        return item

    def _build_focus_panel(self) -> Gtk.Box:
        focus_panel = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=22)
        focus_panel.add_css_class("focus-panel")

        focus_icon = Gtk.Box()
        focus_icon.set_size_request(70, 70)
        focus_icon.set_halign(Gtk.Align.START)
        focus_icon.set_valign(Gtk.Align.CENTER)
        focus_icon.add_css_class("sidecar-icon")
        focus_icon.add_css_class("sidecar-scope")
        focus_image = Gtk.Image.new_from_icon_name("find-location-symbolic")
        focus_image.set_pixel_size(38)
        focus_image.set_halign(Gtk.Align.CENTER)
        focus_image.set_valign(Gtk.Align.CENTER)
        focus_icon.append(focus_image)
        focus_panel.append(focus_icon)

        focus_text = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=5)
        focus_text.set_hexpand(True)
        focus_panel.append(focus_text)

        eyebrow = Gtk.Label(label="AKTIVER FOKUS")
        eyebrow.set_xalign(0)
        eyebrow.add_css_class("eyebrow")
        focus_text.append(eyebrow)

        focus_text.append(self.focus_entry)

        self.focus_subtitle.set_xalign(0)
        self.focus_subtitle.add_css_class("focus-subtitle")
        focus_text.append(self.focus_subtitle)

        target = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=8)
        target.set_size_request(360, -1)
        target.set_valign(Gtk.Align.CENTER)
        target.add_css_class("focus-target")
        focus_panel.append(target)

        target_label = Gtk.Label(label="FOKUS-ZIEL")
        target_label.set_xalign(0)
        target_label.add_css_class("focus-goal")
        target.append(target_label)

        self.focus_goal_copy.set_xalign(0)
        self.focus_goal_copy.set_wrap(True)
        target.append(self.focus_goal_copy)

        return focus_panel

    def _build_work_panel(self) -> Gtk.Box:
        panel = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=12)
        panel.add_css_class("work-panel")

        title = Gtk.Label(label="DEINE AKTUELLE ARBEIT")
        title.set_xalign(0)
        title.add_css_class("section-title")
        panel.append(title)

        panel.append(self._build_code_panel())
        panel.append(self._text_field("NOTIZEN", self.notes_view, height=88))
        panel.append(self._text_field("OFFENE FÄDEN", self.threads_view, height=70))
        panel.append(self._build_todo_panel())
        panel.append(self._build_action_bar())

        footer = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=12)
        footer.add_css_class("work-footer")
        panel.append(footer)

        self.saved_label.set_xalign(0)
        self.saved_label.set_hexpand(True)
        footer.append(self.saved_label)

        footer.append(self.language_label)

        return panel

    def _build_code_panel(self) -> Gtk.Box:
        panel = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0)
        panel.add_css_class("code-panel")

        header = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=10)
        header.add_css_class("code-header")
        panel.append(header)

        icon = Gtk.Image.new_from_icon_name("text-x-python-symbolic")
        icon.set_pixel_size(20)
        icon.add_css_class("work-icon")
        header.append(icon)

        self.file_label.set_xalign(0)
        self.file_label.set_hexpand(True)
        header.append(self.file_label)

        self.work_status_label.add_css_class("muted")
        header.append(self.work_status_label)

        self.code_label.set_xalign(0)
        self.code_label.set_wrap(False)
        self.code_label.add_css_class("code-text")
        panel.append(self.code_label)

        return panel

    def _build_todo_panel(self) -> Gtk.Box:
        panel = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=9)
        panel.add_css_class("work-section")

        title = Gtk.Label(label="TODO")
        title.set_xalign(0)
        title.add_css_class("field-label")
        panel.append(title)

        panel.append(self.todo_list)
        return panel

    def _build_action_bar(self) -> Gtk.Box:
        panel = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=9)
        panel.add_css_class("work-section")

        title = Gtk.Label(label="OWNER-AKTIONEN")
        title.set_xalign(0)
        title.add_css_class("field-label")
        panel.append(title)

        grid = Gtk.Grid(column_spacing=8, row_spacing=8)
        grid.add_css_class("action-grid")
        panel.append(grid)

        actions = (
            ("Faden parken", "thread_parked"),
            ("Abschlussaktion setzen", "finish_action_set"),
            ("Todo erledigen", "todo_completed"),
            ("Beweis hinzufügen", "evidence_added"),
        )
        for index, (label, event_type) in enumerate(actions):
            button = Gtk.Button(label=label)
            button.add_css_class("owner-button")
            button.connect("clicked", lambda _button, kind=event_type: self._handle_owner_action(kind))
            grid.attach(button, index % 2, index // 2, 1, 1)

        return panel

    def _todo_row(self, item: dict[str, Any]) -> Gtk.Box:
        is_done = item.get("status") == "done"

        row = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=9)
        row.add_css_class("todo-row")

        check = Gtk.CheckButton()
        check.set_active(is_done)
        check.set_sensitive(False)
        row.append(check)

        label = Gtk.Label(label=text(item.get("text"), "Todo"))
        label.set_xalign(0)
        label.set_hexpand(True)
        row.append(label)

        state_label = Gtk.Label(label="Erledigt" if is_done else "Offen")
        state_label.add_css_class("todo-done" if is_done else "muted")
        row.append(state_label)

        return row

    def _build_next_step(self) -> Gtk.Box:
        next_step = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6)
        next_step.add_css_class("next-step")

        next_label = Gtk.Label(label="NÄCHSTER ERLAUBTER SCHRITT")
        next_label.set_xalign(0)
        next_label.add_css_class("next-label")
        next_step.append(next_label)

        self.next_copy.set_xalign(0)
        self.next_copy.set_wrap(True)
        self.next_copy.set_wrap_mode(Pango.WrapMode.WORD_CHAR)
        self.next_copy.add_css_class("next-copy")
        next_step.append(self.next_copy)

        return next_step

    def _field(self, label: str, widget: Gtk.Widget) -> Gtk.Box:
        box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6)
        field_label = Gtk.Label(label=label)
        field_label.set_xalign(0)
        field_label.add_css_class("field-label")
        box.append(field_label)
        box.append(widget)
        return box

    def _text_field(self, label: str, view: Gtk.TextView, height: int) -> Gtk.Box:
        view.set_wrap_mode(Gtk.WrapMode.WORD_CHAR)
        view.set_monospace(False)
        view.set_editable(False)
        view.set_cursor_visible(False)
        frame = Gtk.ScrolledWindow()
        frame.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
        frame.set_min_content_height(height)
        frame.set_child(view)
        return self._field(label, frame)

    def render_state(self) -> None:
        active_focus = self.state.get("active_focus", {})
        current_work = self.state.get("current_work", {})

        self.focus_entry.set_text(focus_name(self.state))
        self.sidebar_focus_name.set_label(focus_name(self.state))
        self.active_time_label.set_label(text(active_focus.get("active_for")))
        self.focus_subtitle.set_label(text(active_focus.get("subtitle")))
        self.focus_goal_copy.set_label(text(active_focus.get("goal")))

        self.file_label.set_label(text(current_work.get("file_path")))
        self.work_status_label.set_label(text(current_work.get("status")))
        self.code_label.set_label("\n".join(str(line) for line in current_work.get("code_lines", [])))
        self.saved_label.set_label(text(current_work.get("saved")))
        self.language_label.set_label(text(current_work.get("language")))
        set_text_view(self.notes_view, "\n".join(str(note) for note in current_work.get("notes", [])))
        set_text_view(self.threads_view, self._threads_text())

        self._render_todos()
        self._render_cards()
        self.next_copy.set_label(text(self.state.get("next_allowed_step")))

    def _threads_text(self) -> str:
        rows = []
        for thread in self.state.get("open_threads", []):
            rows.append(
                f"{text(thread.get('title'), 'Thread')} · "
                f"{text(thread.get('kind'), 'THREAD')} · "
                f"{text(thread.get('status'), 'open')}"
            )
        return "\n".join(rows)

    def _render_todos(self) -> None:
        while child := self.todo_list.get_first_child():
            self.todo_list.remove(child)

        for item in self.state.get("todos", []):
            self.todo_list.append(self._todo_row(item))

    def _render_cards(self) -> None:
        while child := self.lead_slot.get_first_child():
            self.lead_slot.remove(child)
        while child := self.quiet_grid.get_first_child():
            self.quiet_grid.remove(child)

        sidecars = list(self.state.get("sidecars", []))
        lead = next((sidecar for sidecar in sidecars if sidecar.get("is_lead") is True), sidecars[0])

        lead_card = SidecarCard(lead, lead=True)
        lead_card.update([str(sentence) for sentence in lead.get("sentences", [])])
        self.lead_slot.append(lead_card)

        quiet_sidecars = [sidecar for sidecar in sidecars if sidecar is not lead]
        for index, sidecar in enumerate(quiet_sidecars):
            card = SidecarCard(sidecar)
            card.update([str(sentence) for sentence in sidecar.get("sentences", [])])
            self.quiet_grid.attach(card, index % 2, index // 2, 1, 1)

    def _handle_owner_action(self, event_type: str) -> None:
        payload: dict[str, Any] = {"active_focus": focus_name(self.state)}

        if event_type == "thread_parked":
            payload.update(self._park_thread())
        elif event_type == "finish_action_set":
            payload.update(self._set_finish_action())
        elif event_type == "todo_completed":
            payload.update(self._complete_todo())
        elif event_type == "evidence_added":
            payload.update(self._add_evidence_note())

        self.store.append_event({"type": event_type, "payload": payload})
        self.store.save_state(self.state)
        self.render_state()

    def _park_thread(self) -> dict[str, Any]:
        for thread in self.state.get("open_threads", []):
            if thread.get("kind") != "ACTIVE" and thread.get("status") != "parked":
                thread["status"] = "parked"
                return {"thread_id": thread.get("id"), "result": "parked"}
        return {"result": "no_open_thread"}

    def _set_finish_action(self) -> dict[str, Any]:
        step = "Schließe die kleinste sichtbare Einheit ab: Unit-Test für evaluate_focus."
        self.state["next_allowed_step"] = step
        return {"next_allowed_step": step}

    def _complete_todo(self) -> dict[str, Any]:
        for todo in self.state.get("todos", []):
            if todo.get("status") != "done":
                todo["status"] = "done"
                return {"todo_id": todo.get("id"), "result": "done"}
        return {"result": "no_open_todo"}

    def _add_evidence_note(self) -> dict[str, Any]:
        note = "Beweis hinzugefügt: Owner-Aktion protokolliert."
        current_work = self.state.setdefault("current_work", {})
        notes = current_work.setdefault("notes", [])
        if isinstance(notes, list):
            notes.append(note)
        return {"evidence": note}


class CockpitApp(Adw.Application):
    def __init__(self) -> None:
        super().__init__(application_id=APP_ID, flags=Gio.ApplicationFlags.DEFAULT_FLAGS)
        self._css_provider = Gtk.CssProvider()
        self._css_provider.load_from_data(CSS.encode("utf-8"))
        self._css_installed = False

    def do_startup(self) -> None:
        Adw.Application.do_startup(self)
        Adw.StyleManager.get_default().set_color_scheme(Adw.ColorScheme.FORCE_DARK)

    def do_activate(self) -> None:
        window = self.props.active_window
        if window is None:
            window = CockpitWindow(self)
        if not self._css_installed:
            Gtk.StyleContext.add_provider_for_display(
                window.get_display(),
                self._css_provider,
                Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION,
            )
            self._css_installed = True
        window.present()


def main() -> int:
    app = CockpitApp()
    return app.run(sys.argv)


if __name__ == "__main__":
    raise SystemExit(main())