main.py

"""
Main FastAPI application for the LangGraph Chatbot API Service
"""
import os
import asyncio
from contextlib import asynccontextmanager
from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import JSONResponse
from dotenv import load_dotenv
from datetime import datetime

from session_manager import SessionManager
from chatbot_service import ChatbotService
from endpoints import router, initialize_services
from models import ErrorResponse, ErrorDetail

# Load environment variables
load_dotenv()

# Global service instances
session_manager_instance: SessionManager = None
chatbot_service_instance: ChatbotService = None


@asynccontextmanager
async def lifespan(app: FastAPI):
    """Lifespan context manager for startup and shutdown events"""
    # Startup
    global session_manager_instance, chatbot_service_instance
    
    # Initialize services
    try:
        # Get OpenAI API key
        openai_api_key = os.getenv("OPENAI_API_KEY")
        if not openai_api_key:
            raise ValueError("OPENAI_API_KEY environment variable is required")
        
        # Initialize session manager
        session_timeout_hours = int(os.getenv("SESSION_TIMEOUT_HOURS", "1"))
        session_manager_instance = SessionManager(session_timeout_hours=session_timeout_hours)
        
        # Initialize chatbot service
        model = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
        temperature = float(os.getenv("OPENAI_TEMPERATURE", "0"))
        chatbot_service_instance = ChatbotService(
            openai_api_key=openai_api_key,
            model=model,
            temperature=temperature
        )
        
        # Initialize endpoints with service instances
        initialize_services(session_manager_instance, chatbot_service_instance)
        
        print(f"✅ Chatbot API Service initialized successfully")
        print(f"   - Model: {model}")
        print(f"   - Temperature: {temperature}")
        print(f"   - Session timeout: {session_timeout_hours} hours")
        
        # Start background task for session cleanup
        cleanup_task = asyncio.create_task(session_cleanup_task())
        
    except Exception as e:
        print(f"❌ Failed to initialize services: {str(e)}")
        raise
    
    yield
    
    # Shutdown
    try:
        cleanup_task.cancel()
        print("🛑 Chatbot API Service shutting down...")
    except Exception as e:
        print(f"⚠️  Error during shutdown: {str(e)}")


async def session_cleanup_task():
    """Background task to cleanup expired sessions"""
    while True:
        try:
            if session_manager_instance:
                cleaned_count = session_manager_instance.cleanup_expired_sessions()
                if cleaned_count > 0:
                    print(f"🧹 Cleaned up {cleaned_count} expired sessions")
            
            # Run cleanup every 30 minutes
            await asyncio.sleep(1800)
            
        except asyncio.CancelledError:
            print("🛑 Session cleanup task cancelled")
            break
        except Exception as e:
            print(f"⚠️  Error in session cleanup: {str(e)}")
            await asyncio.sleep(60)  # Wait 1 minute before retrying


# Create FastAPI app
app = FastAPI(
    title="LangGraph Chatbot API",
    description="A simple REST API service for the LangGraph chatbot using OpenAI GPT-4o-mini",
    version="1.0.0",
    lifespan=lifespan
)

# Add CORS middleware
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  # Configure this properly for production
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Include API routes
app.include_router(router)


# Global exception handler
@app.exception_handler(HTTPException)
async def http_exception_handler(request, exc):
    """Handle HTTP exceptions and return standardized error format"""
    error_response = ErrorResponse(
        error=ErrorDetail(
            code=f"HTTP_{exc.status_code}",
            message=exc.detail,
            details=None
        ),
        timestamp=datetime.utcnow()
    )
    return JSONResponse(
        status_code=exc.status_code,
        content=error_response.model_dump(mode='json')
    )


@app.exception_handler(Exception)
async def general_exception_handler(request, exc):
    """Handle general exceptions"""
    error_response = ErrorResponse(
        error=ErrorDetail(
            code="INTERNAL_SERVER_ERROR",
            message="An unexpected error occurred",
            details=str(exc) if os.getenv("DEBUG", "false").lower() == "true" else None
        ),
        timestamp=datetime.utcnow()
    )
    return JSONResponse(
        status_code=500,
        content=error_response.model_dump(mode='json')
    )


# Root endpoint
@app.get("/")
async def root():
    """Root endpoint with API information"""
    return {
        "message": "LangGraph Chatbot API Service",
        "version": "1.0.0",
        "docs": "/docs",
        "health": "/api/health",
        "timestamp": datetime.utcnow()
    }


if __name__ == "__main__":
    import uvicorn
    
    # Configuration
    host = os.getenv("HOST", "0.0.0.0")
    port = int(os.getenv("PORT", "8000"))
    debug = os.getenv("DEBUG", "false").lower() == "true"
    
    print(f"🚀 Starting LangGraph Chatbot API Service...")
    print(f"   - Host: {host}")
    print(f"   - Port: {port}")
    print(f"   - Debug: {debug}")
    print(f"   - Docs: http://{host}:{port}/docs")
    
    uvicorn.run(
        "main:app",
        host=host,
        port=port,
        reload=debug,
        log_level="info"
    )