src/clfgui/gui/main_window.py

from __future__ import annotations

from functools import partial

from PySide6.QtCore import Qt, QTimer
from PySide6.QtWidgets import (
    QApplication,
    QFrame,
    QHBoxLayout,
    QLabel,
    QLayout,
    QMainWindow,
    QMessageBox,
    QPushButton,
    QScrollArea,
    QSizePolicy,
    QTextEdit,
    QVBoxLayout,
    QWidget,
)

from clfgui.kernel import Job, JobSnapshot, LocalAgentKernel, Phase, SQLiteStatusStore

from .paths import qstandard_db_path


STATUS_LABELS = {
    "running": "Läuft",
    "waiting_decision": "Human-Gate",
    "awaiting_approval": "Ergebnisfreigabe",
    "approved": "Freigegeben",
    "rejected": "Abgelehnt",
    "blocked": "Blockiert",
    "pending": "Ausstehend",
    "waiting": "Wartet",
    "completed": "Fertig",
    "failed": "Fehler",
}


PHASE_LABELS = {
    "plan": "Plan",
    "research": "Research",
    "code": "Code",
    "test": "Test",
    "verify": "Verify",
    "result": "Ergebnis",
}


class MainWindow(QMainWindow):
    def __init__(self, kernel: LocalAgentKernel | None = None) -> None:
        super().__init__()
        self.kernel = kernel or LocalAgentKernel(SQLiteStatusStore(qstandard_db_path()))
        self.active_job_id: int | None = None
        self._selected_decision_id: int | None = None
        self._selected_decision_option: str | None = None

        self.setWindowTitle("CLFGUI")
        self.resize(1360, 820)
        self.setMinimumSize(1120, 700)
        self._build_ui()
        self._apply_style()
        self.refresh()

        self._timer = QTimer(self)
        self._timer.timeout.connect(self.refresh)
        self._timer.start(1000)

    def _build_ui(self) -> None:
        root = QWidget()
        root.setObjectName("appRoot")
        root_layout = QHBoxLayout(root)
        root_layout.setContentsMargins(0, 0, 0, 0)
        root_layout.setSpacing(0)

        root_layout.addWidget(self._build_sidebar())
        root_layout.addWidget(self._build_workspace(), 1)
        self.setCentralWidget(root)

    def _build_sidebar(self) -> QWidget:
        sidebar = QFrame()
        sidebar.setObjectName("sidebar")
        sidebar.setFixedWidth(342)
        layout = QVBoxLayout(sidebar)
        layout.setContentsMargins(22, 22, 22, 22)
        layout.setSpacing(18)

        title = QLabel("Owner Cockpit")
        title.setObjectName("appTitle")
        self.status_badge = QLabel("Bereit")
        self.status_badge.setObjectName("statusBadge")
        self.status_badge.setProperty("state", "idle")
        self.status_badge.setAlignment(Qt.AlignmentFlag.AlignCenter)

        self.intent_input = QTextEdit()
        self.intent_input.setObjectName("intentInput")
        self.intent_input.setAcceptRichText(False)
        self.intent_input.setPlaceholderText("Ich will ...")
        self.intent_input.setFixedHeight(116)

        self.submit_button = QPushButton("Auftrag starten")
        self.submit_button.setObjectName("primaryButton")
        self.submit_button.clicked.connect(self._submit_intent)

        jobs_title = QLabel("Aufträge")
        jobs_title.setObjectName("sidebarSection")

        self.jobs_content = QWidget()
        self.jobs_content.setObjectName("jobsContent")
        self.jobs_layout = QVBoxLayout(self.jobs_content)
        self.jobs_layout.setContentsMargins(0, 0, 0, 0)
        self.jobs_layout.setSpacing(8)

        jobs_scroll = QScrollArea()
        jobs_scroll.setObjectName("jobsScroll")
        jobs_scroll.setWidgetResizable(True)
        jobs_scroll.setFrameShape(QFrame.Shape.NoFrame)
        jobs_scroll.setWidget(self.jobs_content)

        layout.addWidget(title)
        layout.addWidget(self.status_badge)
        layout.addWidget(self.intent_input)
        layout.addWidget(self.submit_button)
        layout.addSpacing(6)
        layout.addWidget(jobs_title)
        layout.addWidget(jobs_scroll, 1)
        return sidebar

    def _build_workspace(self) -> QWidget:
        workspace = QWidget()
        workspace.setObjectName("workspace")
        layout = QVBoxLayout(workspace)
        layout.setContentsMargins(24, 22, 24, 22)
        layout.setSpacing(18)

        top = QHBoxLayout()
        top.setSpacing(16)
        title_group = QVBoxLayout()
        title_group.setSpacing(4)
        page_title = QLabel("Aktiver Auftrag")
        page_title.setObjectName("pageTitle")
        self.header_context = QLabel("Kein Auftrag aktiv.")
        self.header_context.setObjectName("headerContext")
        self.header_context.setWordWrap(True)
        title_group.addWidget(page_title)
        title_group.addWidget(self.header_context)
        self.plan_status = QLabel("Human-Gates: keine offen")
        self.plan_status.setObjectName("topMeta")
        top.addLayout(title_group, 1)
        top.addWidget(self.plan_status, 0, Qt.AlignmentFlag.AlignTop)

        body = QHBoxLayout()
        body.setSpacing(18)
        body.addWidget(self._build_plan_panel(), 1)
        body.addWidget(self._build_action_panel())

        layout.addLayout(top)
        layout.addLayout(body, 1)
        return workspace

    def _build_plan_panel(self) -> QWidget:
        panel = self._panel("planPanel")
        layout = QVBoxLayout(panel)
        layout.setContentsMargins(20, 18, 20, 20)
        layout.setSpacing(14)

        layout.addWidget(self._section_title("Laufender Plan"))
        self.phase_content = QWidget()
        self.phase_content.setObjectName("phaseContent")
        self.phase_layout = QVBoxLayout(self.phase_content)
        self.phase_layout.setContentsMargins(0, 0, 0, 0)
        self.phase_layout.setSpacing(10)

        phase_scroll = QScrollArea()
        phase_scroll.setObjectName("phaseScroll")
        phase_scroll.setWidgetResizable(True)
        phase_scroll.setFrameShape(QFrame.Shape.NoFrame)
        phase_scroll.setWidget(self.phase_content)

        layout.addWidget(phase_scroll, 1)
        return panel

    def _build_action_panel(self) -> QWidget:
        panel = QWidget()
        panel.setObjectName("actionColumn")
        panel.setFixedWidth(402)
        layout = QVBoxLayout(panel)
        layout.setContentsMargins(0, 0, 0, 0)
        layout.setSpacing(18)
        layout.addWidget(self._build_decision_panel(), 1)
        layout.addWidget(self._build_result_panel(), 1)
        return panel

    def _build_decision_panel(self) -> QWidget:
        panel = self._panel("decisionPanel")
        layout = QVBoxLayout(panel)
        layout.setContentsMargins(20, 18, 20, 20)
        layout.setSpacing(14)

        layout.addWidget(self._section_title("Entscheidung"))
        self.decision_content = QWidget()
        self.decision_content_layout = QVBoxLayout(self.decision_content)
        self.decision_content_layout.setContentsMargins(0, 0, 0, 0)
        self.decision_content_layout.setSpacing(12)
        layout.addWidget(self.decision_content, 1)
        return panel

    def _build_result_panel(self) -> QWidget:
        panel = self._panel("resultPanel")
        layout = QVBoxLayout(panel)
        layout.setContentsMargins(20, 18, 20, 20)
        layout.setSpacing(14)

        layout.addWidget(self._section_title("Ergebnis"))
        self.result_text = QTextEdit()
        self.result_text.setObjectName("resultText")
        self.result_text.setReadOnly(True)
        self.result_text.setAcceptRichText(False)
        self.result_text.setPlaceholderText("Noch kein Ergebnis vorhanden.")

        button_row = QHBoxLayout()
        button_row.setSpacing(10)
        self.approve_button = QPushButton("Freigeben")
        self.approve_button.setObjectName("primaryButton")
        self.approve_button.clicked.connect(partial(self._approve_result, True))
        self.reject_button = QPushButton("Ablehnen")
        self.reject_button.setObjectName("secondaryButton")
        self.reject_button.clicked.connect(partial(self._approve_result, False))
        button_row.addWidget(self.approve_button)
        button_row.addWidget(self.reject_button)

        layout.addWidget(self.result_text, 1)
        layout.addLayout(button_row)
        return panel

    @staticmethod
    def _panel(name: str) -> QFrame:
        panel = QFrame()
        panel.setObjectName(name)
        panel.setFrameShape(QFrame.Shape.NoFrame)
        return panel

    @staticmethod
    def _section_title(text: str) -> QLabel:
        label = QLabel(text)
        label.setObjectName("sectionTitle")
        return label

    def _apply_style(self) -> None:
        self.setStyleSheet(
            """
            #appRoot {
                background: #eef1f4;
            }
            QWidget {
                color: #18202a;
                font-size: 13px;
            }
            QLabel {
                background: transparent;
            }
            #sidebar {
                background: #151d27;
                border-right: 1px solid #25313e;
            }
            #workspace {
                background: #eef1f4;
            }
            #appTitle {
                color: #f8fafc;
                font-size: 24px;
                font-weight: 800;
            }
            #sidebarSection {
                color: #aeb8c4;
                font-size: 12px;
                font-weight: 800;
                letter-spacing: 0px;
            }
            #pageTitle {
                color: #18202a;
                font-size: 24px;
                font-weight: 800;
            }
            #headerContext {
                color: #637080;
                font-size: 13px;
            }
            #topMeta {
                background: #ffffff;
                color: #56616f;
                border: 1px solid #d7dde5;
                border-radius: 10px;
                padding: 8px 12px;
                font-weight: 700;
            }
            #statusBadge {
                background: #263241;
                color: #dce3ea;
                border: 1px solid #334253;
                border-radius: 10px;
                padding: 9px 12px;
                font-weight: 800;
            }
            #statusBadge[state="waiting_decision"], #statusBadge[state="waiting"] {
                background: #382e16;
                border-color: #9c7a25;
                color: #f7d677;
            }
            #statusBadge[state="awaiting_approval"], #statusBadge[state="running"] {
                background: #173044;
                border-color: #34708f;
                color: #a6d8ef;
            }
            #statusBadge[state="approved"] {
                background: #173526;
                border-color: #2f7b52;
                color: #99ddb6;
            }
            #statusBadge[state="blocked"], #statusBadge[state="rejected"], #statusBadge[state="failed"] {
                background: #3e1e1e;
                border-color: #9d4a40;
                color: #f2b0a7;
            }
            #intentInput {
                background: #0f1721;
                color: #f4f7fb;
                border: 1px solid #2a3847;
                border-radius: 12px;
                padding: 10px;
                selection-background-color: #2e6b77;
            }
            #intentInput::placeholder {
                color: #758293;
            }
            #resultText {
                background: #f8fafc;
                color: #202a35;
                border: 1px solid #d8dee6;
                border-radius: 12px;
                padding: 10px;
                selection-background-color: #cde3ec;
            }
            #primaryButton {
                background: #2f7783;
                color: #ffffff;
                border: 1px solid #286773;
                border-radius: 12px;
                padding: 10px 14px;
                min-height: 34px;
                font-weight: 800;
            }
            #primaryButton:hover:!disabled {
                background: #286b76;
            }
            #secondaryButton {
                background: #ffffff;
                color: #2e3946;
                border: 1px solid #cbd3dc;
                border-radius: 12px;
                padding: 10px 14px;
                min-height: 34px;
                font-weight: 800;
            }
            #secondaryButton:hover:!disabled {
                background: #f4f7fa;
            }
            QPushButton:disabled {
                background: #e4e8ed;
                border: 1px solid #d3d9e1;
                color: #9aa5b2;
            }
            #jobsScroll, #phaseScroll {
                background: transparent;
                border: 0;
            }
            #jobsContent, #phaseContent, #actionColumn {
                background: transparent;
            }
            #jobButton {
                background: #1c2734;
                color: #c7d0dc;
                border: 1px solid #2c3948;
                border-radius: 12px;
                padding: 11px 12px;
                text-align: left;
                font-weight: 700;
            }
            #jobButton:hover {
                background: #243244;
            }
            #jobButton[selected="true"] {
                background: #eaf7fa;
                color: #14313a;
                border-color: #72aeb8;
            }
            #planPanel, #decisionPanel, #resultPanel {
                background: #ffffff;
                border: 1px solid #d9dfe7;
                border-radius: 18px;
            }
            #sectionTitle {
                color: #18202a;
                font-size: 16px;
                font-weight: 800;
            }
            #phaseRow {
                background: #f8fafc;
                border: 1px solid #e0e5ec;
                border-radius: 14px;
            }
            #phaseRow[active="true"] {
                background: #fff8e8;
                border-color: #e5be5f;
            }
            #phaseName {
                color: #18202a;
                font-weight: 800;
                font-size: 14px;
            }
            #phaseSummary {
                color: #5b6775;
                font-size: 13px;
            }
            #statusPill {
                border-radius: 10px;
                padding: 5px 9px;
                font-weight: 800;
                font-size: 12px;
            }
            #statusPill[state="pending"] {
                background: #edf1f5;
                color: #657181;
            }
            #statusPill[state="waiting"], #statusPill[state="waiting_decision"] {
                background: #fff0c6;
                color: #735300;
            }
            #statusPill[state="completed"], #statusPill[state="approved"] {
                background: #daf3e3;
                color: #1f6339;
            }
            #statusPill[state="running"], #statusPill[state="awaiting_approval"] {
                background: #dceff7;
                color: #22566d;
            }
            #statusPill[state="blocked"], #statusPill[state="failed"], #statusPill[state="rejected"] {
                background: #f9ddd8;
                color: #84372c;
            }
            #decisionTitle {
                color: #18202a;
                font-size: 16px;
                font-weight: 800;
            }
            #bodyText {
                color: #526070;
                line-height: 1.35;
            }
            #optionButton {
                background: #f7f9fb;
                color: #26313d;
                border: 1px solid #d9e0e8;
                border-radius: 12px;
                padding: 10px 12px;
                text-align: left;
                font-weight: 700;
            }
            #optionButton:hover {
                background: #eef5f7;
            }
            #optionButton[selected="true"] {
                background: #e5f4f7;
                color: #14353c;
                border-color: #5ca2ad;
            }
            #decisionNote {
                background: #f8fafc;
                color: #202a35;
                border: 1px solid #d8dee6;
                border-radius: 12px;
                padding: 9px;
            }
            QScrollBar:vertical {
                background: transparent;
                width: 10px;
                margin: 0;
            }
            QScrollBar::handle:vertical {
                background: #c6ced8;
                border-radius: 5px;
                min-height: 36px;
            }
            QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical {
                height: 0;
            }
            """
        )

    def _submit_intent(self) -> None:
        try:
            job_id = self.kernel.submit_intent(self.intent_input.toPlainText())
        except ValueError as exc:
            QMessageBox.warning(self, "Auftrag fehlt", str(exc))
            return

        self.active_job_id = job_id
        self.intent_input.clear()
        self.refresh()

    def _select_job(self, job_id: int) -> None:
        self.active_job_id = job_id
        self.refresh()

    def _select_decision_option(self, decision_id: int, option: str) -> None:
        self._selected_decision_id = decision_id
        self._selected_decision_option = option
        for button in self.decision_content.findChildren(QPushButton):
            if button.objectName() != "optionButton":
                continue
            selected = button.property("decision_id") == decision_id and button.property("option") == option
            button.setProperty("selected", "true" if selected else "false")
            self._refresh_widget_style(button)

    def _answer_decision(self) -> None:
        if self._selected_decision_id is None or self._selected_decision_option is None:
            QMessageBox.warning(self, "Entscheidung fehlt", "Bitte eine Option auswählen.")
            return

        self.kernel.answer_decision(
            self._selected_decision_id,
            self._selected_decision_option,
            self.decision_note.toPlainText(),
        )
        self._selected_decision_id = None
        self._selected_decision_option = None
        self.refresh()

    def _approve_result(self, approved: bool) -> None:
        if self.active_job_id is None:
            return
        try:
            self.kernel.approve_result(self.active_job_id, approved)
        except KeyError:
            QMessageBox.information(self, "Kein Ergebnis", "Für diesen Auftrag liegt noch kein Ergebnis vor.")
            return
        self.refresh()

    def refresh(self) -> None:
        self._refresh_jobs()
        snapshot = self._active_snapshot()
        self._refresh_header(snapshot)
        self._refresh_plan(snapshot)
        self._refresh_decisions(snapshot)
        self._refresh_results(snapshot)

    def _refresh_jobs(self) -> None:
        jobs = self.kernel.list_jobs()
        if self.active_job_id is None and jobs:
            self.active_job_id = jobs[0].id

        self._clear_layout(self.jobs_layout)
        for job in jobs:
            self.jobs_layout.addWidget(self._job_button(job))
        self.jobs_layout.addStretch(1)

    def _job_button(self, job: Job) -> QPushButton:
        status = STATUS_LABELS.get(job.status, job.status)
        intent = job.intent if len(job.intent) <= 48 else f"{job.intent[:45]}..."
        button = QPushButton(f"#{job.id} · {status}\n{intent}")
        button.setObjectName("jobButton")
        button.setProperty("selected", "true" if job.id == self.active_job_id else "false")
        button.setCursor(Qt.CursorShape.PointingHandCursor)
        button.clicked.connect(partial(self._select_job, job.id))
        button.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
        return button

    def _active_snapshot(self) -> JobSnapshot | None:
        if self.active_job_id is None:
            return None
        try:
            return self.kernel.get_job_status(self.active_job_id)
        except KeyError:
            self.active_job_id = None
            return None

    def _refresh_header(self, snapshot: JobSnapshot | None) -> None:
        if snapshot is None:
            self.header_context.setText("Kein Auftrag aktiv.")
            self.status_badge.setText("Bereit")
            self._set_status_state("idle")
            return

        status = STATUS_LABELS.get(snapshot.job.status, snapshot.job.status)
        self.status_badge.setText(status)
        self._set_status_state(snapshot.job.status)
        self.header_context.setText(f"#{snapshot.job.id} · {snapshot.job.intent}")

    def _refresh_plan(self, snapshot: JobSnapshot | None) -> None:
        self._clear_layout(self.phase_layout)
        if snapshot is None:
            self.plan_status.setText("Human-Gates: keine offen")
            self.phase_layout.addWidget(self._empty_label("Kein Auftrag ausgewählt."))
            self.phase_layout.addStretch(1)
            return

        open_decisions = [decision for decision in snapshot.decisions if decision.status == "open"]
        gate_text = f"{len(open_decisions)} offen" if open_decisions else "keine offen"
        self.plan_status.setText(f"Human-Gates: {gate_text}")

        for phase in snapshot.phases:
            self.phase_layout.addWidget(self._phase_row(phase))
        self.phase_layout.addStretch(1)

    def _phase_row(self, phase: Phase) -> QWidget:
        row = QFrame()
        row.setObjectName("phaseRow")
        row.setProperty("active", "true" if phase.status in {"running", "waiting"} else "false")
        layout = QHBoxLayout(row)
        layout.setContentsMargins(14, 12, 14, 12)
        layout.setSpacing(14)

        text_group = QVBoxLayout()
        text_group.setSpacing(3)
        name = QLabel(PHASE_LABELS.get(phase.name, phase.name))
        name.setObjectName("phaseName")
        summary = QLabel(phase.summary or "Noch keine Zusammenfassung.")
        summary.setObjectName("phaseSummary")
        summary.setWordWrap(True)
        text_group.addWidget(name)
        text_group.addWidget(summary)

        status = QLabel(STATUS_LABELS.get(phase.status, phase.status))
        status.setObjectName("statusPill")
        status.setProperty("state", phase.status)
        status.setAlignment(Qt.AlignmentFlag.AlignCenter)
        status.setMinimumWidth(112)

        layout.addLayout(text_group, 1)
        layout.addWidget(status, 0, Qt.AlignmentFlag.AlignTop)
        return row

    def _refresh_decisions(self, snapshot: JobSnapshot | None) -> None:
        self._clear_layout(self.decision_content_layout)
        self._selected_decision_id = None
        self._selected_decision_option = None

        if snapshot is None:
            self.decision_content_layout.addWidget(self._empty_label("Kein Auftrag ausgewählt."))
            self.decision_content_layout.addStretch(1)
            return

        open_decisions = [decision for decision in snapshot.decisions if decision.status == "open"]
        if not open_decisions:
            self.decision_content_layout.addWidget(self._empty_label("Keine offenen Human-Gates."))
            self.decision_content_layout.addStretch(1)
            return

        decision = open_decisions[0]
        title = QLabel(decision.title)
        title.setObjectName("decisionTitle")
        title.setWordWrap(True)
        context = QLabel(decision.context)
        context.setWordWrap(True)
        context.setObjectName("bodyText")

        self.decision_content_layout.addWidget(title)
        self.decision_content_layout.addWidget(context)

        for index, option in enumerate(decision.options):
            button = QPushButton(option)
            button.setObjectName("optionButton")
            button.setProperty("decision_id", decision.id)
            button.setProperty("option", option)
            button.setProperty("selected", "true" if index == 0 else "false")
            button.setCheckable(False)
            button.setCursor(Qt.CursorShape.PointingHandCursor)
            button.clicked.connect(partial(self._select_decision_option, decision.id, option))
            self.decision_content_layout.addWidget(button)
            if index == 0:
                self._selected_decision_id = decision.id
                self._selected_decision_option = option

        self.decision_note = QTextEdit()
        self.decision_note.setObjectName("decisionNote")
        self.decision_note.setAcceptRichText(False)
        self.decision_note.setPlaceholderText("Optionaler Hinweis")
        self.decision_note.setFixedHeight(86)

        submit = QPushButton("Antwort senden")
        submit.setObjectName("primaryButton")
        submit.clicked.connect(self._answer_decision)

        self.decision_content_layout.addWidget(self.decision_note)
        self.decision_content_layout.addWidget(submit)
        self.decision_content_layout.addStretch(1)

    def _refresh_results(self, snapshot: JobSnapshot | None) -> None:
        if snapshot is None or snapshot.result is None:
            self.result_text.clear()
            self.approve_button.setEnabled(False)
            self.reject_button.setEnabled(False)
            return

        result = snapshot.result
        decisions = "\n".join(f"- {item}" for item in result.decisions) or "- Keine"
        next_steps = "\n".join(f"- {item}" for item in result.next_steps) or "- Keine"
        blocked = "Ja" if result.blocked else "Nein"
        approval = (
            "Offen"
            if result.approved is None
            else "Freigegeben"
            if result.approved
            else "Abgelehnt"
        )
        self.result_text.setPlainText(
            "\n\n".join(
                [
                    f"Was gemacht wurde\n{result.summary}",
                    f"Was blockiert ist\n{blocked}",
                    f"Was du entschieden hast\n{decisions}",
                    f"Was als Nächstes sinnvoll ist\n{next_steps}",
                    f"Freigabe\n{approval}",
                ]
            )
        )
        buttons_enabled = result.approved is None and not result.blocked
        self.approve_button.setEnabled(buttons_enabled)
        self.reject_button.setEnabled(buttons_enabled)

    @staticmethod
    def _empty_label(text: str) -> QLabel:
        label = QLabel(text)
        label.setObjectName("bodyText")
        label.setWordWrap(True)
        return label

    def _set_status_state(self, state: str) -> None:
        self.status_badge.setProperty("state", state)
        self._refresh_widget_style(self.status_badge)

    @staticmethod
    def _refresh_widget_style(widget: QWidget) -> None:
        widget.style().unpolish(widget)
        widget.style().polish(widget)

    @staticmethod
    def _clear_layout(layout: QLayout) -> None:
        while layout.count():
            item = layout.takeAt(0)
            widget = item.widget()
            child_layout = item.layout()
            if widget is not None:
                widget.setParent(None)
                widget.deleteLater()
            elif child_layout is not None:
                MainWindow._clear_layout(child_layout)


def run_app(argv: list[str]) -> int:
    QApplication.setOrganizationName("CLFGUI")
    QApplication.setApplicationName("CLFGUI")
    QApplication.setStyle("Fusion")
    app = QApplication(argv)
    window = MainWindow()
    window.show()
    return app.exec()