# api/routes/chat_ai.py

from fastapi import APIRouter, Depends, HTTPException
from api.models.requests import ChatRequest, ChatMessage,SurveyRequest
from api.models.responses import ChatResponse,SurveyAgentResponse
from api.dependencies.auth import get_api_key
from src.llm.orchestrator import DroneBot, Message  # Adjust import as needed
from src.llm.agent.flight_assesment import DroneAssessmentAgent
import json
from logger import logger
router = APIRouter(
    prefix="/chat",
    tags=["chat"]
)

@router.post("/booking-assistant", response_model=ChatResponse)
async def chat_ai(
    request: ChatRequest,
    _: str = Depends(get_api_key)
):
    """Chat with DroneBot using query and history."""
    try:
        logger.info(f"Starting chat request with query: {request.query}")
        logger.info(f"History length: {len(request.history)}")
        
        # Extract customer metadata if provided
        customer_metadata = request.customer_metadata
        if customer_metadata:
            logger.info(f"Customer metadata provided: {list(customer_metadata.keys())}")
        else:
            logger.info("No customer metadata provided")
        
        # Convert to internal Message format
        history = [Message(role=msg.role, content=msg.content) for msg in request.history]
        logger.info(f"Converted history to internal format: {len(history)} messages")
        
        # Initialize DroneBot with history and customer metadata
        logger.info("Initializing DroneBot...")
        bot = DroneBot(history=history, use_openai_as_fallback=True, customer_metadata=customer_metadata)
        logger.info("DroneBot initialized successfully")
        
        # Get response from DroneBot
        logger.info("Calling DroneBot.chat()...")
        result = bot.chat(request.query)
        logger.info(f"DroneBot response received: {result}")
        
        # Validate result and final_message
        if not result or "final_message" not in result:
            logger.error(f"Invalid result from DroneBot: {result}")
            raise HTTPException(
                status_code=500,
                detail="Invalid response from DroneBot: missing final_message"
            )
        
        final_message = result["final_message"]
        logger.info(f"Final message extracted: {final_message}")
        
        if not final_message or not isinstance(final_message, str):
            logger.error(f"Final message is not a valid string: {type(final_message)} - {final_message}")
            raise HTTPException(
                status_code=500,
                detail="Invalid response from DroneBot: final_message is not a valid string"
            )
        
        try:
            logger.info("Attempting to parse final_message as JSON...")
            message = json.loads(final_message)
            logger.info("JSON parsing successful")
        except json.JSONDecodeError as json_error:
            logger.warning(f"JSON decode error: {json_error}")
            logger.warning(f"Raw final_message: {final_message}")
            # If JSON parsing fails, create a fallback structure
            message = {
                "message": final_message,
                "options": None,
                "requires_selection": False,
                "end": "in_progress",
                "form": {}
            }
            logger.info("Created fallback message structure")
        
        logger.info(f"Final message to return: {message}")
        return ChatResponse(
            status="success",
            message=message
        )
    except HTTPException:
        logger.error("Re-raising HTTPException")
        raise
    except Exception as e:
        logger.error(f"Unexpected error in chat_ai: {str(e)}", exc_info=True)
        raise HTTPException(
            status_code=500,
            detail=str(e)
        )


@router.post("/analyse-survey", response_model=SurveyAgentResponse)
async def run_survey_agent(
    request: SurveyRequest,
    _: str = Depends(get_api_key)
):
    """Chat with DroneBot using query and history."""
    try:
        booking_form_input = request.booking_form_input
        #from test2 import booking_form_input
        agent = DroneAssessmentAgent()
        result = await agent.run(booking_form_input)
        return SurveyAgentResponse(
            status="success",
            result=result
        )
    except Exception as e:
        raise HTTPException(
            status_code=500,
            detail=str(e)
        )