from fastapi import APIRouter, Request, Body, HTTPException, Depends, Path
from sqlalchemy.ext.asyncio import AsyncSession


from app.database import get_db, CallbackFailureLog
from app.models import CallbackResponse
from app.config import settings
from app.logger import get_logger
from app.celery_tasks import push_data_to_dtc_task

logger = get_logger("routes")

router = APIRouter()


async def log_callback_request(
    db: AsyncSession,
    request: Request,
    site_id: str,
    callback_data: dict
) -> bool:
    """记录回调请求到数据库，返回操作是否成功"""
    import json
    
    # 获取客户端IP地址
    client_ip = request.client.host if request.client else None
    client_port = request.client.port if request.client else None
    
    # 获取服务器IP地址
    server_ip = None
    server_port = None
    if hasattr(request, 'scope') and 'server' in request.scope:
        server_host, server_port_info = request.scope['server']
        server_ip = server_host
        server_port = server_port_info
    
    # 准备请求头信息（直接记录原始请求头）
    request_headers = dict(request.headers)

    # 准备请求体信息（直接记录原始请求体）
    request_body = callback_data

    # 记录请求URL（JSON格式）
    logger.info(f"🌐 请求URL: {request.url}")
    
    # 记录site_id（JSON格式）
    logger.info(f"📝 site_id: {site_id}")
    
        # 记录server_ip（JSON格式）
    server_info = {
        "ip": server_ip,
        "port": server_port
    }
    logger.info(f"🏠 server_ip: {server_info}")
    
    # 记录client_ip（JSON格式）
    client_info = {
        "ip": client_ip,
        "port": client_port
    }
    logger.info(f"🖥️ client_ip: {client_info}")

    # 记录请求头（JSON格式）
    logger.info(f"📋 请求头: {json.dumps(request_headers, ensure_ascii=False, indent=2)}")
    
    # 记录请求体（JSON格式）
    logger.info(f"📄 请求体: {json.dumps(callback_data, ensure_ascii=False, indent=2)}")
        
    try:
        # 保存到数据库
        callback_log = CallbackFailureLog(
            site_id=site_id,
            remote_address=f"{client_ip}:{client_port}" if client_ip and client_port else client_ip,
            server_ip=f"{server_ip}:{server_port}" if server_ip and server_port else server_ip,
            request_url=str(request.url),
            request_headers=request_headers,  # 保存原始请求头
            request_body=request_body  # 保存从request.body获取的原始请求体
        )
        
        db.add(callback_log)
        await db.commit()
        
        logger.info(f"✅ 回调请求记录成功保存到数据库，ID: {callback_log.id}")
        
        # 返回成功标识
        return True
        
    except Exception as e:
        logger.error(f"❌ 保存回调请求到数据库失败: {e}", exc_info=True)
        # 返回失败标识
        return False





@router.post("/ai-talk/callback/{siteId}/failure", response_model=CallbackResponse)
async def ai_talk_callback(
    request: Request,
    callback_data: dict = Body(...),
    siteId: str = Path(..., description="站点ID"),
    db: AsyncSession = Depends(get_db)
):
    """
    AI Talk回调接口处理
    """
    try:
        # 记录回调请求（包含siteId）
        success = await log_callback_request(db, request, siteId, callback_data)
        
        if not success:
            logger.error("❌ 回调请求日志保存失败")
            raise HTTPException(status_code=500, detail="回调请求日志保存失败")
        
        # 立即返回成功响应
        return CallbackResponse(
            success=True,
            message="成功",
            processed=False,
            retry_count=0,
            site_id=siteId
        )
    
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"💥 服务器内部错误: {e}", exc_info=True)
        raise HTTPException(
            status_code=500,
            detail=f"服务器内部错误: {str(e)}"
        )