from fastapi import APIRouter, HTTPException, Depends
from fastapi.responses import StreamingResponse

from schemas.agent_input import AgentInput
from schemas.agent_output import AgentOutput
from schemas.tool_input import ToolInput
from schemas.tool_output import ToolOutput
from workflows.workflow_manager import WorkflowType
from api.dependencies import get_workflow_manager, get_nacos_manager, get_service_config, get_tool_router


router = APIRouter()


def _resolve_workflow_type(value: str) -> WorkflowType:
    try:
        return WorkflowType(value)
    except Exception as e:
        raise ValueError(f"不支持的工作流类型: {value}") from e


@router.get("/health")
def health_check(service_config=Depends(get_service_config)):
    return {
        "status": "ok",
        "service_name": service_config.service_name,
        "model_section": service_config.metadata.get("model_section", "")
    }


@router.get("/nacos/status")
def nacos_status(nacos_manager=Depends(get_nacos_manager)):
    return nacos_manager.status()


@router.post("/api/workflows", response_model=AgentOutput)
def run_workflow(payload: AgentInput, workflow_manager=Depends(get_workflow_manager)):
    try:
        workflow_type = _resolve_workflow_type(payload.workflow_type)
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))

    result = workflow_manager.execute_workflow(
        workflow_type=workflow_type,
        user_input=payload.input,
        session_id=payload.session_id,
    )

    return AgentOutput(
        session_id=result["session_id"],
        workflow_type=result["workflow_type"],
        result=result["result"],
    )


@router.post("/api/workflows/stream")
def run_workflow_stream(payload: AgentInput, workflow_manager=Depends(get_workflow_manager)):
    try:
        workflow_type = _resolve_workflow_type(payload.workflow_type)
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))

    if workflow_type != WorkflowType.CONVERSATION:
        raise HTTPException(status_code=400, detail="仅支持对话工作流的流式输出")

    agent = workflow_manager.get_workflow(workflow_type)

    def event_stream():
        try:
            for token in agent.stream_run(payload.input):
                yield f"data: {token}\n\n"
            yield "event: end\ndata: [DONE]\n\n"
        except Exception as e:
            yield f"event: error\ndata: {str(e)}\n\n"

    return StreamingResponse(event_stream(), media_type="text/event-stream")


@router.post("/api/tools/execute", response_model=ToolOutput)
def run_tool(payload: ToolInput, tool_router=Depends(get_tool_router)):
    result = tool_router.call(payload.tool_name, payload.payload)
    return ToolOutput(**result)