"""Точка входа FastAPI: API + раздача собранной SPA-статики с того же контейнера."""

from contextlib import AsyncExitStack, asynccontextmanager

from fastapi import FastAPI, Request
from fastapi.middleware.cors import CORSMiddleware
from fastapi.staticfiles import StaticFiles

from fastapi.responses import FileResponse
from app.api import events_routes
from app.api import admin_routes
from app.api import me_routes
from app.api.auth_routes import router as auth_router
from app.api.routes import router as api_router
from app.api.routes import top_router
from app.config import get_settings
from app.worker.celery_app import celery_app  # noqa: F401 — регистрирует задачи в очереди import'ов


def create_app() -> FastAPI:
    settings = get_settings()

    # MCP (docs/07): embedded FastMCP на /mcp streamable-http, гейт по Bearer.
    # Монтируется всегда: персональные ключи (mcp_...) работают и без
    # MCP_TOKEN; статический env-токен — опциональный суперадмин-бэкдор.
    # Session manager FastMCP требует явного запуска: enter_async_context
    # в lifespan держит его открытым всё время жизни приложения.
    from app.mcp.server import McpTokenGuard, build_mcp_server

    raw_mcp_app = build_mcp_server().streamable_http_app()
    mcp_mount = McpTokenGuard(raw_mcp_app, settings.mcp_token or None)

    lifespan_kwargs: dict = {}

    @asynccontextmanager
    async def _lifespan(app: FastAPI):
        async with AsyncExitStack() as stack:
            await stack.enter_async_context(
                raw_mcp_app.router.lifespan_context(raw_mcp_app)
            )
            yield

    lifespan_kwargs["lifespan"] = _lifespan

    app = FastAPI(
        title=settings.app_name, docs_url="/api/docs", openapi_url="/api/openapi.json",
        **lifespan_kwargs,
    )

    # Локализация серверных ошибок по Accept-Language (i18n.md хендбука).
    from starlette.exceptions import HTTPException as StarletteHTTPException

    from app.i18n_server import localize_detail

    @app.exception_handler(StarletteHTTPException)
    async def localized_http_exception(request: Request, exc: StarletteHTTPException):
        from fastapi.responses import JSONResponse

        return JSONResponse(
            status_code=exc.status_code,
            content={"detail": localize_detail(request, exc.detail)},
            headers=getattr(exc, "headers", None),
        )

    # В проде SPA с того же origin, CORS нужен только dev-серверу vite.
    app.add_middleware(
        CORSMiddleware,
        allow_origins=settings.cors_origins,
        allow_credentials=True,
        allow_methods=["*"],
        allow_headers=["*"],
    )

    app.include_router(api_router)
    app.include_router(top_router)
    app.include_router(auth_router)
    app.include_router(events_routes.router)
    app.include_router(admin_routes.router)
    app.include_router(me_routes.router)

    # MCP монтируется до SPA catch-all (иначе GET /mcp съел бы роутер SPA).
    # Именно Route, не Mount: Mount('/mcp') матчит только '/mcp/...' (regex
    # с trailing slash), точный POST /mcp провалился бы в SPA (GET index /
    # POST 405); Route отдаёт в саб-апп путь без root_path-трюков.
    # /mcp — исторический маршрут; /mcp-protocol/ — конвенция хендбука
    # (10-platform/mcp.md, слэш значим для реверс-прокси).
    from starlette.routing import Route

    class McpPathRewriter:
        """ASGI-обёртка: FastMCP-саб-апп роутит только "/mcp",
        внешний маршрут (/mcp-protocol/, конвенция хендбука) существует
        только до этой точки — скармливаем саб-аппу канонический путь."""

        def __init__(self, app):
            self.app = app

        async def __call__(self, scope, receive, send):
            await self.app({**scope, "path": "/mcp"}, receive, send)

    for mcp_path in ("/mcp", "/mcp-protocol/"):
        app.router.routes.append(
            Route(
                mcp_path, McpPathRewriter(mcp_mount),
                methods=["GET", "POST", "DELETE", "OPTIONS"],
                include_in_schema=False,
            )
        )

    # Собранная SPA: в Docker-образе кладётся в spa_static/. Если собранной
    # статики нет (локальный запуск api без фронта) — просто пропускаем.
    spa = settings.spa_dist_dir
    if (spa / "index.html").exists():
        # Не mount(StaticFiles, html=True): он отдаёт 404 на произвольных путях,
        # а vue-router'у (например /oauth/callback) нужен fallback на index.html.
        @app.get("/{spa_path:path}", include_in_schema=False)
        def spa_fallback(spa_path: str) -> FileResponse:
            candidate = (spa / spa_path).resolve()
            # Только файлы внутри каталога SPA (без ../ побегов); роутеры
            # /api/* и /auth/* зарегистрированы раньше и матчатся первыми.
            if spa_path and candidate.is_file() and candidate.is_relative_to(spa.resolve()):
                return FileResponse(candidate)
            return FileResponse(spa / "index.html")
    else:
        @app.get("/")
        def root() -> dict:
            return {
                "service": settings.app_name,
                "docs": "/api/docs",
                "health": "/api/healthz",
            }

    return app


app = create_app()