"""HTTP-facing lifecycle owner for the autonomous CDSL author."""

from __future__ import annotations

import asyncio
import base64
from collections.abc import AsyncIterator
import json
import secrets
from pathlib import Path
from typing import Any

import httpx

from app.models.contracts import ChatMessage
from app.services.autonomous_cdsl_generation import AutonomousCdslGenerationRunner
from app.services.library import CdslLibrary
from app.services.review_renderer import renderer_status
from app.services.sse import event
from app.services.storage import WorkspaceStore
from app.settings import ProviderConfig, ProviderModel, Settings


def text_from_message(message: ChatMessage) -> str:
    return "\n".join(part.text or "" for part in message.parts if part.type == "text").strip()


def conversation_user_context(conversation: dict[str, Any]) -> list[dict[str, str]]:
    """Return durable user intent from the whole conversation.

    A terminal CAD task always starts a fresh frozen requirements document,
    but it must not lose the earlier user messages that explain what a short
    follow-up means.  This deliberately has no keyword handling: ``retry``,
    ``change it`` and a full replacement prompt are all ordinary conversation
    turns.  Assistant prose is excluded because it is generated evidence, not
    user intent.
    """
    entries: list[str] = []
    for message in conversation.get("messages") or ():
        if not isinstance(message, dict) or message.get("role") != "user":
            continue
        parts = message.get("parts") or ()
        text = "\n".join(
            str(part.get("text") or "")
            for part in parts
            if isinstance(part, dict) and str(part.get("type") or "") == "text"
        ).strip()
        if text:
            entries.append(text)
    if not entries:
        return []
    # Bound history without giving an arbitrary short follow-up precedence
    # over its preceding detailed request.  The latest user turn remains last.
    selected: list[str] = []
    remaining = 18_000
    for text in reversed(entries):
        if len(text) > remaining and selected:
            break
        selected.append(text[-remaining:])
        remaining -= len(selected[-1])
        if remaining <= 0 or len(selected) >= 12:
            break
    selected.reverse()
    return [{
        "role": "user",
        "content": "Conversation user context, ordered from earlier to latest. Use it to interpret the current CAD request; do not treat short follow-ups as a replacement unless they explicitly say so:\n\n"
        + "\n\n--- Next user turn ---\n\n".join(selected),
    }]


class AgentService:
    def __init__(self, settings: Settings, store: WorkspaceStore, library: CdslLibrary) -> None:
        self.settings = settings
        self.store = store
        self.library = library
        self._autonomous_runs: dict[str, asyncio.Task[None]] = {}

    async def resume_running_tasks(self) -> None:
        """Restart only durable native autonomous workers after process recovery."""
        for task in self.store.running_tasks():
            task_id = str(task.get("task_id") or "")
            state = self.store.read_agent_state(task_id) if task_id else None
            if not task_id or task_id in self._autonomous_runs:
                continue
            if str(task.get("schema_version") or "") != "2.0" or not isinstance(state, dict):
                self.store.finish_generation(task_id, lifecycle="failed", failure={
                    "schema_version": "cad.autonomous-failure.v1",
                    "stage": "recovery",
                    "error_code": "AUTONOMOUS_PROTOCOL_OBSOLETE",
                    "message": "This running task uses the retired planning/strict-authoring protocol and cannot be resumed.",
                })
                continue
            try:
                provider, model = self.settings.resolve_model(str(state.get("provider_id") or ""), str(state.get("model_id") or ""))
            except ValueError as error:
                self.store.finish_generation(task_id, lifecycle="failed", failure={
                    "schema_version": "cad.autonomous-failure.v1", "stage": "recovery", "message": str(error),
                })
                continue
            try:
                self.settings.resolve_independent_review_model(provider, model)
                renderer_ready, renderer_detail = renderer_status()
                if not renderer_ready:
                    raise ValueError(renderer_detail)
            except ValueError as error:
                self.store.finish_generation(task_id, lifecycle="failed", failure={
                    "schema_version": "cad.autonomous-failure.v1",
                    "stage": "recovery",
                    "error_code": "FINAL_REVIEW_UNAVAILABLE",
                    "message": str(error),
                })
                continue
            request = str(state.get("request") or task.get("request") or "")
            conversation_id = str(state.get("conversation_id") or "")
            initial_messages = state.get("initial_messages") if isinstance(state.get("initial_messages"), list) else []
            runner = AutonomousCdslGenerationRunner(self.settings, self.store, self._complete)

            async def consume(
                *, task_id: str = task_id, request: str = request, conversation_id: str = conversation_id,
                provider: ProviderConfig = provider, model: ProviderModel = model,
                initial_messages: list[dict[str, Any]] = initial_messages, runner: AutonomousCdslGenerationRunner = runner,
            ) -> None:
                try:
                    async for _name, _payload in runner.run(
                        task_id=task_id, request=request, conversation_id=conversation_id, provider=provider,
                        model=model, initial_messages=initial_messages, already_started=True,
                    ):
                        pass
                finally:
                    self._autonomous_runs.pop(task_id, None)

            self._autonomous_runs[task_id] = asyncio.create_task(consume(), name=f"resume-autonomous-cdsl-{task_id}")

    async def stream(
        self,
        messages: list[ChatMessage],
        conversation_id: str | None,
        selected_task_id: str | None,
        provider_id: str | None = None,
        model_id: str | None = None,
        viewer_context: list[dict[str, Any]] | None = None,
    ) -> AsyncIterator[bytes]:
        del viewer_context  # Viewer topology remains frozen while a run executes.
        latest_user = next((message for message in reversed(messages) if message.role == "user"), None)
        if latest_user is None:
            yield event("cad_error", {"stage": "request", "message": "A user message is required."})
            yield event("done", {})
            return
        user_text = text_from_message(latest_user)
        if not user_text:
            yield event("cad_error", {"stage": "request", "message": "A non-empty user request is required."})
            yield event("done", {})
            return
        conversation = self.store.ensure_conversation(conversation_id)
        task_id = str(selected_task_id or conversation.get("current_task_id") or "")
        current_task = self.store.read_task(task_id) if task_id else None
        if task_id and current_task is None:
            yield event("cad_error", {"stage": "request", "message": "The selected CAD task no longer exists."})
            yield event("done", {})
            return
        if current_task and str(current_task.get("lifecycle") or "") == "running":
            yield event("cad_error", {"stage": "request", "message": "该 CAD 任务正在生成，完成或失败前不能继续对话。"})
            yield event("done", {})
            return
        try:
            provider, model = self.settings.resolve_model(provider_id, model_id)
        except ValueError as error:
            yield event("cad_error", {"stage": "configuration", "message": str(error)})
            yield event("done", {})
            return
        # This is a fail-closed delivery gate, not a per-checkpoint cost.  A
        # model must never spend a long authoring run only to discover at final
        # publication that independent visual review cannot run.
        try:
            self.settings.resolve_independent_review_model(provider, model)
            renderer_ready, renderer_detail = renderer_status()
            if not renderer_ready:
                raise ValueError(renderer_detail)
        except ValueError as error:
            yield event("cad_error", {"stage": "configuration", "message": f"最终视觉复核不可用：{error}"})
            yield event("done", {})
            return
        try:
            attachment_content = self._attachment_message(conversation, model)
        except ValueError as error:
            yield event("cad_error", {"stage": "attachment", "message": str(error)})
            yield event("done", {})
            return
        if not task_id:
            created = self.store.ensure_task(None, user_text)
            task_id = str(created["task_id"])
            current_task = created
        elif str(current_task.get("schema_version") or "") != "2.0":
            yield event("cad_error", {"stage": "generation", "message": "AUTONOMOUS_PROTOCOL_OBSOLETE: this task belongs to the retired protocol. Start a new CAD task."})
            yield event("done", {})
            return
        else:
            # requirements.md is immutable for a task.  A post-terminal user
            # request therefore starts a clean autonomous run instead of
            # silently mixing two independent frozen specifications.
            created = self.store.ensure_task(None, user_text)
            task_id = str(created["task_id"])
            current_task = created

        conversation = self.store.append_conversation_message(
            conversation["conversation_id"], latest_user.model_dump(), task_id,
        )
        initial_messages: list[dict[str, Any]] = conversation_user_context(conversation)
        if attachment_content:
            initial_messages.append({"role": "user", "content": attachment_content})
        frozen_attachment_ids = [
            str(attachment.get("id") or "")
            for attachment in conversation.get("attachments") or ()
            if isinstance(attachment, dict) and str(attachment.get("id") or "")
        ]
        self.store.start_generation(task_id, request=user_text)
        queue: asyncio.Queue[tuple[str, dict[str, Any]] | None] = asyncio.Queue()
        runner = AutonomousCdslGenerationRunner(self.settings, self.store, self._complete)
        assistant_id = f"assistant_{secrets.token_hex(8)}"

        async def consume() -> None:
            assistant_parts: list[dict[str, Any]] = []
            terminal = ""
            try:
                async for name, payload in runner.run(
                    task_id=task_id, request=user_text, conversation_id=conversation["conversation_id"], provider=provider,
                    model=model, initial_messages=initial_messages, frozen_attachment_ids=frozen_attachment_ids, already_started=True,
                ):
                    if name == "cad_result":
                        assistant_parts.append({"type": "data-cad-result", "data": payload})
                    elif name == "agent_thinking":
                        visible = str(payload.get("message") or "")
                        if visible:
                            assistant_parts.append({"type": "text", "text": visible})
                    elif name == "task_terminal":
                        terminal = str(payload.get("lifecycle") or "")
                        if terminal == "failed":
                            assistant_parts.append({"type": "data-cad-error", "data": {"stage": "generation", "message": str(payload.get("message") or "CAD 自主生成失败。")}})
                    await queue.put((name, payload))
            except Exception as error:
                self.store.finish_generation(task_id, lifecycle="failed", failure={"schema_version": "cad.autonomous-failure.v1", "stage": "worker", "message": str(error)})
                terminal = "failed"
                payload = {"taskId": task_id, "lifecycle": "failed", "message": str(error)}
                assistant_parts.append({"type": "data-cad-error", "data": {"stage": "generation", "message": str(error)}})
                await queue.put(("task_terminal", payload))
            finally:
                if terminal == "completed" and not assistant_parts:
                    assistant_parts.append({"type": "text", "text": "CAD 模型已完成。"})
                self._persist_assistant(conversation["conversation_id"], assistant_id, assistant_parts, task_id)
                self._autonomous_runs.pop(task_id, None)
                await queue.put(None)

        self._autonomous_runs[task_id] = asyncio.create_task(consume(), name=f"autonomous-cdsl-{task_id}")
        while True:
            item = await queue.get()
            if item is None:
                break
            name, payload = item
            if name == "task_terminal" and str(payload.get("lifecycle") or "") == "failed":
                yield event("cad_error", {"stage": "generation", "message": str(payload.get("message") or "CAD 自主生成失败。")})
            elif name == "agent_thinking":
                yield event("text_delta", {"text": str(payload.get("message") or "")})
            else:
                yield event(name, payload)
        yield event("done", {})

    def _persist_assistant(self, conversation_id: str, assistant_id: str, parts: list[dict[str, Any]], task_id: str) -> None:
        self.store.append_conversation_message(
            conversation_id,
            {"id": assistant_id, "role": "assistant", "parts": parts},
            task_id or None,
        )

    async def _complete(
        self,
        messages: list[dict[str, Any]],
        tools: list[dict[str, Any]],
        provider: ProviderConfig,
        model: ProviderModel,
        required_tool_name: str | None = None,
    ) -> dict[str, Any]:
        tool_choice: str | dict[str, Any] = "auto"
        if required_tool_name:
            tool_choice = {"type": "function", "function": {"name": required_tool_name}}
        payload: dict[str, Any] = {
            "model": model.id,
            "messages": messages,
            "tools": tools,
            "tool_choice": tool_choice,
            "temperature": 0.1,
        }
        payload.update(provider.chat_completion_options)
        headers = {"Authorization": f"Bearer {provider.api_key}", "Content-Type": "application/json"}
        # A transport failure is independent of authoring quality.  Retry it
        # here, before the durable runner can classify the task as failed.
        # Keep the bound small: retries must not hide a broken provider or
        # leave a locked task waiting indefinitely.
        transport_error: Exception | None = None
        response: httpx.Response | None = None
        for attempt in range(3):
            try:
                async with httpx.AsyncClient(timeout=self.settings.llm_timeout_s) as client:
                    # ``httpx`` timeouts occasionally fail to interrupt a
                    # locally proxied socket.  The coroutine deadline is the
                    # final authority so a durable CAD task cannot remain
                    # locked forever waiting for one author response.
                    response = await asyncio.wait_for(
                        client.post(f"{provider.base_url}/chat/completions", headers=headers, json=payload),
                        timeout=self.settings.llm_timeout_s,
                    )
                    if response.status_code == 400 and "thinking mode does not support this tool_choice" in response.text.lower():
                        retry_payload = dict(payload)
                        retry_payload.pop("tool_choice", None)
                        response = await asyncio.wait_for(
                            client.post(f"{provider.base_url}/chat/completions", headers=headers, json=retry_payload),
                            timeout=self.settings.llm_timeout_s,
                        )
                break
            except (httpx.HTTPError, asyncio.TimeoutError) as error:
                transport_error = error
                if attempt == 2:
                    raise RuntimeError(f"LLM connection failed after 3 attempts: {error}") from error
                await asyncio.sleep(0.5 * (2**attempt))
        if response is None:
            raise RuntimeError(f"LLM connection failed after 3 attempts: {transport_error}")
        if response.status_code >= 400:
            raise RuntimeError(f"LLM request failed ({response.status_code}): {response.text[:800]}")
        body = response.json()
        if not isinstance(body, dict) or not isinstance(body.get("choices"), list) or not body["choices"]:
            raise RuntimeError("LLM response contains no completion choices")
        return body

    def _attachment_message(self, conversation: dict[str, Any], model: ProviderModel) -> list[dict[str, Any]] | str:
        attachments = conversation.get("attachments") or []
        if not attachments:
            return ""
        conversation_id = str(conversation.get("conversation_id") or "")
        if not conversation_id:
            raise ValueError("Conversation attachment has no conversation id")
        content: list[dict[str, Any]] = [{"type": "text", "text": "These frozen attachments are part of the CAD request."}]
        for attachment in attachments:
            if not isinstance(attachment, dict):
                continue
            if str(attachment.get("conversation_id") or "") != conversation_id:
                raise ValueError("Conversation attachment metadata is invalid")
            relative = str(attachment.get("path") or "")
            if not relative:
                raise ValueError("Conversation attachment is missing its artifact path")
            path = self.store.conversation_attachment_path(conversation_id, relative)
            if not path.is_file():
                raise ValueError(f"Conversation attachment is missing: {attachment.get('name') or attachment.get('id')}")
            if str(attachment.get("kind") or "") == "image":
                if not model.vision:
                    raise ValueError("The selected author model does not support images. Select a vision-capable model for image attachments.")
                mime = str(attachment.get("mime") or "image/png")
                encoded = base64.b64encode(path.read_bytes()).decode("ascii")
                content.append({"type": "image_url", "image_url": {"url": f"data:{mime};base64,{encoded}"}})
            else:
                extracted = str(attachment.get("extracted_path") or "")
                document_path = self.store.conversation_attachment_path(conversation_id, extracted) if extracted else path
                text = document_path.read_text(encoding="utf-8", errors="replace")[:24000] if document_path.is_file() else ""
                content.append({"type": "text", "text": f"Document {attachment.get('name') or path.name}:\n{text}"})
        return content