from fastapi import APIRouter, Depends, HTTPException, Request
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from datetime import datetime

from database.database import get_db_session
from models.database import User, ProcessingTask
from services.auth_service import get_current_active_user
from services.cam_bundle_service import cam_bundle_service
from services.task_query_service import TaskQueryService
from utils.logger import get_logger

logger = get_logger(__name__)

router = APIRouter()
DEFAULT_CAM_PREFERENCES = {
    "mold_steel": "P20",
    "surface_quality": "standard",
    "controller": "fanuc",
    "include_gcode": False,
}


@router.post("/cam/plan")
async def generate_cam_plan(
    request: Request,
    db_session: AsyncSession = Depends(get_db_session),
    current_user: User = Depends(get_current_active_user),
):
    """基于任务分模结果生成 CAM 准备包（MVP）。"""
    _ = current_user
    body = await request.json()
    task_id = body.get("task_id")
    scheme_id = body.get("scheme_id")

    if not task_id:
        raise HTTPException(status_code=400, detail="缺少 task_id")

    task_result = await db_session.execute(
        select(ProcessingTask).where(ProcessingTask.task_id == task_id)
    )
    processing_task = task_result.scalar_one_or_none()

    persisted_preferences = {}
    if processing_task and isinstance(processing_task.parameters, dict):
        persisted_preferences = (
            processing_task.parameters.get("cam_preferences", {}) or {}
        )

    mold_steel = body.get(
        "mold_steel",
        persisted_preferences.get("mold_steel", DEFAULT_CAM_PREFERENCES["mold_steel"]),
    )
    surface_quality = body.get(
        "surface_quality",
        persisted_preferences.get("surface_quality", DEFAULT_CAM_PREFERENCES["surface_quality"]),
    )
    controller = body.get(
        "controller",
        persisted_preferences.get("controller", DEFAULT_CAM_PREFERENCES["controller"]),
    )
    include_gcode = bool(
        body.get(
            "include_gcode",
            persisted_preferences.get("include_gcode", DEFAULT_CAM_PREFERENCES["include_gcode"]),
        )
    )

    task_view = await TaskQueryService.get_task_view(db_session, task_id)
    if not task_view:
        raise HTTPException(status_code=404, detail="任务不存在")
    if task_view.get("status") != "completed":
        raise HTTPException(status_code=400, detail="任务尚未完成，无法生成CAM计划")

    try:
        data = cam_bundle_service.build_bundle(
            task_view=task_view,
            scheme_id=scheme_id,
            mold_steel=mold_steel,
            surface_quality=surface_quality,
            controller=controller,
            include_gcode=include_gcode,
        )
        cam_preferences = {
            "mold_steel": mold_steel,
            "surface_quality": surface_quality,
            "controller": controller,
            "include_gcode": include_gcode,
        }
        if processing_task:
            parameters = processing_task.parameters if isinstance(processing_task.parameters, dict) else {}
            parameters["cam_preferences"] = cam_preferences
            parameters["cam_last_plan"] = {
                "scheme_id": data.get("scheme_id"),
                "generated_at": datetime.now().isoformat(),
            }
            processing_task.parameters = parameters
            await db_session.commit()

        return {"status": "success", "data": data, "cam_preferences": cam_preferences}
    except Exception as exc:
        logger.error(f"生成CAM准备包失败 task_id={task_id}: {exc}")
        raise HTTPException(status_code=500, detail=f"生成CAM准备包失败: {exc}")