"""
FastAPI service para el agente de retail de chat.
Permite interacción con múltiples clientes simultáneos (ej: WhatsApp).
"""
import logging
import os

from fastapi import Depends, FastAPI
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import JSONResponse
from starlette import status

# Importar settings primero: dispara la carga de .env + .env.{APP_ENV}
from config.settings import settings
from config.logging_config import setup_logging

from .routes import health, products, sessions, chat
from .auth import verify_token
from core.session_manager import session_manager

# Configurar logging (consola + archivos rotados en logs/)
_log_level = os.getenv("LOG_LEVEL", "INFO")
setup_logging(log_level=_log_level)
logger = logging.getLogger(__name__)

# Subpath configurable: las rutas se sirven bajo este prefijo tanto en
# acceso directo como a través de Nginx.
# Ejemplo: API_ROOT_PATH=/agent-marci → http://host:7206/agent-marci/chat/...
ROOT_PATH = os.getenv("API_ROOT_PATH", "")

# Documentación: solo habilitada si ENABLE_DOCS=true (desarrollo).
# En producción debe quedar en false para no exponer la API pública.
_docs_url    = f"{ROOT_PATH}/docs"         if settings.ENABLE_DOCS else None
_redoc_url   = f"{ROOT_PATH}/redoc"        if settings.ENABLE_DOCS else None
_openapi_url = f"{ROOT_PATH}/openapi.json" if settings.ENABLE_DOCS else None

app = FastAPI(
    title="Retail Agent Chat API (Marcimex)",
    description="API REST para asistente de ventas retail con soporte multi-cliente",
    version="2.0.0",
    docs_url=_docs_url,
    redoc_url=_redoc_url,
    openapi_url=_openapi_url,
)

# Configurar CORS para permitir integraciones con WhatsApp y otros servicios
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  # En producción, especificar orígenes permitidos
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Dependencia de autenticación JWT (Keycloak)
_auth = [Depends(verify_token)]

# Registrar routers con el subpath como prefijo
# health: público (sin autenticación, usado por balanceadores/health checks)
app.include_router(health.router,      prefix=ROOT_PATH)
# Resto de routers: protegidos con Bearer JWT de Keycloak
app.include_router(products.router,    prefix=ROOT_PATH)  # auth por endpoint (sync usa API Key, resto JWT)
app.include_router(sessions.router,    prefix=ROOT_PATH, dependencies=_auth)
app.include_router(chat.router,        prefix=ROOT_PATH)  # auth por endpoint (usa API Key)

@app.on_event("startup")
async def startup_event():
    """Evento de inicio de la aplicación."""
    logger.info("🚀 Retail Agent Chat API iniciada")

    # Garantizar que el índice vectorial de productos existe en Neo4j
    from rag_service.neo4j_client import neo4j_client
    neo4j_client.ensure_product_vector_index()

    # Inicializar herramientas MCP de forma asíncrona
    from mcp_integration.tools import get_tools_async
    await get_tools_async()

    # Iniciar el scheduler de tareas programadas
    #from tasks.scheduler import start_scheduler
    #start_scheduler()

    port = os.getenv("API_PORT", "7206")
    logger.info(f"📊 Documentación disponible en: http://localhost:{port}{ROOT_PATH}/docs")


@app.on_event("shutdown")
async def shutdown_event():
    """Evento de cierre de la aplicación."""
    from tasks.scheduler import stop_scheduler
    stop_scheduler()

    await session_manager.close()
    logger.info("👋 Retail Agent Chat API detenida")


# Manejador de errores global
@app.exception_handler(Exception)
async def global_exception_handler(request, exc):
    """Manejador global de excepciones."""
    logger.error(f"❌ Error no manejado: {str(exc)}")
    return JSONResponse(
        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
        content={
            "detail": "Error interno del servidor",
            "error": str(exc)
        }
    )