from __future__ import annotations

import logging
from typing import Any

from fastapi import APIRouter, Depends, HTTPException

from app.modules.auth.presentation.auth import require_role
from app.core.postgres.erp_client import ErpDatabaseClient
from app.models.schemas import (
    AgentModelConfigItem,
    AgentModelListResponse,
    UpdateAgentModelRequest,
)
from app.modules.core.application.model_benchmark_service import ModelBenchmarkService

logger = logging.getLogger("dscons.api.knowledge_agents.benchmark")
router = APIRouter()
benchmark_service = ModelBenchmarkService()


@router.get("/v1/admin/agent-models", response_model=AgentModelListResponse)
def list_ai_agent_models(
    current_user: dict[str, Any] = Depends(
        require_role(["superadmin", "director", "admin"])
    ),
) -> AgentModelListResponse:
    """Lấy danh sách cấu hình LLM Model và Provider của toàn bộ AI Agents (Dành cho Superadmin/Director)."""
    client = ErpDatabaseClient()
    try:
        models = client.list_ai_agent_models()
        return AgentModelListResponse(
            agents=[AgentModelConfigItem(**m) for m in models],
            default_model="gemini-3.8-flash",
            default_provider="antigravity_sdk",
        )
    except Exception as exc:
        raise HTTPException(
            status_code=500, detail=f"Lỗi lấy cấu hình AI models: {exc!s}"
        ) from exc


@router.put("/v1/admin/agent-models/{agent_code}", response_model=AgentModelConfigItem)
def update_ai_agent_model(
    agent_code: str,
    payload: UpdateAgentModelRequest,
    current_user: dict[str, Any] = Depends(
        require_role(["superadmin", "director", "admin"])
    ),
) -> AgentModelConfigItem:
    """Cập nhật LLM Model, Provider, System Prompt và vòng đời Stealth cho một AI Agent (Dành cho Superadmin/Director)."""
    client = ErpDatabaseClient()
    try:
        updated = client.update_ai_agent_model(
            agent_code=agent_code,
            model_name=payload.model_name,
            provider=payload.provider,
            temperature=payload.temperature,
            max_tokens=payload.max_tokens,
            system_prompt_custom=payload.system_prompt_custom,
            is_stealth_promo=payload.is_stealth_promo,
            stealth_expires_at=payload.stealth_expires_at,
            fallback_model_name=payload.fallback_model_name,
            fallback_provider=payload.fallback_provider,
        )
        all_models = client.list_ai_agent_models()
        presets = all_models[0].get("available_presets", []) if all_models else []
        updated["available_presets"] = presets
        return AgentModelConfigItem(**updated)
    except ValueError as exc:
        raise HTTPException(status_code=404, detail=str(exc)) from exc
    except Exception as exc:
        raise HTTPException(
            status_code=500, detail=f"Lỗi cập nhật AI model: {exc!s}"
        ) from exc


@router.post("/v1/admin/model-benchmark/run")
def run_model_benchmark(
    current_user: dict[str, Any] = Depends(
        require_role(["superadmin", "director", "admin"])
    ),
) -> dict[str, Any]:
    """Kích hoạt bài kiểm tra đo lường thực tế TPS, Latency (TTFT) và Chất lượng câu trả lời chuyên ngành AEC."""
    try:
        results = benchmark_service.run_benchmark()
        return {
            "status": "SUCCESS",
            "tested_models_count": len(results),
            "results": results,
        }
    except Exception as exc:
        raise HTTPException(
            status_code=500, detail=f"Lỗi chạy benchmark mô hình: {exc!s}"
        ) from exc


@router.get("/v1/admin/model-benchmark/results")
def get_model_benchmark_results(
    current_user: dict[str, Any] = Depends(
        require_role(["superadmin", "director", "admin", "pm", "qs"])
    ),
) -> dict[str, Any]:
    """Truy xuất kết quả benchmark so sánh giữa OpenRouter Free Models và Local LM Studio."""
    try:
        results = benchmark_service.get_benchmark_results()
        return {
            "tested_models_count": len(results),
            "results": results,
        }
    except Exception as exc:
        raise HTTPException(
            status_code=500, detail=f"Lỗi lấy kết quả benchmark: {exc!s}"
        ) from exc


@router.get("/v1/admin/model-benchmark/recommendations")
def get_optimal_model_recommendations(
    current_user: dict[str, Any] = Depends(
        require_role(["superadmin", "director", "admin", "pm", "qs"])
    ),
) -> dict[str, Any]:
    """Lấy ma trận đề xuất gán model tối ưu nhất cho từng vị trí trong 9 nhân sự AI của DSCons."""
    try:
        recommendations = benchmark_service.generate_recommendations()
        return {
            "total_personas": len(recommendations),
            "recommendations": recommendations,
        }
    except Exception as exc:
        raise HTTPException(
            status_code=500, detail=f"Lỗi tạo đề xuất model tối ưu: {exc!s}"
        ) from exc


@router.post("/v1/admin/model-benchmark/apply-recommendations")
def apply_optimal_model_recommendations(
    current_user: dict[str, Any] = Depends(
        require_role(["superadmin", "director", "admin"])
    ),
) -> dict[str, Any]:
    """1-Click: Tự động cập nhật và áp dụng toàn bộ cấu hình model tối ưu cho 9 nhân viên AI."""
    try:
        return benchmark_service.apply_optimal_recommendations()
    except Exception as exc:
        raise HTTPException(
            status_code=500, detail=f"Lỗi áp dụng cấu hình tối ưu: {exc!s}"
        ) from exc


@router.post("/v1/admin/model-benchmark/check-stealth-expiration")
def check_stealth_models_expiration(
    current_user: dict[str, Any] = Depends(
        require_role(["superadmin", "director", "admin"])
    ),
) -> dict[str, Any]:
    """Kiểm tra và tự động chuyển đổi toàn bộ mô hình Stealth / Promo đã hết hạn về Fallback Model an toàn."""
    try:
        return benchmark_service.check_and_fallback_expired_stealth_models()
    except Exception as exc:
        raise HTTPException(
            status_code=500, detail=f"Lỗi kiểm tra hết hạn Stealth models: {exc!s}"
        ) from exc