main.py

import asyncio
import os
import sys
from contextlib import asynccontextmanager

from fastapi import APIRouter, FastAPI, Request
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import JSONResponse

from app.admin.api import admin_router
from app.auth.api import auth_router
from app.billing.api import billing_router
from app.example.api import example_router
from app.monitoring.api import monitoring_router
from app.tenants.api import tenants_router
from app.users.api import users_router
from core.config import config
from core.database import init_db
from core.logging import logger
from core.redis.redis_client import AsyncRedisClient

# Регистрация моделей для create_all
from core.schemas import RefreshToken, Subscription, Tenant, User
from core.security import SecurityHeadersMiddleware
from core.utils.sanitize import sanitize_for_logging


async def _demo_reset_loop(interval_minutes: int):
    """Периодический сброс демо-данных в норму."""
    from scripts.seed_demo import run_seed_demo

    while True:
        await asyncio.sleep(interval_minutes * 60)
        try:
            await run_seed_demo()
            logger.info(f"Demo data reset (interval={interval_minutes}m)")
        except Exception as e:
            logger.warning(f"Demo reset failed: {sanitize_for_logging(str(e))}")


@asynccontextmanager
async def lifespan(app: FastAPI):
    # Валидация JWT secret в production
    if not os.getenv("TESTING") and not config.auth.is_production_secret():
        if os.getenv("ENV", "development") == "production":
            logger.error("JWT_SECRET не задан или используется dev-secret в production!")
            sys.exit(1)

    # Инициализация таблиц БД (для dev/Docker) — в тестах пропускаем (event loop)
    if not os.getenv("TESTING"):
        try:
            await init_db()
        except Exception as e:
            logger.warning(f"БД недоступна на старте: {sanitize_for_logging(str(e))}")

    if not os.getenv("TESTING"):
        client = await AsyncRedisClient.get_client()
        try:
            await client.ping()
        except Exception:
            logger.warning("Redis недоступен на старте")

    # Автосброс демо-данных: DEMO_AUTO_RESET_MINUTES=15
    reset_task = None
    if not os.getenv("TESTING"):
        try:
            interval = int(os.getenv("DEMO_AUTO_RESET_MINUTES", "0"))
            if interval > 0:
                from scripts.seed_demo import run_seed_demo

                try:
                    await run_seed_demo()
                    logger.info("Demo data loaded on startup")
                except Exception as e:
                    logger.warning(f"Demo seed on startup failed: {sanitize_for_logging(str(e))}")
                reset_task = asyncio.create_task(_demo_reset_loop(interval))
                logger.info(f"Demo auto-reset enabled: every {interval} minutes")
        except ValueError:
            pass

    yield

    if reset_task is not None:
        reset_task.cancel()
        try:
            await reset_task
        except asyncio.CancelledError:
            pass
    if not os.getenv("TESTING"):
        await AsyncRedisClient.close()


def _global_exception_handler(request: Request, exc: Exception) -> JSONResponse:
    """Глобальный обработчик: ловит только необработанные Exception (не HTTPException/ValidationError)."""
    from core.logging import logger

    logger.error(
        f"Unhandled exception: {sanitize_for_logging(str(exc))}",
        exc_info=os.getenv("ENV") == "development",
    )
    return JSONResponse(
        status_code=500,
        content={"detail": "Внутренняя ошибка сервера. Обратитесь к администратору."},
    )


app = FastAPI(
    title=config.app.title or "SaaS Skeleton API",
    version=config.app.version or "0.1.0",
    description="Production-ready SaaS backend: auth, multi-tenant, billing, admin",
    docs_url="/api/docs",
    redoc_url="/api/redoc",
    openapi_url="/api/openapi.json",
    lifespan=lifespan,
)

app.add_exception_handler(Exception, _global_exception_handler)

# Health/metrics на корне для k8s/Docker (livenessProbe, readinessProbe)
from app.monitoring.api.monitoring_api import health_liveness, health_readiness, metrics

app.get("/health")(health_liveness)
app.get("/ready")(health_readiness)
app.get("/metrics")(metrics)

main_router = APIRouter(prefix="/api/v1")
main_router.include_router(example_router)
main_router.include_router(users_router)
main_router.include_router(tenants_router)
main_router.include_router(auth_router)
main_router.include_router(admin_router)
main_router.include_router(billing_router)
main_router.include_router(monitoring_router)
app.include_router(main_router)


# Логирование middleware — отключаем в тестах (event loop conflicts)
if not os.getenv("TESTING"):
    from lynx_logger.middleware import FastAPILoggingMiddleware

    middleware_logger = logger.get_logger()
    if middleware_logger:
        middleware = FastAPILoggingMiddleware(middleware_logger)
        app.middleware("http")(middleware(app))


# Security headers (CSP, HSTS, X-Frame-Options и др.)
app.add_middleware(SecurityHeadersMiddleware)

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,
    expose_headers=config.cors.expose_headers,
)

# Метрики Prometheus (RPS, latency, ошибки) — после CORS
if not os.getenv("TESTING"):
    from app.monitoring.middleware import PrometheusMiddleware

    app.add_middleware(PrometheusMiddleware)