"""模型能力矩阵 API"""

from typing import Optional

from fastapi import APIRouter, Depends, Query
from fastapi.responses import JSONResponse
from sqlalchemy import and_, select
from sqlalchemy.ext.asyncio import AsyncSession

from ..core.response import ErrorCode, error_response, success_response
from ..database import get_db
from ..dependencies import get_current_user, get_tenant_id
from ..models import Experiment, TruthNode, User
from ..schemas.model_capability import (
    CostOptimizationAnalyzeRequest,
    ExperimentSyncRequest,
    ExperimentSyncReviewRequest,
    ExperimentSyncRollbackRequest,
    GenerateMigrationTasksRequest,
    LifecycleImpactRequest,
    ValidateMatchRequest,
)
from ..services.ai_service import get_ai_service
from ..services.cost_optimization_service import CostOptimizationService
from ..services.experiment_sync_service import ExperimentSyncService
from ..services.model_capability_service import ModelCapabilityService
from ..services.model_lifecycle_service import ModelLifecycleService

router = APIRouter(prefix="/model-capability", tags=["model-capability"])


def _build_service(db: AsyncSession) -> ModelCapabilityService:
    return ModelCapabilityService(db=db, ai_service=get_ai_service())


@router.post("/validate-match")
async def validate_model_requirement_match(
    request: ValidateMatchRequest,
    current_user: User = Depends(get_current_user),
    tenant_id: int = Depends(get_tenant_id),
    db: AsyncSession = Depends(get_db),
):
    """需求-模型匹配校验"""
    _ = current_user
    service = _build_service(db)
    try:
        data = await service.validate_model_requirement_match(
            truth_node_id=request.truth_node_id,
            model_version_id=request.model_version_id,
            tenant_id=tenant_id,
            project_id=request.project_id,
        )
        return success_response(data=data)
    except ValueError as exc:
        return JSONResponse(
            status_code=404,
            content=error_response(ErrorCode.NOT_FOUND, str(exc)),
        )
    except Exception as exc:
        return JSONResponse(
            status_code=500,
            content=error_response(ErrorCode.INTERNAL_ERROR, f"匹配校验失败: {exc}"),
        )


@router.get("/capability-gaps")
async def list_capability_gaps(
    status: Optional[str] = Query(default=None),
    severity: Optional[str] = Query(default=None),
    limit: int = Query(default=100, ge=1, le=500),
    current_user: User = Depends(get_current_user),
    tenant_id: int = Depends(get_tenant_id),
    db: AsyncSession = Depends(get_db),
):
    """列出能力差距预警"""
    _ = current_user
    service = _build_service(db)
    try:
        data = await service.list_capability_gaps(
            tenant_id=tenant_id,
            status=status,
            severity=severity,
            limit=limit,
        )
        return success_response(data=data)
    except Exception as exc:
        return JSONResponse(
            status_code=500,
            content=error_response(ErrorCode.INTERNAL_ERROR, f"查询能力差距失败: {exc}"),
        )


@router.get("/cost-tracking/{truth_node_id}")
async def get_cost_tracking(
    truth_node_id: int,
    period: str = Query(default="weekly", pattern="^(daily|weekly|monthly|project)$"),
    current_user: User = Depends(get_current_user),
    tenant_id: int = Depends(get_tenant_id),
    db: AsyncSession = Depends(get_db),
):
    """查询成本跟踪与 ROI"""
    _ = current_user
    service = _build_service(db)
    try:
        data = await service.get_cost_tracking(
            truth_node_id=truth_node_id,
            period=period,
            tenant_id=tenant_id,
        )
        return success_response(data=data)
    except Exception as exc:
        return JSONResponse(
            status_code=500,
            content=error_response(ErrorCode.INTERNAL_ERROR, f"查询成本跟踪失败: {exc}"),
        )


@router.get("/cost-optimization/{truth_node_id}")
async def get_cost_optimization(
    truth_node_id: int,
    period: str = Query(default="weekly", pattern="^(daily|weekly|monthly|project)$"),
    current_user: User = Depends(get_current_user),
    tenant_id: int = Depends(get_tenant_id),
    db: AsyncSession = Depends(get_db),
):
    """查询成本优化建议（必要时自动触发一次计算）"""
    _ = current_user
    service = _build_service(db)
    try:
        tracking = await service.get_cost_tracking(
            truth_node_id=truth_node_id,
            period=period,
            tenant_id=tenant_id,
        )

        optimization = tracking.get("optimization_suggestions") or {}
        if not optimization:
            computed = await service.track_cost_and_roi(
                truth_node_id=truth_node_id,
                period=period,
                tenant_id=tenant_id,
            )
            optimization = computed.get("optimization_suggestions", {})
            tracking = await service.get_cost_tracking(
                truth_node_id=truth_node_id,
                period=period,
                tenant_id=tenant_id,
            )

        return success_response(
            data={
                "truth_node_id": truth_node_id,
                "period": period,
                "optimization_suggestions": optimization,
                "roi_score": tracking.get("roi_score"),
                "actual_cost_usd": tracking.get("actual_cost_usd", 0.0),
            }
        )
    except Exception as exc:
        return JSONResponse(
            status_code=500,
            content=error_response(ErrorCode.INTERNAL_ERROR, f"查询成本优化失败: {exc}"),
        )


@router.post("/lifecycle/assess-impact")
async def assess_model_update_impact(
    request: LifecycleImpactRequest,
    current_user: User = Depends(get_current_user),
    tenant_id: int = Depends(get_tenant_id),
    db: AsyncSession = Depends(get_db),
):
    """评估模型升级对现有需求集合的影响。"""
    _ = current_user
    service = ModelLifecycleService(db)
    try:
        data = await service.assess_model_update_impact(
            old_model_version_id=request.old_model_version_id,
            new_model_version_id=request.new_model_version_id,
            tenant_id=tenant_id,
        )
        return success_response(data=data)
    except ValueError as exc:
        return JSONResponse(
            status_code=404,
            content=error_response(ErrorCode.NOT_FOUND, str(exc)),
        )
    except Exception as exc:
        return JSONResponse(
            status_code=500,
            content=error_response(ErrorCode.INTERNAL_ERROR, f"影响评估失败: {exc}"),
        )


@router.get("/lifecycle/impacts")
async def list_lifecycle_impacts(
    limit: int = Query(default=50, ge=1, le=200),
    current_user: User = Depends(get_current_user),
    tenant_id: int = Depends(get_tenant_id),
    db: AsyncSession = Depends(get_db),
):
    """列出模型生命周期影响评估记录。"""
    _ = current_user
    service = ModelLifecycleService(db)
    try:
        data = await service.list_impacts(tenant_id=tenant_id, limit=limit)
        return success_response(data=data)
    except Exception as exc:
        return JSONResponse(
            status_code=500,
            content=error_response(ErrorCode.INTERNAL_ERROR, f"查询影响评估失败: {exc}"),
        )


@router.post("/lifecycle/{impact_id}/migration-tasks")
async def create_migration_tasks(
    impact_id: int,
    request: GenerateMigrationTasksRequest,
    current_user: User = Depends(get_current_user),
    tenant_id: int = Depends(get_tenant_id),
    db: AsyncSession = Depends(get_db),
):
    """基于影响评估自动生成迁移任务建议。"""
    _ = current_user
    service = ModelLifecycleService(db)
    try:
        data = await service.generate_migration_tasks(
            impact_id=impact_id,
            tenant_id=tenant_id,
            max_tasks=request.max_tasks,
        )
        return success_response(data=data)
    except ValueError as exc:
        return JSONResponse(
            status_code=404,
            content=error_response(ErrorCode.NOT_FOUND, str(exc)),
        )
    except Exception as exc:
        return JSONResponse(
            status_code=500,
            content=error_response(ErrorCode.INTERNAL_ERROR, f"生成迁移任务失败: {exc}"),
        )


@router.post("/experiment-sync")
async def create_experiment_sync(
    request: ExperimentSyncRequest,
    current_user: User = Depends(get_current_user),
    tenant_id: int = Depends(get_tenant_id),
    db: AsyncSession = Depends(get_db),
):
    """创建实验结果同步记录，满足阈值时自动同步。"""
    _ = current_user
    service = ExperimentSyncService(db)
    try:
        data = await service.auto_sync_experiment_result(
            experiment_id=request.experiment_id,
            truth_node_id=request.truth_node_id,
            tenant_id=tenant_id,
            project_id=request.project_id,
            sync_type=request.sync_type,
            auto_apply_threshold=request.auto_apply_threshold,
        )
        return success_response(data=data)
    except ValueError as exc:
        return JSONResponse(
            status_code=404,
            content=error_response(ErrorCode.NOT_FOUND, str(exc)),
        )
    except Exception as exc:
        return JSONResponse(
            status_code=500,
            content=error_response(ErrorCode.INTERNAL_ERROR, f"创建同步失败: {exc}"),
        )


@router.get("/experiment-sync")
async def list_experiment_sync_records(
    truth_node_id: Optional[int] = Query(default=None),
    limit: int = Query(default=50, ge=1, le=200),
    current_user: User = Depends(get_current_user),
    tenant_id: int = Depends(get_tenant_id),
    db: AsyncSession = Depends(get_db),
):
    """查询实验同步记录。"""
    _ = current_user
    service = ExperimentSyncService(db)
    try:
        data = await service.list_sync_records(
            tenant_id=tenant_id,
            truth_node_id=truth_node_id,
            limit=limit,
        )
        return success_response(data=data)
    except Exception as exc:
        return JSONResponse(
            status_code=500,
            content=error_response(ErrorCode.INTERNAL_ERROR, f"查询同步记录失败: {exc}"),
        )


@router.post("/experiment-sync/{sync_id}/review")
async def review_experiment_sync(
    sync_id: int,
    request: ExperimentSyncReviewRequest,
    current_user: User = Depends(get_current_user),
    tenant_id: int = Depends(get_tenant_id),
    db: AsyncSession = Depends(get_db),
):
    """人工审核实验同步记录。"""
    service = ExperimentSyncService(db)
    try:
        data = await service.review_sync(
            sync_id=sync_id,
            tenant_id=tenant_id,
            reviewer_id=current_user.id,
            action=request.action,
            review_notes=request.review_notes,
        )
        return success_response(data=data)
    except ValueError as exc:
        return JSONResponse(
            status_code=400,
            content=error_response(ErrorCode.BAD_REQUEST, str(exc)),
        )
    except Exception as exc:
        return JSONResponse(
            status_code=500,
            content=error_response(ErrorCode.INTERNAL_ERROR, f"审核同步失败: {exc}"),
        )


@router.post("/experiment-sync/{sync_id}/rollback")
async def rollback_experiment_sync(
    sync_id: int,
    request: ExperimentSyncRollbackRequest,
    current_user: User = Depends(get_current_user),
    tenant_id: int = Depends(get_tenant_id),
    db: AsyncSession = Depends(get_db),
):
    """回滚已应用的实验同步。"""
    service = ExperimentSyncService(db)
    try:
        data = await service.rollback_sync(
            sync_id=sync_id,
            tenant_id=tenant_id,
            reviewer_id=current_user.id,
            rollback_notes=request.rollback_notes,
        )
        return success_response(data=data)
    except ValueError as exc:
        return JSONResponse(
            status_code=400,
            content=error_response(ErrorCode.BAD_REQUEST, str(exc)),
        )
    except Exception as exc:
        return JSONResponse(
            status_code=500,
            content=error_response(ErrorCode.INTERNAL_ERROR, f"回滚同步失败: {exc}"),
        )


@router.post("/cost-optimization/analyze")
async def analyze_cost_optimization(
    request: CostOptimizationAnalyzeRequest,
    current_user: User = Depends(get_current_user),
    tenant_id: int = Depends(get_tenant_id),
    db: AsyncSession = Depends(get_db),
):
    """生成并持久化成本优化建议。"""
    _ = current_user
    service = CostOptimizationService(db)
    try:
        data = await service.analyze_cost_optimization(
            truth_node_id=request.truth_node_id,
            tenant_id=tenant_id,
            period=request.period,
            project_id=request.project_id,
        )
        return success_response(data=data)
    except ValueError as exc:
        return JSONResponse(
            status_code=400,
            content=error_response(ErrorCode.BAD_REQUEST, str(exc)),
        )
    except Exception as exc:
        return JSONResponse(
            status_code=500,
            content=error_response(ErrorCode.INTERNAL_ERROR, f"成本优化分析失败: {exc}"),
        )


@router.get("/context/projects/{project_id}/truth-nodes")
async def list_project_truth_nodes(
    project_id: int,
    current_user: User = Depends(get_current_user),
    tenant_id: int = Depends(get_tenant_id),
    db: AsyncSession = Depends(get_db),
):
    """获取项目上下文中的宪章列表，用于前端选择器。"""
    _ = current_user
    result = await db.execute(
        select(TruthNode).where(
            and_(
                TruthNode.tenant_id == tenant_id,
                TruthNode.project_id == project_id,
            )
        ).order_by(TruthNode.created_at.desc())
    )
    nodes = result.scalars().all()
    return success_response(
        data={
            "items": [
                {
                    "id": n.id,
                    "title": n.title,
                    "status": n.status,
                    "node_type": n.node_type,
                }
                for n in nodes
            ]
        }
    )


@router.get("/context/projects/{project_id}/experiments")
async def list_project_experiments(
    project_id: int,
    current_user: User = Depends(get_current_user),
    tenant_id: int = Depends(get_tenant_id),
    db: AsyncSession = Depends(get_db),
):
    """获取项目上下文中的实验列表（基于 linked_context_nodes 关联）。"""
    _ = current_user
    truth_ids_result = await db.execute(
        select(TruthNode.id).where(
            and_(
                TruthNode.tenant_id == tenant_id,
                TruthNode.project_id == project_id,
            )
        )
    )
    truth_ids = {int(row[0]) for row in truth_ids_result.all()}
    if not truth_ids:
        return success_response(data={"items": []})

    exp_result = await db.execute(
        select(Experiment)
        .where(Experiment.tenant_id == tenant_id)
        .order_by(Experiment.created_at.desc())
    )
    experiments = exp_result.scalars().all()

    def _linked_ids(raw) -> set[int]:
        ids = set()
        if isinstance(raw, list):
            for x in raw:
                try:
                    ids.add(int(x))
                except (TypeError, ValueError):
                    continue
        return ids

    items = []
    for e in experiments:
        if e.project_id is not None:
            if int(e.project_id) != int(project_id):
                continue
            items.append(
                {
                    "id": e.id,
                    "title": e.title or f"Experiment {e.id}",
                    "status": e.status,
                    "target_metric": e.target_metric,
                }
            )
            continue

        # 迁移兼容：project_id 为空时，回退到 linked_context_nodes 交叉判断。
        if _linked_ids(e.linked_context_nodes).isdisjoint(truth_ids):
            continue
        items.append(
            {
                "id": e.id,
                "title": e.title or f"Experiment {e.id}",
                "status": e.status,
                "target_metric": e.target_metric,
            }
        )
    return success_response(data={"items": items})