endpoints.py

"""
FastAPI endpoints for the chatbot API service
"""
from datetime import datetime
from typing import List
from fastapi import APIRouter, HTTPException, Depends
from models import (
    ChatRequest, ChatResponse, SessionCreateResponse, 
    SessionResponse, HealthResponse, ErrorResponse, 
    MessageRole, ChatMessage
)
from session_manager import SessionManager
from chatbot_service import ChatbotService


# Create router
router = APIRouter()

# Global instances (will be initialized in main.py)
session_manager: SessionManager = None
chatbot_service: ChatbotService = None


def get_session_manager() -> SessionManager:
    """Dependency to get session manager instance"""
    if session_manager is None:
        raise HTTPException(status_code=500, detail="Session manager not initialized")
    return session_manager


def get_chatbot_service() -> ChatbotService:
    """Dependency to get chatbot service instance"""
    if chatbot_service is None:
        raise HTTPException(status_code=500, detail="Chatbot service not initialized")
    return chatbot_service


@router.post("/api/chat", response_model=ChatResponse)
async def chat_endpoint(
    request: ChatRequest,
    session_mgr: SessionManager = Depends(get_session_manager),
    chatbot: ChatbotService = Depends(get_chatbot_service)
):
    """
    Send a message to the chatbot and receive a response
    """
    try:
        # Get or create session
        session_id = request.session_id
        if session_id is None:
            # Create new session
            session_id = session_mgr.create_session()
        else:
            # Validate existing session
            if not session_mgr.session_exists(session_id):
                raise HTTPException(
                    status_code=404,
                    detail=f"Session {session_id} not found or expired"
                )
        
        # Add user message to session
        session_mgr.add_message_to_session(session_id, MessageRole.USER, request.message)
        
        # Get conversation history
        messages = session_mgr.get_session_messages(session_id)
        if messages is None:
            raise HTTPException(
                status_code=404,
                detail=f"Session {session_id} not found"
            )
        
        # Generate response from chatbot
        try:
            bot_response = chatbot.generate_response(messages)
        except Exception as e:
            raise HTTPException(
                status_code=500,
                detail=f"Failed to generate response: {str(e)}"
            )
        
        # Add bot response to session
        session_mgr.add_message_to_session(session_id, MessageRole.ASSISTANT, bot_response)
        
        return ChatResponse(
            response=bot_response,
            session_id=session_id,
            timestamp=datetime.utcnow()
        )
        
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(
            status_code=500,
            detail=f"Internal server error: {str(e)}"
        )


@router.post("/api/sessions", response_model=SessionCreateResponse)
async def create_session_endpoint(
    session_mgr: SessionManager = Depends(get_session_manager)
):
    """
    Create a new chat session
    """
    try:
        session_id = session_mgr.create_session()
        return SessionCreateResponse(
            session_id=session_id,
            created_at=datetime.utcnow()
        )
    except Exception as e:
        raise HTTPException(
            status_code=500,
            detail=f"Failed to create session: {str(e)}"
        )


@router.get("/api/sessions/{session_id}", response_model=SessionResponse)
async def get_session_endpoint(
    session_id: str,
    session_mgr: SessionManager = Depends(get_session_manager)
):
    """
    Retrieve conversation history for a specific session
    """
    try:
        # Validate session ID format (basic UUID validation)
        if len(session_id) != 36 or session_id.count('-') != 4:
            raise HTTPException(
                status_code=400,
                detail="Invalid session ID format"
            )
        
        session = session_mgr.get_session(session_id)
        if session is None:
            raise HTTPException(
                status_code=404,
                detail=f"Session {session_id} not found or expired"
            )
        
        return SessionResponse(
            session_id=session_id,
            messages=session.get_messages(),
            created_at=session.created_at
        )
        
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(
            status_code=500,
            detail=f"Failed to retrieve session: {str(e)}"
        )


@router.get("/api/health", response_model=HealthResponse)
async def health_check_endpoint(
    chatbot: ChatbotService = Depends(get_chatbot_service),
    session_mgr: SessionManager = Depends(get_session_manager)
):
    """
    API service health monitoring
    """
    try:
        # Perform health checks
        chatbot_healthy = chatbot.health_check()
        session_mgr_healthy = session_mgr is not None
        
        if chatbot_healthy and session_mgr_healthy:
            status = "healthy"
        else:
            status = "unhealthy"
            
        return HealthResponse(
            status=status,
            timestamp=datetime.utcnow(),
            version="1.0.0"
        )
        
    except Exception as e:
        raise HTTPException(
            status_code=503,
            detail=f"Service unavailable: {str(e)}"
        )


# Utility function to initialize global instances
def initialize_services(session_manager_instance: SessionManager, chatbot_service_instance: ChatbotService):
    """Initialize global service instances"""
    global session_manager, chatbot_service
    session_manager = session_manager_instance
    chatbot_service = chatbot_service_instance