"""Single NinjaAPI instance: public ``/api/v1``, internal ``/internal/v1``, admin ``/admin/v1``.

One OpenAPI document covers all three (exported to ``spec/openapi.json``).
"""

from __future__ import annotations

import logging
from typing import Any

from django.db import OperationalError
from django.http import Http404, HttpRequest, HttpResponse
from ninja import NinjaAPI
from ninja.errors import AuthenticationError, HttpError, ValidationError

from snapfile.core.errors import ApiError, error_body
from snapfile_render import ENGINE_VERSION

log = logging.getLogger("snapfile.app")

api = NinjaAPI(
    title="Snapfile API",
    version=f"1.0 (engine {ENGINE_VERSION})",
    description=(
        "Snapfile: template editor backend and document render service.\n\n"
        "* `/api/v1` — public API for client services (API key: `Authorization: Bearer vk_live_…`).\n"
        "* `/internal/v1` — editor API (editor JWT from SSO handoff); also served as `/api/editor/v1`.\n"
        "* `/admin/v1` — super-admin API (session cookie); also served as `/api/admin/v1`.\n\n"
        'Errors use the envelope `{"error": {"code", "message", "details", "request_id"}}`.'
    ),
    docs_url="/api/docs",
    openapi_url="/api/openapi.json",
    urls_namespace="snapfile-api",
)


def _respond(
    request: HttpRequest,
    status: int,
    code: str,
    message: str,
    details: list[dict[str, Any]] | None = None,
    headers: dict[str, str] | None = None,
) -> HttpResponse:
    resp = api.create_response(
        request, error_body(code, message, details, getattr(request, "request_id", None)), status=status
    )
    for k, v in (headers or {}).items():
        resp[k] = v
    return resp


@api.exception_handler(ApiError)
def _api_error(request: HttpRequest, exc: ApiError) -> HttpResponse:
    return _respond(request, exc.status, exc.code, exc.message, exc.details, exc.headers)


@api.exception_handler(ValidationError)
def _validation_error(request: HttpRequest, exc: ValidationError) -> HttpResponse:
    details = []
    for err in exc.errors[:100]:
        loc = [str(p) for p in err.get("loc", []) if p not in ("body", "payload", "query", "path")]
        details.append({"pointer": "/" + "/".join(loc), "rule": err.get("type"), "message": err.get("msg")})
    return _respond(request, 422, "VALIDATION_FAILED", "Request validation failed", details)


@api.exception_handler(AuthenticationError)
def _auth_error(request: HttpRequest, exc: AuthenticationError) -> HttpResponse:
    return _respond(request, 401, "UNAUTHENTICATED", "Authentication required")


@api.exception_handler(HttpError)
def _http_error(request: HttpRequest, exc: HttpError) -> HttpResponse:
    code = {400: "BAD_REQUEST", 403: "FORBIDDEN", 404: "NOT_FOUND", 405: "METHOD_NOT_ALLOWED"}.get(
        exc.status_code, "ERROR"
    )
    return _respond(request, exc.status_code, code, str(exc))


@api.exception_handler(Http404)
def _not_found(request: HttpRequest, exc: Http404) -> HttpResponse:
    return _respond(request, 404, "NOT_FOUND", "Not found")


@api.exception_handler(OperationalError)
def _db_down(request: HttpRequest, exc: OperationalError) -> HttpResponse:
    log.exception("database error")
    return _respond(request, 503, "SERVICE_UNAVAILABLE", "Database is unavailable", headers={"Retry-After": "5"})


@api.exception_handler(Exception)
def _internal(request: HttpRequest, exc: Exception) -> HttpResponse:
    log.exception("unhandled error", extra={"request_id": getattr(request, "request_id", None)})
    return _respond(request, 500, "INTERNAL_ERROR", "Internal server error")


def register_routers() -> None:
    from snapfile.assets.api import router as assets_router
    from snapfile.auth_sso.api import router as auth_router
    from snapfile.core.admin_api import router as admin_router
    from snapfile.doctemplates.api import router as templates_router
    from snapfile.integration.api import router as public_router
    from snapfile.integration.internal_api import router as integration_router
    from snapfile.jobs.api import router as jobs_internal_router
    from snapfile.projects.api import router as project_router

    api.add_router("/api/v1/", public_router)
    api.add_router("/internal/v1/", auth_router)
    api.add_router("/internal/v1/", project_router)
    api.add_router("/internal/v1/", templates_router)
    api.add_router("/internal/v1/", assets_router)
    api.add_router("/internal/v1/", jobs_internal_router)
    api.add_router("/internal/v1/", integration_router)
    api.add_router("/admin/v1/", admin_router)


register_routers()
