# ///
# nodes.py
# 描述：节点管理API路由
# 作者：AI Generated
# 创建日期：2026-04-05
# ///

from fastapi import APIRouter, HTTPException, Depends
from typing import List, Optional, Dict, Any
from pydantic import BaseModel

from services.node_manager import node_manager
from config import save_config_to_file, get_settings, NodeConfig
from utils import require_api_key


router = APIRouter(prefix="/nodes", tags=["节点管理"])


class NodeAddRequest(BaseModel):
    node_id: str
    name: str
    api_url: str
    api_key: str
    description: str = ""
    group: str = "default"


class NodeUpdateRequest(BaseModel):
    name: Optional[str] = None
    api_url: Optional[str] = None
    api_key: Optional[str] = None
    description: Optional[str] = None
    group: Optional[str] = None
    enabled: Optional[bool] = None


def save_nodes_config():
    nodes_data = node_manager.to_config()
    get_settings().nodes = [NodeConfig(**n) for n in nodes_data]
    save_config_to_file()


@router.get("/", summary="获取所有节点")
async def get_nodes(group: Optional[str] = None, _=Depends(require_api_key)) -> Dict[str, Any]:
    from database_service import get_db_service
    db_service = get_db_service()
    if db_service:
        nodes = db_service.get_all_nodes()
        result_nodes = [n.to_dict() for n in nodes]
        return {"success": True, "data": result_nodes, "count": len(result_nodes)}

    if group:
        nodes = await node_manager.get_nodes_by_group(group)
    else:
        nodes = await node_manager.get_all_nodes()

    result_nodes = []
    for node in nodes:
        node_dict = node.to_dict()
        result_nodes.append(node_dict)

    return {
        "success": True,
        "data": result_nodes,
        "count": len(result_nodes)
    }


@router.get("/{node_id}", summary="获取指定节点信息")
async def get_node(node_id: str, _=Depends(require_api_key)) -> Dict[str, Any]:
    from database_service import get_db_service
    db_service = get_db_service()
    if db_service:
        node = db_service.get_node(node_id)
        if node:
            return {"success": True, "data": node.to_dict()}
    node = await node_manager.get_node(node_id)
    if not node:
        raise HTTPException(status_code=404, detail=f"Node '{node_id}' not found")
    return {"success": True, "data": node.to_dict()}


@router.post("/", summary="添加节点")
async def add_node(request: NodeAddRequest, _=Depends(require_api_key)) -> Dict[str, Any]:
    from database_service import get_db_service
    db_service = get_db_service()
    if db_service:
        db_service.add_node(
            node_id=request.node_id,
            name=request.name,
            api_url=request.api_url,
            api_key=request.api_key,
            description=request.description or "",
            group=request.group or "default"
        )

    success = await node_manager.add_node(
        node_id=request.node_id,
        name=request.name,
        api_url=request.api_url,
        api_key=request.api_key,
        description=request.description,
        group=request.group
    )
    if not success:
        raise HTTPException(status_code=400, detail=f"Node '{request.node_id}' already exists")
    save_nodes_config()
    return {"success": True, "message": f"Node '{request.node_id}' added successfully"}


@router.put("/{node_id}", summary="更新节点信息")
async def update_node(node_id: str, request: NodeUpdateRequest,
                       _=Depends(require_api_key)) -> Dict[str, Any]:
    update_data = request.model_dump(exclude_unset=True)

    from database_service import get_db_service
    db_service = get_db_service()
    if db_service:
        db_service.update_node(node_id, **update_data)

    success = await node_manager.update_node(node_id, **update_data)
    if not success:
        raise HTTPException(status_code=404, detail=f"Node '{node_id}' not found")
    save_nodes_config()
    return {"success": True, "message": f"Node '{node_id}' updated successfully"}


@router.delete("/{node_id}", summary="删除节点")
async def delete_node(node_id: str, _=Depends(require_api_key)) -> Dict[str, Any]:
    from database_service import get_db_service
    db_service = get_db_service()
    if db_service:
        db_service.delete_node(node_id)

    success = await node_manager.remove_node(node_id)
    if not success:
        raise HTTPException(status_code=404, detail=f"Node '{node_id}' not found")
    save_nodes_config()
    return {"success": True, "message": f"Node '{node_id}' deleted successfully"}


@router.get("/{node_id}/status", summary="检查节点状态")
async def check_node_status(node_id: str, _=Depends(require_api_key)) -> Dict[str, Any]:
    api_status = await node_manager.check_node_status(node_id)
    is_healthy, health_msg = await node_manager.is_node_healthy(node_id)

    return {
        "success": True,
        "data": {
            "node_id": node_id,
            "api_status": api_status,
            "is_healthy": is_healthy,
            "health_message": health_msg
        }
    }


@router.post("/{node_id}/enable", summary="启用节点")
async def enable_node(node_id: str, _=Depends(require_api_key)) -> Dict[str, Any]:
    from database_service import get_db_service
    db_service = get_db_service()
    if db_service:
        db_service.update_node(node_id, enabled=True)
    success = await node_manager.update_node(node_id, enabled=True)
    if not success:
        raise HTTPException(status_code=404, detail=f"Node '{node_id}' not found")
    save_nodes_config()
    return {"success": True, "message": f"Node '{node_id}' enabled"}


@router.post("/{node_id}/disable", summary="禁用节点")
async def disable_node(node_id: str, _=Depends(require_api_key)) -> Dict[str, Any]:
    from database_service import get_db_service
    db_service = get_db_service()
    if db_service:
        db_service.update_node(node_id, enabled=False)
    success = await node_manager.update_node(node_id, enabled=False)
    if not success:
        raise HTTPException(status_code=404, detail=f"Node '{node_id}' not found")
    save_nodes_config()
    return {"success": True, "message": f"Node '{node_id}' disabled"}


@router.get("/{node_id}/friends", summary="获取节点好友列表")
async def get_friends(node_id: str, _=Depends(require_api_key)) -> Dict[str, Any]:
    result = await node_manager.get_friends_list(node_id)
    return result


@router.get("/{node_id}/groups", summary="获取节点群列表")
async def get_groups(node_id: str, _=Depends(require_api_key)) -> Dict[str, Any]:
    result = await node_manager.get_groups_list(node_id)
    return result


@router.get("/{node_id}/messages/{chat_name}", summary="获取聊天消息")
async def get_messages(node_id: str, chat_name: str, limit: int = 20,
                       _=Depends(require_api_key)) -> Dict[str, Any]:
    result = await node_manager.get_messages(node_id, chat_name, limit)
    return result