"""
SSTC 唯一事实链路 API

覆盖模块：
- 项目概览/链路导航/风险预警
- 信号源
- 需求宪章（含对齐）
- 任务拆解与执行
- 发布验证
- 复盘沉淀
"""

from __future__ import annotations

from datetime import datetime, timezone
from typing import Any, Optional

from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException, Query
from pydantic import BaseModel
from sqlalchemy import and_, delete, select
from sqlalchemy.ext.asyncio import AsyncSession

from ..core.response import success_response
from ..database import get_db
from ..models import (
    AICallLog,
    AlignmentRecord,
    ProjectSignalLink,
    Signal,
    Task,
    TruthNode,
    User,
    UserProject,
)
from ..schemas.sstc import (
    AlignmentConfirmRequest,
    AlignmentStartRequest,
    CharterUpdateRequest,
    ReleaseCreateRequest,
    ReleaseStatusPatchRequest,
    ReviewArchiveRequest,
    ReviewCreateRequest,
    TaskStatusPatchRequest,
)
from ..services.llm import llm_service
from ..services.operation_log_service import log_operation
from ..services.auth import has_any_role
from ..services.skill_service import recommend_personnel
from ..services import skill_score_service
from ..services.sstc_service import (
    ALIGNED_STATUSES,
    DONE_STATUSES,
    RELEASE_VERIFIED_STATUSES,
    SSTCService,
)
from ..services import workload_service
from ..dependencies import get_current_user, require_project_member_or_manager
from ..utils.title import compact_title


router = APIRouter(tags=["sstc"])


def _parse_project_id(project_id: str) -> int:
    try:
        return int(project_id)
    except ValueError as exc:
        raise HTTPException(status_code=400, detail="Invalid project_id") from exc


def _parse_node_id(node_id: str, label: str) -> int:
    try:
        return int(node_id)
    except ValueError as exc:
        raise HTTPException(status_code=400, detail=f"Invalid {label}") from exc


def _as_dict(value: Any) -> dict:
    if isinstance(value, dict):
        return value
    if isinstance(value, str):
        import json
        try:
            parsed = json.loads(value)
            return parsed if isinstance(parsed, dict) else {"text": value}
        except (TypeError, ValueError):
            return {"text": value}
    return {}


def _parse_due_date(value: Optional[str]) -> Optional[datetime]:
    if not value:
        return None
    try:
        return datetime.fromisoformat(value.replace("Z", "+00:00")).replace(tzinfo=None)
    except ValueError as exc:
        raise HTTPException(status_code=400, detail="Invalid due_date") from exc


async def _ensure_project(
    svc: SSTCService,
    project_id: int,
):
    project = await svc.get_project(project_id)
    if not project:
        raise HTTPException(status_code=404, detail="Project not found")
    return project


async def _ensure_charter(
    db: AsyncSession,
    *,
    tenant_id: int,
    project_id: int,
    charter_id: int,
) -> TruthNode:
    result = await db.execute(
        select(TruthNode).where(
            and_(
                TruthNode.id == charter_id,
                TruthNode.project_id == project_id,
                TruthNode.tenant_id == tenant_id,
                TruthNode.node_type == "charter",
            )
        )
    )
    charter = result.scalar_one_or_none()
    if not charter:
        raise HTTPException(status_code=404, detail="Charter not found")
    return charter


async def _ensure_task(
    db: AsyncSession,
    *,
    tenant_id: int,
    project_id: int,
    task_id: int,
) -> Task:
    result = await db.execute(
        select(Task).where(
            and_(
                Task.id == task_id,
                Task.project_id == project_id,
                Task.tenant_id == tenant_id,
            )
        )
    )
    task = result.scalar_one_or_none()
    if not task:
        raise HTTPException(status_code=404, detail="Task not found")
    return task


async def _ensure_release(
    db: AsyncSession,
    *,
    tenant_id: int,
    project_id: int,
    release_node_id: int,
) -> TruthNode:
    result = await db.execute(
        select(TruthNode).where(
            and_(
                TruthNode.id == release_node_id,
                TruthNode.project_id == project_id,
                TruthNode.tenant_id == tenant_id,
                TruthNode.node_type == "release",
            )
        )
    )
    release_node = result.scalar_one_or_none()
    if not release_node:
        raise HTTPException(status_code=404, detail="Release plan not found")
    return release_node


def _assert_charter_aligned(charter: TruthNode) -> None:
    if (charter.status or "").lower() not in ALIGNED_STATUSES:
        raise HTTPException(
            status_code=409,
            detail="宪章未对齐，任务环节未解锁",
        )


def _is_manager(user: User) -> bool:
    return has_any_role(str(user.role or ""), ["BOSS", "ADMIN"])


def _require_manager(user: User) -> None:
    if not _is_manager(user):
        raise HTTPException(status_code=403, detail="仅项目负责人或管理员可执行该操作")


@router.get("/projects/{project_id}/sstc/overview")
async def get_board_overview(
    project_id: str,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    pid = _parse_project_id(project_id)
    svc = SSTCService(db, tenant_id=int(current_user.tenant_id))
    await _ensure_project(svc, pid)
    overview = await svc.build_overview(pid)
    stages = await svc.build_stages(pid)
    risks = await svc.build_risks(pid)
    return success_response(
        {
            "overview": overview,
            "stages": stages,
            "risks": risks,
        }
    )


@router.get("/projects/{project_id}/sstc/stages")
async def get_stages(
    project_id: str,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    pid = _parse_project_id(project_id)
    svc = SSTCService(db, tenant_id=int(current_user.tenant_id))
    await _ensure_project(svc, pid)
    return success_response(await svc.build_stages(pid))


@router.get("/projects/{project_id}/sstc/risks")
async def get_risks(
    project_id: str,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    pid = _parse_project_id(project_id)
    svc = SSTCService(db, tenant_id=int(current_user.tenant_id))
    await _ensure_project(svc, pid)
    return success_response(await svc.build_risks(pid))


@router.get("/projects/{project_id}/sstc-chain")
async def get_sstc_chain(
    project_id: str,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    pid = _parse_project_id(project_id)
    svc = SSTCService(db, tenant_id=int(current_user.tenant_id))
    await _ensure_project(svc, pid)
    return success_response(await svc.build_chain(pid))


@router.get("/projects/{project_id}/signals")
async def list_signals(
    project_id: str,
    status: Optional[str] = Query(default=None, description="pending/linked/archived"),
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    pid = _parse_project_id(project_id)
    svc = SSTCService(db, tenant_id=int(current_user.tenant_id))
    await _ensure_project(svc, pid)
    signals = await svc.get_signals(pid)
    charters = await svc.get_charters(pid)
    linked_signal_ids: set[int] = set()
    for c in charters:
        payload = _as_dict(c.content)
        for sid in payload.get("signal_ids", []):
            if isinstance(sid, int):
                linked_signal_ids.add(sid)
    rows = []
    for s in signals:
        row_status = "pending"
        if int(s.id) in linked_signal_ids:
            row_status = "linked"
        if bool(s.processed):
            row_status = "archived"
        if status and row_status != status:
            continue
        rows.append(
            {
                "id": str(s.id),
                "title": (s.content or "")[:80] or "未命名信号",
                "content": s.content,
                "priority": s.priority,
                "signal_type": s.source or "other",
                "source": s.source,
                "status": row_status,
                "created_at": s.created_at.isoformat() if s.created_at else None,
            }
        )
    return success_response(rows)


@router.post("/projects/{project_id}/signals/{signal_id}/archive")
async def archive_signal(
    project_id: str,
    signal_id: str,
    permission_user: User = Depends(require_project_member_or_manager),
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    _ = permission_user
    pid = _parse_project_id(project_id)
    sid = _parse_node_id(signal_id, "signal_id")
    svc = SSTCService(db, tenant_id=int(current_user.tenant_id))
    await _ensure_project(svc, pid)
    result = await db.execute(
        select(Signal).where(
            and_(Signal.id == sid, Signal.tenant_id == int(current_user.tenant_id))
        )
    )
    signal = result.scalar_one_or_none()
    if not signal:
        raise HTTPException(status_code=404, detail="Signal not found")
    before = {"processed": signal.processed}
    signal.processed = True
    await log_operation(
        db,
        tenant_id=int(current_user.tenant_id),
        user_id=int(current_user.id),
        project_id=pid,
        entity_type="signal",
        entity_id=str(sid),
        action="archive",
        before_data=before,
        after_data={"processed": True},
    )
    await db.commit()
    return success_response({"id": str(signal.id), "status": "archived"})


class CharterCreateRequest(BaseModel):
    title: str
    content: dict[str, Any] | None = None
    signal_ids: list[int]


@router.get("/projects/{project_id}/charters")
async def list_charters(
    project_id: str,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    pid = _parse_project_id(project_id)
    svc = SSTCService(db, tenant_id=int(current_user.tenant_id))
    await _ensure_project(svc, pid)
    charters = await svc.get_charters(pid)
    payload = [
        {
            "id": str(c.id),
            "title": c.title,
            "content": _as_dict(c.content),
            "signal_ids": _as_dict(c.content).get("signal_ids", []),
            "status": c.status,
            "version": c.version,
            "parent_id": str(c.parent_id) if c.parent_id else None,
            "created_at": c.created_at.isoformat() if c.created_at else None,
        }
        for c in charters
    ]
    return success_response(payload)


@router.post("/projects/{project_id}/charters")
async def create_charter(
    project_id: str,
    body: CharterCreateRequest,
    permission_user: User = Depends(require_project_member_or_manager),
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    _ = permission_user
    _require_manager(current_user)
    if not body.signal_ids:
        raise HTTPException(status_code=400, detail="宪章必须关联至少一个信号")
    pid = _parse_project_id(project_id)
    tenant_id = int(current_user.tenant_id)
    svc = SSTCService(db, tenant_id=tenant_id)
    await _ensure_project(svc, pid)

    link_result = await db.execute(
        select(ProjectSignalLink.signal_id).where(
            and_(
                ProjectSignalLink.project_id == pid,
                ProjectSignalLink.signal_id.in_(body.signal_ids),
                ProjectSignalLink.tenant_id == tenant_id,
            )
        )
    )
    valid_signal_ids = {int(v) for v in link_result.scalars().all()}
    if set(body.signal_ids) - valid_signal_ids:
        raise HTTPException(status_code=400, detail="部分信号未关联到当前项目")

    content = dict(body.content or {})
    content["signal_ids"] = sorted(set(body.signal_ids))
    charter = TruthNode(
        node_type="charter",
        parent_id=None,
        project_id=pid,
        created_by=int(current_user.id),
        title=compact_title(body.title, max_len=24),
        content=content,
        version=1,
        status="draft",
        tenant_id=tenant_id,
    )
    db.add(charter)
    await log_operation(
        db,
        tenant_id=tenant_id,
        user_id=int(current_user.id),
        project_id=pid,
        entity_type="charter",
        entity_id="new",
        action="create",
        after_data={"title": charter.title, "signal_ids": content["signal_ids"]},
    )
    await db.commit()
    await db.refresh(charter)
    return success_response(
        {
            "id": str(charter.id),
            "title": charter.title,
            "content": _as_dict(charter.content),
            "signal_ids": _as_dict(charter.content).get("signal_ids", []),
            "status": charter.status,
            "version": charter.version,
        }
    )


@router.get("/projects/{project_id}/charters/{charter_id}")
async def get_charter_detail(
    project_id: str,
    charter_id: str,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    pid = _parse_project_id(project_id)
    cid = _parse_node_id(charter_id, "charter_id")
    tenant_id = int(current_user.tenant_id)
    svc = SSTCService(db, tenant_id=tenant_id)
    await _ensure_project(svc, pid)
    charter = await _ensure_charter(db, tenant_id=tenant_id, project_id=pid, charter_id=cid)

    content = _as_dict(charter.content)
    signal_ids = [sid for sid in content.get("signal_ids", []) if isinstance(sid, int)]
    signal_rows = []
    if signal_ids:
        signal_result = await db.execute(
            select(Signal).where(
                and_(Signal.id.in_(signal_ids), Signal.tenant_id == tenant_id)
            )
        )
        signal_rows = list(signal_result.scalars().all())

    task_result = await db.execute(
        select(Task).where(
            and_(
                Task.truth_node_id == cid,
                Task.project_id == pid,
                Task.tenant_id == tenant_id,
            )
        )
    )
    tasks = list(task_result.scalars().all())

    align_result = await db.execute(
        select(AlignmentRecord).where(
            and_(
                AlignmentRecord.truth_node_id == cid,
                AlignmentRecord.tenant_id == tenant_id,
            )
        )
    )
    alignments = list(align_result.scalars().all())

    return success_response(
        {
            "id": str(charter.id),
            "title": charter.title,
            "content": content,
            "signal_ids": signal_ids,
            "signals": [
                {
                    "id": str(s.id),
                    "source": s.source,
                    "content": s.content,
                    "priority": s.priority,
                    "impact_score": s.impact_score,
                }
                for s in signal_rows
            ],
            "tasks": [
                {
                    "id": str(t.id),
                    "title": t.title,
                    "description": t.description,
                    "status": t.status,
                    "priority": t.priority,
                    "estimated_hours": float(t.estimated_hours) if t.estimated_hours else None,
                    "assignee_id": str(t.assignee_id) if t.assignee_id else None,
                    "due_date": t.due_date.isoformat() if t.due_date else None,
                }
                for t in tasks
            ],
            "alignment_records": [
                {
                    "user_id": str(r.user_id),
                    "score": r.alignment_score,
                    "confirmed": bool(r.is_confirmed),
                    "comments": r.comments,
                }
                for r in alignments
            ],
            "status": charter.status,
            "version": charter.version,
        }
    )


@router.patch("/projects/{project_id}/charters/{charter_id}")
async def update_charter(
    project_id: str,
    charter_id: str,
    body: CharterUpdateRequest,
    permission_user: User = Depends(require_project_member_or_manager),
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    _ = permission_user
    _require_manager(current_user)
    pid = _parse_project_id(project_id)
    cid = _parse_node_id(charter_id, "charter_id")
    tenant_id = int(current_user.tenant_id)
    await _ensure_project(SSTCService(db, tenant_id=tenant_id), pid)
    charter = await _ensure_charter(db, tenant_id=tenant_id, project_id=pid, charter_id=cid)

    before = {
        "title": charter.title,
        "content": _as_dict(charter.content),
        "version": charter.version,
        "status": charter.status,
    }
    aligned = (charter.status or "").lower() in ALIGNED_STATUSES
    if aligned and body.force_new_version:
        new_node = TruthNode(
            node_type="charter",
            parent_id=int(charter.id),
            project_id=pid,
            created_by=int(current_user.id),
            title=compact_title((body.title or charter.title), max_len=24),
            content=body.content if body.content is not None else _as_dict(charter.content),
            version=int(charter.version or 1) + 1,
            status="draft",
            tenant_id=tenant_id,
        )
        db.add(new_node)
        await log_operation(
            db,
            tenant_id=tenant_id,
            user_id=int(current_user.id),
            project_id=pid,
            entity_type="charter",
            entity_id=str(charter.id),
            action="new_version",
            before_data=before,
            after_data={"new_charter_id": "pending"},
        )
        await db.commit()
        await db.refresh(new_node)
        return success_response(
            {
                "id": str(new_node.id),
                "version": new_node.version,
                "status": new_node.status,
                "title": new_node.title,
                "content": _as_dict(new_node.content),
                "new_version_created": True,
            }
        )

    if body.title is not None:
        charter.title = compact_title(body.title, max_len=24)
    if body.content is not None:
        charter.content = body.content
    charter.status = "draft"
    await log_operation(
        db,
        tenant_id=tenant_id,
        user_id=int(current_user.id),
        project_id=pid,
        entity_type="charter",
        entity_id=str(charter.id),
        action="update",
        before_data=before,
        after_data={
            "title": charter.title,
            "content": _as_dict(charter.content),
            "version": charter.version,
            "status": charter.status,
        },
    )
    await db.commit()
    await db.refresh(charter)
    return success_response(
        {
            "id": str(charter.id),
            "title": charter.title,
            "content": _as_dict(charter.content),
            "status": charter.status,
            "version": charter.version,
            "new_version_created": False,
        }
    )


@router.post("/projects/{project_id}/charters/{charter_id}/alignment/start")
async def start_alignment(
    project_id: str,
    charter_id: str,
    body: AlignmentStartRequest,
    permission_user: User = Depends(require_project_member_or_manager),
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    _ = permission_user
    pid = _parse_project_id(project_id)
    cid = _parse_node_id(charter_id, "charter_id")
    tenant_id = int(current_user.tenant_id)
    await _ensure_project(SSTCService(db, tenant_id=tenant_id), pid)
    charter = await _ensure_charter(db, tenant_id=tenant_id, project_id=pid, charter_id=cid)
    before = {"status": charter.status}
    charter.status = "aligning"
    await log_operation(
        db,
        tenant_id=tenant_id,
        user_id=int(current_user.id),
        project_id=pid,
        entity_type="charter",
        entity_id=str(cid),
        action="start_alignment",
        before_data=before,
        after_data={"status": charter.status, "note": body.note},
    )
    await db.commit()
    return success_response({"id": str(cid), "status": charter.status})


@router.post("/projects/{project_id}/charters/{charter_id}/alignment/confirm")
async def confirm_alignment(
    project_id: str,
    charter_id: str,
    body: AlignmentConfirmRequest,
    permission_user: User = Depends(require_project_member_or_manager),
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    _ = permission_user
    pid = _parse_project_id(project_id)
    cid = _parse_node_id(charter_id, "charter_id")
    tenant_id = int(current_user.tenant_id)
    svc = SSTCService(db, tenant_id=tenant_id)
    await _ensure_project(svc, pid)
    charter = await _ensure_charter(db, tenant_id=tenant_id, project_id=pid, charter_id=cid)

    row_result = await db.execute(
        select(AlignmentRecord).where(
            and_(
                AlignmentRecord.truth_node_id == cid,
                AlignmentRecord.user_id == int(current_user.id),
                AlignmentRecord.tenant_id == tenant_id,
            )
        )
    )
    row = row_result.scalar_one_or_none()
    if row is None:
        row = AlignmentRecord(
            truth_node_id=cid,
            user_id=int(current_user.id),
            alignment_score=body.score,
            is_confirmed=body.confirmed,
            comments=body.comments,
            tenant_id=tenant_id,
        )
        db.add(row)
    else:
        row.alignment_score = body.score
        row.is_confirmed = body.confirmed
        row.comments = body.comments

    member_ids = await svc.get_project_member_ids(pid)
    confirmed_map: set[int] = set()
    rows_result = await db.execute(
        select(AlignmentRecord).where(
            and_(
                AlignmentRecord.truth_node_id == cid,
                AlignmentRecord.tenant_id == tenant_id,
                AlignmentRecord.is_confirmed.is_(True),
            )
        )
    )
    for r in rows_result.scalars().all():
        confirmed_map.add(int(r.user_id))
    all_confirmed = set(member_ids).issubset(confirmed_map) if member_ids else False
    if all_confirmed:
        charter.status = "aligned"
    elif (charter.status or "").lower() not in {"aligned"}:
        charter.status = "aligning"

    await log_operation(
        db,
        tenant_id=tenant_id,
        user_id=int(current_user.id),
        project_id=pid,
        entity_type="alignment",
        entity_id=f"{cid}:{current_user.id}",
        action="confirm",
        after_data={
            "score": body.score,
            "confirmed": body.confirmed,
            "all_confirmed": all_confirmed,
            "charter_status": charter.status,
        },
    )
    await db.commit()
    return success_response(
        {
            "charter_id": str(cid),
            "charter_status": charter.status,
            "all_confirmed": all_confirmed,
            "confirmed_count": len(confirmed_map),
            "member_count": len(member_ids),
        }
    )


class TaskCreateRequest(BaseModel):
    title: str
    description: Optional[str] = None
    required_skill_tag_ids: Optional[list[int]] = None
    priority: str = "medium"
    estimated_hours: Optional[float] = None
    due_date: Optional[str] = None


class TaskUpdateRequest(BaseModel):
    title: Optional[str] = None
    description: Optional[str] = None
    assignee_id: Optional[int] = None
    required_skill_tag_ids: Optional[list[int]] = None
    priority: Optional[str] = None
    estimated_hours: Optional[float] = None
    due_date: Optional[str] = None


@router.post("/projects/{project_id}/charters/{charter_id}/tasks")
async def create_task(
    project_id: str,
    charter_id: str,
    body: TaskCreateRequest,
    permission_user: User = Depends(require_project_member_or_manager),
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    _ = permission_user
    _require_manager(current_user)
    pid = _parse_project_id(project_id)
    cid = _parse_node_id(charter_id, "charter_id")
    tenant_id = int(current_user.tenant_id)
    await _ensure_project(SSTCService(db, tenant_id=tenant_id), pid)
    charter = await _ensure_charter(db, tenant_id=tenant_id, project_id=pid, charter_id=cid)
    _assert_charter_aligned(charter)

    due_date = _parse_due_date(body.due_date)

    task = Task(
        tenant_id=tenant_id,
        truth_node_id=cid,
        project_id=pid,
        assignee_id=None,
        title=compact_title(body.title, max_len=32),
        description=body.description,
        required_skill_tag_ids=body.required_skill_tag_ids or [],
        status="todo",
        priority=body.priority,
        estimated_hours=body.estimated_hours,
        due_date=due_date,
    )
    db.add(task)
    await log_operation(
        db,
        tenant_id=tenant_id,
        user_id=int(current_user.id),
        project_id=pid,
        entity_type="task",
        entity_id="new",
        action="create",
        after_data={
            "title": task.title,
            "truth_node_id": cid,
            "priority": body.priority,
        },
    )
    await db.commit()
    await db.refresh(task)
    return success_response(
        {
            "id": str(task.id),
            "title": task.title,
            "status": task.status,
            "priority": task.priority,
            "charter_id": str(cid),
        }
    )


@router.post("/projects/{project_id}/charters/{charter_id}/tasks/ai-breakdown")
async def ai_breakdown_tasks(
    project_id: str,
    charter_id: str,
    permission_user: User = Depends(require_project_member_or_manager),
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    _ = permission_user
    _require_manager(current_user)
    pid = _parse_project_id(project_id)
    cid = _parse_node_id(charter_id, "charter_id")
    tenant_id = int(current_user.tenant_id)
    await _ensure_project(SSTCService(db, tenant_id=tenant_id), pid)
    charter = await _ensure_charter(db, tenant_id=tenant_id, project_id=pid, charter_id=cid)
    _assert_charter_aligned(charter)

    prompt = f"""请基于以下需求宪章拆解 5-8 条任务，返回 JSON 数组：
[
  {{"task_name":"", "type":"backend/frontend/ai/devops", "estimated_hours": 4.0, "priority":"P0/P1/P2"}}
]

宪章标题：{charter.title}
宪章内容：{_as_dict(charter.content)}
"""
    try:
        rows = await llm_service.generate_task_breakdown_async(
            prompt,
            db=db,
            tenant_id=tenant_id,
            project_id=pid,
        )
    except RuntimeError as exc:
        raise HTTPException(status_code=403, detail=str(exc)) from exc
    except Exception as exc:
        raise HTTPException(status_code=500, detail=f"AI 拆解失败: {exc}") from exc

    created = []
    prompt_tokens = max(len(prompt) // 4, 1)
    completion_tokens = 0
    for item in rows or []:
        title = compact_title((item.get("task_name") or item.get("title") or ""), max_len=32)
        if not title:
            continue
        priority = str(item.get("priority") or "P1").lower()
        mapped_priority = "high" if priority == "p0" else "medium" if priority == "p1" else "low"
        task = Task(
            tenant_id=tenant_id,
            truth_node_id=cid,
            project_id=pid,
            assignee_id=None,
            title=title,
            description=item.get("description"),
            required_skill_tag_ids=[],
            status="todo",
            priority=mapped_priority,
            estimated_hours=float(item.get("estimated_hours") or 0) or None,
        )
        db.add(task)
        created.append(task)
        completion_tokens += max(len(title) // 2, 1)

    db.add(
        AICallLog(
            tenant_id=tenant_id,
            user_id=int(current_user.id),
            function_name="sstc_ai_breakdown",
            prompt=prompt,
            response=f"created_count={len(created)}",
            tokens_used=prompt_tokens + completion_tokens,
            cost=((prompt_tokens * 0.00015 + completion_tokens * 0.0006) / 1000),
            status="success",
        )
    )
    await log_operation(
        db,
        tenant_id=tenant_id,
        user_id=int(current_user.id),
        project_id=pid,
        entity_type="task",
        entity_id=str(cid),
        action="ai_breakdown",
        after_data={"created_count": len(created)},
    )
    await db.commit()
    return success_response(
        {
            "created_count": len(created),
            "items": [
                {"id": str(t.id), "title": t.title, "priority": t.priority, "status": t.status}
                for t in created
            ],
        }
    )


@router.get("/projects/{project_id}/tasks/board")
async def get_task_board(
    project_id: str,
    assignee_id: Optional[int] = Query(default=None),
    priority: Optional[str] = Query(default=None),
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    pid = _parse_project_id(project_id)
    tenant_id = int(current_user.tenant_id)
    await _ensure_project(SSTCService(db, tenant_id=tenant_id), pid)
    result = await db.execute(
        select(Task).where(
            and_(
                Task.project_id == pid,
                Task.tenant_id == tenant_id,
            )
        )
    )
    tasks = list(result.scalars().all())
    if assignee_id is not None:
        tasks = [t for t in tasks if t.assignee_id == assignee_id]
    if priority:
        tasks = [t for t in tasks if (t.priority or "").lower() == priority.lower()]

    rows = []
    for t in tasks:
        risk_count = 0
        if (t.status or "").lower() == "blocked":
            risk_count += 1
        if t.due_date and t.due_date < datetime.now(timezone.utc).replace(tzinfo=None) and (t.status or "").lower() not in DONE_STATUSES:
            risk_count += 1
        rows.append(
            {
                "id": str(t.id),
                "title": t.title,
                "description": t.description,
                "status": t.status,
                "priority": t.priority,
                "assignee_id": str(t.assignee_id) if t.assignee_id else None,
                "due_date": t.due_date.isoformat() if t.due_date else None,
                "estimated_hours": float(t.estimated_hours) if t.estimated_hours else None,
                "risk_count": risk_count,
                "truth_node_id": str(t.truth_node_id),
            }
        )
    return success_response(rows)


@router.patch("/projects/{project_id}/tasks/{task_id}/status")
async def patch_task_status(
    project_id: str,
    task_id: str,
    body: TaskStatusPatchRequest,
    background_tasks: BackgroundTasks,
    permission_user: User = Depends(require_project_member_or_manager),
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    _ = permission_user
    pid = _parse_project_id(project_id)
    tid = _parse_node_id(task_id, "task_id")
    tenant_id = int(current_user.tenant_id)
    await _ensure_project(SSTCService(db, tenant_id=tenant_id), pid)
    task = await _ensure_task(db, tenant_id=tenant_id, project_id=pid, task_id=tid)
    if not _is_manager(current_user) and int(task.assignee_id or 0) != int(current_user.id):
        raise HTTPException(status_code=403, detail="仅负责人或任务执行人可更新状态")

    before_status = (task.status or "").lower()
    before = {"status": task.status}
    task.status = body.status
    if body.status in DONE_STATUSES:
        task.completed_at = datetime.now(timezone.utc).replace(tzinfo=None)
    await log_operation(
        db,
        tenant_id=tenant_id,
        user_id=int(current_user.id),
        project_id=pid,
        entity_type="task",
        entity_id=str(tid),
        action="status_change",
        before_data=before,
        after_data={"status": body.status},
    )
    if task.assignee_id:
        await workload_service.refresh_user_assigned_hours_from_tasks(
            db,
            tenant_id=tenant_id,
            user_id=int(task.assignee_id),
        )
    else:
        await db.commit()
    became_done = (body.status or "").lower() in DONE_STATUSES and before_status not in DONE_STATUSES
    if became_done and task.assignee_id:
        background_tasks.add_task(
            skill_score_service.process_task_completion,
            task_id=int(task.id),
            tenant_id=tenant_id,
            operator_user_id=int(current_user.id),
        )

    return success_response({"id": str(task.id), "status": task.status})


@router.patch("/projects/{project_id}/tasks/{task_id}")
async def patch_task(
    project_id: str,
    task_id: str,
    body: TaskUpdateRequest,
    permission_user: User = Depends(require_project_member_or_manager),
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    _ = permission_user
    _require_manager(current_user)
    pid = _parse_project_id(project_id)
    tid = _parse_node_id(task_id, "task_id")
    tenant_id = int(current_user.tenant_id)
    await _ensure_project(SSTCService(db, tenant_id=tenant_id), pid)
    task = await _ensure_task(db, tenant_id=tenant_id, project_id=pid, task_id=tid)

    before = {
        "title": task.title,
        "description": task.description,
        "assignee_id": task.assignee_id,
        "priority": task.priority,
        "estimated_hours": float(task.estimated_hours) if task.estimated_hours is not None else None,
        "due_date": task.due_date.isoformat() if task.due_date else None,
    }

    old_assignee_id = int(task.assignee_id) if task.assignee_id else None
    if body.title is not None:
        task.title = compact_title(body.title, max_len=32)
    if body.description is not None:
        task.description = body.description
    if body.assignee_id is not None:
        task.assignee_id = body.assignee_id
    if body.required_skill_tag_ids is not None:
        task.required_skill_tag_ids = body.required_skill_tag_ids
    if body.priority is not None:
        task.priority = body.priority
    if body.estimated_hours is not None:
        task.estimated_hours = body.estimated_hours
    if body.due_date is not None:
        task.due_date = _parse_due_date(body.due_date)

    await log_operation(
        db,
        tenant_id=tenant_id,
        user_id=int(current_user.id),
        project_id=pid,
        entity_type="task",
        entity_id=str(tid),
        action="update",
        before_data=before,
        after_data={
            "title": task.title,
            "description": task.description,
            "assignee_id": task.assignee_id,
            "priority": task.priority,
            "estimated_hours": float(task.estimated_hours) if task.estimated_hours is not None else None,
            "due_date": task.due_date.isoformat() if task.due_date else None,
        },
    )

    touched_user_ids: set[int] = set()
    if old_assignee_id:
        touched_user_ids.add(old_assignee_id)
    if task.assignee_id:
        touched_user_ids.add(int(task.assignee_id))

    if touched_user_ids:
        for uid in touched_user_ids:
            await workload_service.refresh_user_assigned_hours_from_tasks(
                db,
                tenant_id=tenant_id,
                user_id=uid,
            )
    else:
        await db.commit()

    return success_response({"id": str(task.id), "status": task.status})


@router.delete("/projects/{project_id}/tasks/{task_id}")
async def delete_task(
    project_id: str,
    task_id: str,
    permission_user: User = Depends(require_project_member_or_manager),
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    _ = permission_user
    _require_manager(current_user)
    pid = _parse_project_id(project_id)
    tid = _parse_node_id(task_id, "task_id")
    tenant_id = int(current_user.tenant_id)
    await _ensure_project(SSTCService(db, tenant_id=tenant_id), pid)
    task = await _ensure_task(db, tenant_id=tenant_id, project_id=pid, task_id=tid)
    assignee_id = int(task.assignee_id) if task.assignee_id else None

    await log_operation(
        db,
        tenant_id=tenant_id,
        user_id=int(current_user.id),
        project_id=pid,
        entity_type="task",
        entity_id=str(tid),
        action="delete",
        before_data={
            "assignee_id": assignee_id,
            "estimated_hours": float(task.estimated_hours) if task.estimated_hours else None,
            "status": task.status,
        },
    )
    await db.execute(
        delete(Task).where(
            and_(
                Task.id == tid,
                Task.project_id == pid,
                Task.tenant_id == tenant_id,
            )
        )
    )

    if assignee_id:
        await workload_service.refresh_user_assigned_hours_from_tasks(
            db,
            tenant_id=tenant_id,
            user_id=assignee_id,
        )
    else:
        await db.commit()

    return success_response({"id": str(tid), "deleted": True})


@router.post("/projects/{project_id}/tasks/{task_id}/recommend-assignee")
async def recommend_assignee_for_task(
    project_id: str,
    task_id: str,
    permission_user: User = Depends(require_project_member_or_manager),
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    _ = permission_user
    pid = _parse_project_id(project_id)
    tid = _parse_node_id(task_id, "task_id")
    tenant_id = int(current_user.tenant_id)
    await _ensure_project(SSTCService(db, tenant_id=tenant_id), pid)
    task = await _ensure_task(db, tenant_id=tenant_id, project_id=pid, task_id=tid)

    required_skills = [str(x) for x in (task.required_skill_tag_ids or [])]
    recommendations = await recommend_personnel(
        db=db,
        tenant_id=tenant_id,
        required_skills=required_skills,
        task_description=task.description or task.title,
        task_id=str(task.id),
        limit=5,
    )

    project_user_ids_result = await db.execute(
        select(UserProject.user_id).where(
            and_(
                UserProject.tenant_id == tenant_id,
                UserProject.project_id == pid,
            )
        )
    )
    project_user_ids = {int(uid) for uid in project_user_ids_result.scalars().all()}

    active_users_result = await db.execute(
        select(User.id).where(
            and_(
                User.tenant_id == tenant_id,
                User.status == "active",
                User.is_active.is_(True),
            )
        )
    )
    active_user_ids = {int(uid) for uid in active_users_result.scalars().all()}

    filtered = []
    for item in recommendations.get("recommendations", []):
        try:
            uid = int(item.get("user_id"))
        except (TypeError, ValueError):
            continue
        if uid in project_user_ids and uid in active_user_ids:
            filtered.append(item)

    recommendations["recommendations"] = filtered
    recommendations["total_count"] = len(filtered)
    return success_response(recommendations)


@router.post("/projects/{project_id}/tasks/optimize-workload")
async def optimize_task_workload(
    project_id: str,
    permission_user: User = Depends(require_project_member_or_manager),
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    _ = permission_user
    _require_manager(current_user)
    pid = _parse_project_id(project_id)
    tenant_id = int(current_user.tenant_id)
    await _ensure_project(SSTCService(db, tenant_id=tenant_id), pid)
    task_result = await db.execute(
        select(Task).where(
            and_(Task.project_id == pid, Task.tenant_id == tenant_id, Task.status.in_(["todo", "in_progress"]))
        )
    )
    tasks = list(task_result.scalars().all())
    wl_result = await db.execute(
        select(User.id, User.workload)
        .join(
            UserProject,
            and_(
                UserProject.user_id == User.id,
                UserProject.tenant_id == tenant_id,
                UserProject.project_id == pid,
            ),
        )
        .where(
            and_(
                User.tenant_id == tenant_id,
                User.status == "active",
                User.is_active.is_(True),
            )
        )
    )
    members = [{"id": int(uid), "workload": int(wl or 0)} for uid, wl in wl_result.all()]
    if not members:
        return success_response({"updated": 0, "message": "no active users"})
    members.sort(key=lambda x: x["workload"])

    updated = 0
    touched_user_ids: set[int] = set()
    for task in tasks:
        if task.assignee_id:
            continue
        picked = members[0]
        task.assignee_id = int(picked["id"])
        touched_user_ids.add(int(picked["id"]))
        picked["workload"] += int(float(task.estimated_hours or 1) * 2)
        members.sort(key=lambda x: x["workload"])
        updated += 1

    await log_operation(
        db,
        tenant_id=tenant_id,
        user_id=int(current_user.id),
        project_id=pid,
        entity_type="task",
        entity_id=str(pid),
        action="optimize_workload",
        after_data={"updated": updated},
    )
    if touched_user_ids:
        for uid in touched_user_ids:
            await workload_service.refresh_user_assigned_hours_from_tasks(
                db,
                tenant_id=tenant_id,
                user_id=uid,
            )
    else:
        await db.commit()
    return success_response({"updated": updated})


@router.get("/projects/{project_id}/releases")
async def list_releases(
    project_id: str,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    pid = _parse_project_id(project_id)
    svc = SSTCService(db, tenant_id=int(current_user.tenant_id))
    await _ensure_project(svc, pid)
    releases = await svc.get_releases(pid)
    return success_response(
        [
            {
                "id": str(r.id),
                "title": r.title,
                "status": r.status,
                "content": _as_dict(r.content),
                "version": r.version,
                "created_at": r.created_at.isoformat() if r.created_at else None,
            }
            for r in releases
        ]
    )


@router.post("/projects/{project_id}/releases")
async def create_release_plan(
    project_id: str,
    body: ReleaseCreateRequest,
    permission_user: User = Depends(require_project_member_or_manager),
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    _ = permission_user
    _require_manager(current_user)
    pid = _parse_project_id(project_id)
    tenant_id = int(current_user.tenant_id)
    svc = SSTCService(db, tenant_id=tenant_id)
    await _ensure_project(svc, pid)

    charter = await _ensure_charter(
        db,
        tenant_id=tenant_id,
        project_id=pid,
        charter_id=int(body.charter_id),
    )

    if not body.task_ids:
        raise HTTPException(status_code=400, detail="发布计划必须绑定至少一个任务")

    task_result = await db.execute(
        select(Task).where(
            and_(
                Task.id.in_(body.task_ids),
                Task.project_id == pid,
                Task.tenant_id == tenant_id,
            )
        )
    )
    tasks = list(task_result.scalars().all())
    if len(tasks) != len(body.task_ids):
        raise HTTPException(status_code=400, detail="部分任务不存在")
    not_done = [t for t in tasks if (t.status or "").lower() not in DONE_STATUSES]
    if not_done:
        raise HTTPException(status_code=409, detail="发布计划仅允许绑定已完成任务")

    content = {
        "charter_id": int(charter.id),
        "task_ids": [int(t.id) for t in tasks],
        "planned_at": body.planned_at,
        "verification_items": [],
        "verification_done": False,
    }
    release_node = TruthNode(
        tenant_id=tenant_id,
        node_type="release",
        parent_id=int(charter.id),
        project_id=pid,
        created_by=int(current_user.id),
        title=compact_title(body.title, max_len=24),
        content=content,
        version=1,
        status="pending",
    )
    db.add(release_node)
    await log_operation(
        db,
        tenant_id=tenant_id,
        user_id=int(current_user.id),
        project_id=pid,
        entity_type="release",
        entity_id="new",
        action="create",
        after_data={"title": release_node.title, "task_ids": body.task_ids},
    )
    await db.commit()
    await db.refresh(release_node)
    return success_response(
        {
            "id": str(release_node.id),
            "title": release_node.title,
            "status": release_node.status,
            "content": _as_dict(release_node.content),
        }
    )


@router.patch("/projects/{project_id}/releases/{release_node_id}/status")
async def patch_release_status(
    project_id: str,
    release_node_id: str,
    body: ReleaseStatusPatchRequest,
    permission_user: User = Depends(require_project_member_or_manager),
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    _ = permission_user
    _require_manager(current_user)
    pid = _parse_project_id(project_id)
    rid = _parse_node_id(release_node_id, "release_node_id")
    tenant_id = int(current_user.tenant_id)
    await _ensure_project(SSTCService(db, tenant_id=tenant_id), pid)
    release_node = await _ensure_release(
        db, tenant_id=tenant_id, project_id=pid, release_node_id=rid
    )
    before = {"status": release_node.status}
    release_node.status = body.status
    content = _as_dict(release_node.content)
    content["status_note"] = body.note
    release_node.content = content
    await log_operation(
        db,
        tenant_id=tenant_id,
        user_id=int(current_user.id),
        project_id=pid,
        entity_type="release",
        entity_id=str(rid),
        action="status_change",
        before_data=before,
        after_data={"status": body.status, "note": body.note},
    )
    await db.commit()
    return success_response({"id": str(release_node.id), "status": release_node.status})


@router.post("/projects/{project_id}/releases/{release_node_id}/verification/generate")
async def generate_release_verification(
    project_id: str,
    release_node_id: str,
    permission_user: User = Depends(require_project_member_or_manager),
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    _ = permission_user
    _require_manager(current_user)
    pid = _parse_project_id(project_id)
    rid = _parse_node_id(release_node_id, "release_node_id")
    tenant_id = int(current_user.tenant_id)
    await _ensure_project(SSTCService(db, tenant_id=tenant_id), pid)
    release_node = await _ensure_release(
        db, tenant_id=tenant_id, project_id=pid, release_node_id=rid
    )

    content = _as_dict(release_node.content)
    charter_id = int(content.get("charter_id") or 0)
    charter = await _ensure_charter(
        db,
        tenant_id=tenant_id,
        project_id=pid,
        charter_id=charter_id,
    )
    charter_content = _as_dict(charter.content)
    success_metrics = charter_content.get("success_metrics") or charter_content.get("core_metrics") or []
    if not success_metrics:
        success_metrics = ["功能验收通过", "核心流程无阻塞", "关键性能指标达标"]

    items = [
        {
            "id": f"check-{i+1}",
            "title": str(metric),
            "expected": "达到预期",
            "status": "pending",
            "verified_by": None,
            "verified_at": None,
        }
        for i, metric in enumerate(success_metrics)
    ]
    content["verification_items"] = items
    release_node.content = content
    await db.commit()
    return success_response({"release_id": str(release_node.id), "verification_items": items})


@router.post("/projects/{project_id}/releases/{release_node_id}/verification/complete")
async def complete_release_verification(
    project_id: str,
    release_node_id: str,
    permission_user: User = Depends(require_project_member_or_manager),
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    _ = permission_user
    _require_manager(current_user)
    pid = _parse_project_id(project_id)
    rid = _parse_node_id(release_node_id, "release_node_id")
    tenant_id = int(current_user.tenant_id)
    await _ensure_project(SSTCService(db, tenant_id=tenant_id), pid)
    release_node = await _ensure_release(
        db, tenant_id=tenant_id, project_id=pid, release_node_id=rid
    )
    content = _as_dict(release_node.content)
    items = content.get("verification_items", [])
    now_str = datetime.now(timezone.utc).isoformat()
    for item in items:
        item["status"] = "done"
        item["verified_by"] = str(current_user.id)
        item["verified_at"] = now_str
    content["verification_items"] = items
    content["verification_done"] = True
    release_node.content = content
    release_node.status = "verified"
    await db.commit()
    return success_response({"id": str(release_node.id), "status": release_node.status})


@router.get("/projects/{project_id}/reviews")
async def list_reviews(
    project_id: str,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    pid = _parse_project_id(project_id)
    svc = SSTCService(db, tenant_id=int(current_user.tenant_id))
    await _ensure_project(svc, pid)
    reviews = await svc.get_reviews(pid)
    return success_response(
        [
            {
                "id": str(r.id),
                "title": r.title,
                "status": r.status,
                "content": _as_dict(r.content),
                "version": r.version,
                "created_at": r.created_at.isoformat() if r.created_at else None,
            }
            for r in reviews
        ]
    )


@router.post("/projects/{project_id}/reviews")
async def create_review(
    project_id: str,
    body: ReviewCreateRequest,
    permission_user: User = Depends(require_project_member_or_manager),
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    _ = permission_user
    _require_manager(current_user)
    pid = _parse_project_id(project_id)
    tenant_id = int(current_user.tenant_id)
    await _ensure_project(SSTCService(db, tenant_id=tenant_id), pid)
    release_node = await _ensure_release(
        db,
        tenant_id=tenant_id,
        project_id=pid,
        release_node_id=int(body.release_node_id),
    )
    if (release_node.status or "").lower() not in RELEASE_VERIFIED_STATUSES:
        raise HTTPException(status_code=409, detail="发布未验证，复盘环节未解锁")

    review_node = TruthNode(
        tenant_id=tenant_id,
        node_type="review",
        parent_id=int(release_node.id),
        project_id=pid,
        created_by=int(current_user.id),
        title=compact_title(body.title, max_len=24),
        content=body.content,
        version=1,
        status="draft",
    )
    db.add(review_node)
    await log_operation(
        db,
        tenant_id=tenant_id,
        user_id=int(current_user.id),
        project_id=pid,
        entity_type="review",
        entity_id="new",
        action="create",
        after_data={"title": review_node.title, "release_node_id": body.release_node_id},
    )
    await db.commit()
    await db.refresh(review_node)
    return success_response(
        {
            "id": str(review_node.id),
            "title": review_node.title,
            "status": review_node.status,
            "content": _as_dict(review_node.content),
        }
    )


@router.post("/projects/{project_id}/reviews/{review_node_id}/archive")
async def archive_review(
    project_id: str,
    review_node_id: str,
    body: ReviewArchiveRequest,
    permission_user: User = Depends(require_project_member_or_manager),
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    _ = permission_user
    _require_manager(current_user)
    pid = _parse_project_id(project_id)
    rid = _parse_node_id(review_node_id, "review_node_id")
    tenant_id = int(current_user.tenant_id)
    await _ensure_project(SSTCService(db, tenant_id=tenant_id), pid)
    result = await db.execute(
        select(TruthNode).where(
            and_(
                TruthNode.id == rid,
                TruthNode.project_id == pid,
                TruthNode.tenant_id == tenant_id,
                TruthNode.node_type == "review",
            )
        )
    )
    review_node = result.scalar_one_or_none()
    if not review_node:
        raise HTTPException(status_code=404, detail="Review not found")

    before = {"status": review_node.status}
    review_node.status = "archived" if body.archive else "draft"
    content = _as_dict(review_node.content)
    content["archive_note"] = body.note
    content["archived_at"] = datetime.now(timezone.utc).isoformat() if body.archive else None
    review_node.content = content
    await log_operation(
        db,
        tenant_id=tenant_id,
        user_id=int(current_user.id),
        project_id=pid,
        entity_type="review",
        entity_id=str(rid),
        action="archive" if body.archive else "unarchive",
        before_data=before,
        after_data={"status": review_node.status},
    )
    await db.commit()
    return success_response({"id": str(review_node.id), "status": review_node.status})