from __future__ import annotations

from .backends import AgentBackend, FakeAgentBackend
from .models import Decision, JobSnapshot
from .store import SQLiteStatusStore


PHASES = ("plan", "research", "code", "test", "verify", "result")


class LocalAgentKernel:
    """Small in-process orchestration boundary for V1.

    The public methods are intentionally daemon-shaped. The GUI should keep
    calling this facade when the implementation later moves behind IPC.
    """

    def __init__(self, store: SQLiteStatusStore | None = None, agent_backend: AgentBackend | None = None) -> None:
        self.store = store or SQLiteStatusStore()
        self.agent_backend = agent_backend or FakeAgentBackend()

    def submit_intent(self, text: str) -> int:
        intent = text.strip()
        if not intent:
            raise ValueError("Intent must not be empty.")

        job = self.store.create_job(intent)
        self.store.create_phases(job.id, PHASES)
        self.store.update_phase(job.id, "plan", "running", "Intent wird in einen Arbeitsplan verdichtet.")
        self.store.update_phase(
            job.id,
            "plan",
            "completed",
            f"Plan erstellt: {intent}",
        )
        self.store.update_phase(
            job.id,
            "research",
            "waiting",
            "Wartet auf menschliche Freigabe des verdichteten Plans.",
        )
        self.store.create_decision(
            job_id=job.id,
            phase_name="plan",
            title="Plan freigeben",
            context=(
                "Der Kernel hat den Intent in einen kleinen V1-Plan übersetzt. "
                "Die nächsten Phasen laufen automatisch, wenn der Plan freigegeben wird."
            ),
            options=["Plan freigeben", "Plan anpassen", "Auftrag blockieren"],
        )
        self.store.update_job_status(job.id, "waiting_decision")
        return job.id

    def get_job_status(self, job_id: int) -> JobSnapshot:
        return self.store.snapshot(job_id)

    def list_jobs(self):
        return self.store.list_jobs()

    def list_open_decisions(self, job_id: int) -> list[Decision]:
        return self.store.list_open_decisions(job_id)

    def answer_decision(self, decision_id: int, selected_option: str, note: str = "") -> JobSnapshot:
        answered = self.store.answer_decision(decision_id, selected_option, note)

        if selected_option == "Auftrag blockieren":
            self._block_job(answered.job_id, note)
            return self.store.snapshot(answered.job_id)

        if selected_option == "Plan anpassen":
            self._request_plan_adjustment(answered.job_id, note)
            return self.store.snapshot(answered.job_id)

        self._run_remaining_phases(answered.job_id)
        return self.store.snapshot(answered.job_id)

    def approve_result(self, job_id: int, approved: bool) -> JobSnapshot:
        self.store.set_result_approval(job_id, approved)
        self.store.update_job_status(job_id, "approved" if approved else "rejected")
        return self.store.snapshot(job_id)

    def _request_plan_adjustment(self, job_id: int, note: str) -> None:
        adjustment = note.strip() or "Bitte Plan vor Ausführung anpassen."
        self.store.update_phase(job_id, "plan", "waiting", "Plananpassung angefordert.")
        self.store.create_decision(
            job_id=job_id,
            phase_name="plan",
            title="Angepassten Plan freigeben",
            context=(
                "Gewünschte Anpassung: "
                f"{adjustment} "
                "Der Skeleton-Kernel hält den Auftrag, bis diese Anpassung freigegeben wird."
            ),
            options=["Plan freigeben", "Auftrag blockieren"],
        )
        self.store.update_job_status(job_id, "waiting_decision")

    def _block_job(self, job_id: int, note: str) -> None:
        reason = note.strip() or "Auftrag wurde an einem Human-Gate blockiert."
        for phase in self.store.list_phases(job_id):
            if phase.status in {"pending", "waiting", "running"}:
                self.store.update_phase(job_id, phase.name, "blocked", reason)
        self.store.save_result(
            job_id=job_id,
            summary="Der Auftrag wurde vor der automatischen Ausführung blockiert.",
            blocked=True,
            decisions=self._decision_summaries(job_id),
            next_steps=["Blocker klären", "Auftrag mit geschärftem Ziel neu starten"],
        )
        self.store.update_job_status(job_id, "blocked")

    def _run_remaining_phases(self, job_id: int) -> None:
        job = self.store.get_job(job_id)
        for phase_name in PHASES[1:]:
            phase = self.store.update_phase(job_id, phase_name, "running", f"{phase_name} läuft.")
            outcome = self.agent_backend.run_phase(
                job,
                phase,
                context="Current CLFGUI V1 skeleton flow. Return a concise phase summary only.",
            )
            self.store.update_phase(job_id, phase_name, outcome.status, outcome.summary)

        self.store.save_result(
            job_id=job_id,
            summary=(
                "V1-Skeleton abgeschlossen: Intent aufgenommen, Plan freigegeben, "
                "Phasen abgearbeitet und Ergebnispaket erzeugt."
            ),
            blocked=False,
            decisions=self._decision_summaries(job_id),
            next_steps=[
                "Echte Agent-Adapter für Research/Code/Test anbinden",
                "Kernel bei Bedarf in separaten Headless-Daemon auslagern",
                f"Folgeauftrag für '{job.intent}' starten",
            ],
        )
        self.store.update_job_status(job_id, "awaiting_approval")

    def _decision_summaries(self, job_id: int) -> list[str]:
        summaries: list[str] = []
        for decision in self.store.list_decisions(job_id):
            if decision.selected_option:
                note = f" ({decision.note})" if decision.note else ""
                summaries.append(f"{decision.title}: {decision.selected_option}{note}")
            else:
                summaries.append(f"{decision.title}: offen")
        return summaries