"""
Main application entry point for MangoIT RAG-based AI Chatbot
"""

import os
import asyncio
import logging
from fastapi import FastAPI, Request
from fastapi.middleware.cors import CORSMiddleware
from dotenv import load_dotenv

from routers import chat, user, embedding, rag, frontend, appointment, admin, faqs
from utils.url_config import ALLOWED_ORIGINS
from api.firecrawl_sitemap_to_markdown import create_markdown_files

# Set up detailed logging for debugging
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger("uvicorn")
logger.setLevel(logging.DEBUG)

# Load environment variables
load_dotenv()

# Create FastAPI application
app = FastAPI(
    title="MangoIT RAG-based AI Chatbot",
    description="AI-powered chatbot with RAG capabilities for MangoIT Solutions",
    version="1.0.0",
    docs_url="/docs",
    redoc_url="/redoc"
)

# Add CORS middleware
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  # Allow all origins temporarily for testing
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"]
)

# Add request logging middleware
@app.middleware("http")
async def log_requests(request: Request, call_next):
    logger.debug(f"Request: {request.method} {request.url}")
    logger.debug(f"Headers: {request.headers}")
    
    # For POST requests, try to log the body
    if request.method == "POST":
        try:
            body = await request.body()
            logger.debug(f"Request body: {body}")
        except Exception as e:
            logger.debug(f"Could not log request body: {e}")
    
    response = await call_next(request)
    logger.debug(f"Response status: {response.status_code}")
    
    return response

# Include routers
app.include_router(chat.router)
app.include_router(user.router)
app.include_router(embedding.router)
app.include_router(rag.router)
app.include_router(frontend.router)
app.include_router(appointment.router)
app.include_router(admin.router)
app.include_router(faqs.router)


# Additional endpoints
@app.post("/crawl-sitemap")
async def crawl_sitemap_endpoint():
    """Crawl sitemap and create markdown files"""
    try:
        await asyncio.to_thread(lambda: asyncio.run(create_markdown_files()))
        return {"status": "success", "message": "Markdown files created"}
    except Exception as e:
        return {"status": "error", "message": str(e)}


@app.get("/")
async def root():
    """Root endpoint"""
    return {
        "name": "MangoIT RAG-based AI Chatbot",
        "version": "1.0.0",
        "status": "running"
    }


# Test endpoints for debugging
@app.get("/test")
async def test_get():
    """Test GET endpoint"""
    return {"status": "success", "message": "Test GET endpoint working"}


@app.post("/test")
async def test_post(request: Request):
    """Test POST endpoint"""
    try:
        body = await request.json()
        return {"status": "success", "message": "Test POST endpoint working", "received": body}
    except Exception as e:
        return {"status": "error", "message": f"Error parsing request body: {str(e)}"}


if __name__ == "__main__":
    import uvicorn
    uvicorn.run("main:app", host="127.0.0.1", port=8000, reload=True)