"""LLM 测试和演示路由"""
from fastapi import APIRouter, HTTPException
from pydantic import BaseModel
from typing import List, Optional

from src.integrations.llm_client import get_llm_client, LLMResponse

router = APIRouter(prefix="/api/v1/llm", tags=["LLM"])


class ChatRequest(BaseModel):
    """聊天请求"""
    message: str
    system_prompt: Optional[str] = None
    temperature: float = 0.7


class ChatResponse(BaseModel):
    """聊天响应"""
    content: str
    model: str
    usage: dict
    cost: float


class AnalysisRequest(BaseModel):
    """查询分析请求"""
    query: str
    context: Optional[dict] = {}


class AnalysisResponse(BaseModel):
    """查询分析响应"""
    intent: str
    entities: List[str]
    required_skills: List[str]
    needs_reasoning: bool
    confidence: float


@router.post("/chat", response_model=ChatResponse)
async def llm_chat(request: ChatRequest):
    """
    测试 DeepSeek LLM 聊天功能

    示例请求:
    ```json
    {
        "message": "你好，请介绍一下自己",
        "temperature": 0.7
    }
    ```
    """
    client = get_llm_client()

    if not client.enabled:
        raise HTTPException(status_code=503, detail="LLM not configured")

    messages = []
    if request.system_prompt:
        messages.append({"role": "system", "content": request.system_prompt})
    messages.append({"role": "user", "content": request.message})

    try:
        response: LLMResponse = await client.chat_completion(
            messages=messages,
            temperature=request.temperature,
        )
        return ChatResponse(
            content=response.content,
            model=response.model,
            usage=response.usage,
            cost=response.cost,
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"LLM error: {str(e)}")


@router.post("/analyze", response_model=AnalysisResponse)
async def analyze_query(request: AnalysisRequest):
    """
    使用 LLM 分析用户查询意图

    示例请求:
    ```json
    {
        "query": "技术部有多少员工？",
        "context": {"user_id": "user_123"}
    }
    ```
    """
    client = get_llm_client()

    if not client.enabled:
        raise HTTPException(status_code=503, detail="LLM not configured")

    try:
        result = await client.analyze_query(request.query, request.context)
        return AnalysisResponse(
            intent=result.get("intent", "other"),
            entities=result.get("entities", []),
            required_skills=result.get("required_skills", []),
            needs_reasoning=result.get("needs_reasoning", False),
            confidence=result.get("confidence", 0.5),
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Analysis error: {str(e)}")


@router.get("/status")
async def llm_status():
    """检查 LLM 配置状态"""
    client = get_llm_client()
    return {
        "enabled": client.enabled,
        "model": client.model if client.enabled else None,
        "base_url": client.base_url if client.enabled else None,
    }


@router.post("/stream")
async def llm_stream(request: ChatRequest):
    """
    流式 LLM 响应（SSE）

    返回 text/event-stream 格式的流式响应
    """
    from fastapi.responses import StreamingResponse

    client = get_llm_client()

    if not client.enabled:
        raise HTTPException(status_code=503, detail="LLM not configured")

    messages = []
    if request.system_prompt:
        messages.append({"role": "system", "content": request.system_prompt})
    messages.append({"role": "user", "content": request.message})

    async def generate():
        async for chunk in client.chat_completion_stream(
            messages=messages,
            temperature=request.temperature,
        ):
            yield f"data: {chunk}\n\n"
        yield "data: [DONE]\n\n"

    return StreamingResponse(
        generate(),
        media_type="text/event-stream",
        headers={
            "Cache-Control": "no-cache",
            "Connection": "keep-alive",
        },
    )