"""Govdoc Bridge — 执行编排器。

负责组织一次完整的 govdoc 审查执行链路：
  1. 解析输入文件 (input_resolver)
  2. 调用 govdoc_engine.pipeline 执行审查
  3. 收集并适配结果 (result_adapter)
  4. 持久化结果 (storage_adapter)
"""

from __future__ import annotations

from dataclasses import dataclass, field
from typing import Any

from fastapi_common.fastapi_common_logger import logger

from fastapi_modules.fastapi_leaudit.govdoc_bridge.input_resolver import InputResolver
from fastapi_modules.fastapi_leaudit.govdoc_bridge.result_adapter import ResultAdapter
from fastapi_modules.fastapi_leaudit.govdoc_bridge.storage_adapter import StorageAdapter

log = logger


@dataclass
class GovdocRunner:
    """Govdoc 引擎一次完整审查的执行编排器。

    当前为 Phase 1 骨架：
      - engine 集成点已标注
      - 可先跑通 run 创建 → 状态更新 → 结果持久化 的完整生命周期
      - 引擎执行部分待 govdoc_engine 迁入后接入
    """

    InputResolver: InputResolver = field(default_factory=InputResolver)
    Storage: StorageAdapter = field(default_factory=StorageAdapter)
    ResultAdapter: ResultAdapter = field(default_factory=ResultAdapter)

    async def Execute(
        self,
        DocumentId: int,
        RunId: int,
        RulesPath: str,
        TriggerUserId: int | None = None,
        Speed: str = "normal",
    ) -> dict[str, Any]:
        """执行一次完整的 govdoc 审查。

        Args:
            DocumentId: 文档 ID。
            RunId: 已创建的 govdoc_runs.id。
            TriggerUserId: 触发人。
            Speed: 执行速度 ('normal' / 'urgent')。

        Returns:
            执行摘要 dict。
        """
        log.info(f"[Govdoc] Starting execution: runId={RunId}, documentId={DocumentId}")

        # 1. 更新 run 状态 → processing
        await self.Storage.UpdateRunStatus(RunId, "processing", phase="parsing")
        await self.Storage.UpdateDocumentStatus(DocumentId, "processing", RunId)

        # 2. 解析输入文件
        inputPayload = await self.InputResolver.ResolveForDocument(DocumentId)
        log.info(f"[Govdoc] Input resolved: {inputPayload.fileName} → {inputPayload.localPath}")

        # 3. 调用 govdoc_engine 执行审查
        from fastapi_modules.fastapi_leaudit.govdoc_engine.pipeline import run as engine_run

        engineResult = await engine_run(
            file_path=inputPayload.localPath,
            rules_path=RulesPath,
            llm_client=None,  # 使用默认 LlmClient (从平台配置加载)
        )

        # 4. 适配引擎结果
        runSummary = self.ResultAdapter.AdaptRunSummary(engineResult)
        ruleResults = self.ResultAdapter.AdaptRuleResults(engineResult)
        entities = self.ResultAdapter.AdaptEntities(engineResult)
        structure = self.ResultAdapter.AdaptStructure(engineResult)
        outline = self.ResultAdapter.AdaptOutline(engineResult)
        artifacts = self.ResultAdapter.AdaptArtifacts(engineResult, RunId)

        # 5. 持久化结果
        await self.Storage.UpdateRunResult(RunId, runSummary)
        await self.Storage.SaveRuleResults(RunId, ruleResults)
        await self.Storage.SaveArtifacts(RunId, artifacts)

        # 6. 更新终态
        await self.Storage.UpdateRunStatus(RunId, "completed", phase="reporting")
        await self.Storage.UpdateDocumentStatus(DocumentId, "completed", RunId)

        log.info(f"[Govdoc] Execution completed: runId={RunId}")

        return {
            "runId": RunId,
            "documentId": DocumentId,
            "status": "completed",
            "ruleResultsCount": len(ruleResults),
            "structureCount": len(structure),
            "outlineCount": len(outline),
            "artifactCount": len(artifacts),
        }