import asyncio
from fastapi import FastAPI, Request

from contextlib import asynccontextmanager

from fastapi.exceptions import ResponseValidationError, RequestValidationError
from pydantic import ValidationError

from starlette.exceptions import HTTPException as StarletteHTTPException
from fastapi.responses import JSONResponse
from app.database.session import sessionmanager

from app.routers import rotas

# Importação das Rotas


from app.config import URL_BD
from app.routers.router_registry import RouterRegistry

from fastapi.middleware.cors import CORSMiddleware
# from starlette.middleware.cors import CORSMiddleware


def init_app(init_db=True):
    lifespan = None

    if init_db:

        sessionmanager.init(URL_BD)

        @asynccontextmanager
        async def lifespan(app_init: FastAPI):
            yield
            if sessionmanager.is_initialized():  # Usa o método público para checar o engine
                await sessionmanager.close()

    server = FastAPI(title="Sonora Tecnologia Admin", lifespan=lifespan)

    server.add_middleware(
        CORSMiddleware,
        allow_origins=["http://localhost:4200",
                       "http://srv-captain--sistema/",
                       "https://srv-captain--sistema/",
                       "https://app.sonoraav.com.br",
                       "http://app.sonoraav.com.br",
                       ],  # Domínio do seu frontend
        allow_credentials=True,
        allow_methods=["*"],  # Permitir todos os métodos (ou especifique "POST" se necessário)
        allow_headers=["*"],
    )


    # Registro dinâmico das rotas
    router_registry = RouterRegistry(server, rotas.routers)
    router_registry.register_routers()

    return server


# Definindo o objeto "app" para estar disponível em todos os contextos
app = init_app()


@app.exception_handler(ResponseValidationError)
async def response_validation_exception_handler(request: Request, exc: ResponseValidationError):
    return JSONResponse(
        status_code=500,
        content={"message": "Erro ao validar a resposta do servidor."},
    )


@app.exception_handler(RequestValidationError)
async def validation_exception_handler(request: Request, exc: RequestValidationError):
    return JSONResponse(
        status_code=422,
        content={"detail": exc.errors()},
    )


@app.exception_handler(StarletteHTTPException)
async def starlette_http_exception_handler(request: Request, exc: StarletteHTTPException):
    return JSONResponse(
        status_code=exc.status_code,
        content={"detail": "API Administrativa Eventos"},
    )


@app.exception_handler(ValidationError)
async def pydantic_validation_exception_handler(request: Request, exc: ValidationError):
    return JSONResponse(
        status_code=422,
        content={"detail": exc.errors()},
    )


@app.exception_handler(asyncio.TimeoutError)
async def timeout_error_handler(request: Request, exc: asyncio.TimeoutError):
    return JSONResponse(
        status_code=504,
        content={"detail": "A operação excedeu o tempo limite."},
    )


if __name__ == "__main__":
    # Código de inicialização que só roda se o arquivo for executado diretamente
    app = init_app()
    # Exemplo de inicialização do servidor (se necessário)
    # import uvicorn
    # uvicorn.run("app", host="0.0.0.0", port=8000)