from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import JSONResponse
import logging

from core.database import db_manager
from core.auth import initialize_auth
from core.exceptions import PietanzaNotFoundError, ValidationError, DatabaseError
from dependencies import get_config
from routes import pietanze

# Configura logging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)

# Crea applicazione FastAPI
app = FastAPI(
    title="API Simple Mensa",
    description="API per il sistema di prenotazione mensa",
    version="1.0.0",
    docs_url="/docs",
    redoc_url="/redoc"
)

# Carica configurazione
config = get_config()

# Configura CORS
app.add_middleware(
    CORSMiddleware,
    allow_origins=config['cors']['allow_origins'],
    allow_credentials=config['cors']['allow_credentials'],
    allow_methods=config['cors']['allow_methods'],
    allow_headers=config['cors']['allow_headers'],
)

# Includi router
app.include_router(pietanze.router, prefix="/api/v1")

# Gestori di eccezioni
@app.exception_handler(PietanzaNotFoundError)
async def pietanza_not_found_handler(request, exc):
    return JSONResponse(
        status_code=exc.status_code,
        content={"errore": "Pietanza non trovata", "dettaglio": exc.detail}
    )

@app.exception_handler(ValidationError)
async def validation_error_handler(request, exc):
    return JSONResponse(
        status_code=exc.status_code,
        content={"errore": "Errore di validazione", "dettaglio": exc.detail}
    )

@app.exception_handler(DatabaseError)
async def database_error_handler(request, exc):
    return JSONResponse(
        status_code=exc.status_code,
        content={"errore": "Errore database", "dettaglio": exc.detail}
    )

# Eventi di avvio e spegnimento
@app.on_event("startup")
async def startup_event():
    """Inizializza applicazione all'avvio"""
    try:
        # Inizializza database
        await db_manager.initialize(config['database'])
        logger.info("Database inizializzato")
        
        # Inizializza autenticazione
        initialize_auth(config['auth'])
        logger.info("Autenticazione inizializzata")
        
        logger.info("Avvio applicazione completato")
    except Exception as e:
        logger.error(f"Errore nell'inizializzazione dell'applicazione: {e}")
        raise

@app.on_event("shutdown")
async def shutdown_event():
    """Pulizia alla chiusura dell'applicazione"""
    try:
        await db_manager.close()
        logger.info("Spegnimento applicazione completato")
    except Exception as e:
        logger.error(f"Errore durante lo spegnimento: {e}")

# Endpoint di controllo stato
@app.get("/health")
async def health_check():
    """Endpoint di controllo stato dell'applicazione"""
    return {
        "stato": "funzionante",
        "servizio": "simple-mensa-api",
        "versione": "1.0.0"
    }

# Endpoint principale
@app.get("/")
async def root():
    """Endpoint principale con informazioni API"""
    return {
        "messaggio": "API Simple Mensa",
        "versione": "1.0.0",
        "documentazione": "/docs",
        "stato": "/health"
    }

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(
        "main:app",
        host=config['server']['host'],
        port=config['server']['port'],
        reload=config['server']['reload'],
    )