"""Generate API endpoint for configuration generation.

This module provides the /generate endpoint for generating SQL configuration.
"""

from fastapi import APIRouter, HTTPException, status
from loguru import logger

from app.models.request import GenerateRequest
from app.models.response import GenerateResponse, ErrorResponse
from app.services.config_service import ConfigService
from app.api.execute import store_session_sql  # Import SQL storage function

# Create router
router = APIRouter()


@router.post(
    "/generate",
    response_model=GenerateResponse,
    responses={
        400: {"model": ErrorResponse, "description": "Invalid request"},
        500: {"model": ErrorResponse, "description": "Internal server error"}
    },
    summary="Generate SQL configuration",
    description="Generate SQL configuration based on structured requirements"
)
async def generate_config(request: GenerateRequest) -> GenerateResponse:
    """Generate SQL configuration based on structured requirements.

    This endpoint takes structured requirements from the analysis phase
    and generates SQL configuration statements using Claude AI.

    Args:
        request: GenerateRequest with session_id and requirements

    Returns:
        GenerateResponse with session_id, status, and generated config

    Raises:
        HTTPException: 400 for invalid input, 500 for processing errors
    """
    try:
        # Validate requirements
        if not request.requirements:
            raise HTTPException(
                status_code=status.HTTP_400_BAD_REQUEST,
                detail={
                    "code": "EMPTY_REQUIREMENTS",
                    "message": "requirements cannot be empty",
                    "session_id": request.session_id
                }
            )

        logger.info(f"[{request.session_id}] Processing generate request")

        # Create service and generate config
        service = ConfigService()
        result = await service.generate(
            requirements=request.requirements,
            session_id=request.session_id
        )

        # Store generated SQL for later execution
        if result and result.get("配置方案") and result["配置方案"].get("sql_list"):
            sql_list = result["配置方案"]["sql_list"]
            store_session_sql(request.session_id, sql_list)
            logger.info(f"[{request.session_id}] Stored {len(sql_list)} SQL statements for execution")

        logger.success(f"[{request.session_id}] Config generation completed")

        return GenerateResponse(
            session_id=request.session_id,
            status="success",
            data=result
        )

    except HTTPException:
        # Re-raise HTTP exceptions
        raise

    except ValueError as e:
        logger.error(f"[{request.session_id}] Validation error: {e}")
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail={
                "code": "VALIDATION_ERROR",
                "message": str(e),
                "session_id": request.session_id
            }
        )

    except Exception as e:
        logger.error(f"[{request.session_id}] Config generation failed: {e}")
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail={
                "code": "GENERATION_FAILED",
                "message": f"Failed to generate config: {str(e)}",
                "session_id": request.session_id
            }
        )