"""Super-admin API (TZ 2.8.7): projects, API keys, editor entry, diagnostics. Session cookie + CSRF."""

from __future__ import annotations

import re
from typing import Any

from django.conf import settings
from django.contrib.auth import login as django_login
from django.contrib.auth import logout as django_logout
from django.db import IntegrityError
from django.http import HttpRequest, JsonResponse
from django.middleware.csrf import get_token
from django.utils import timezone
from ninja import Field, Router, Schema, Status
from ninja.security import SessionAuth

from snapfile.core import ids
from snapfile.core.audit import Actor, audit
from snapfile.core.errors import ApiError
from snapfile.core.superadmin import check_credentials, is_blocked, superadmin_enabled
from snapfile.integration.keys import issue_key, key_dict, rotate_key
from snapfile.integration.models import SCOPES, ApiKey
from snapfile.projects.models import DEFAULT_SETTINGS, Project

SLUG_RE = re.compile(r"^[a-z0-9][a-z0-9-]{0,63}$")


class SuperAdminAuth(SessionAuth):
    def authenticate(self, request: HttpRequest, key: str | None) -> Any:
        if not superadmin_enabled():
            raise ApiError(404, "NOT_FOUND", "Admin API is disabled")
        user = getattr(request, "user", None)
        if user is not None and user.is_authenticated and getattr(user, "login", None) == settings.SUPERADMIN_LOGIN:
            return user
        return None


router = Router(auth=SuperAdminAuth(), tags=["admin"])
ADMIN = Actor("superadmin", "superadmin", "Super admin")


class LoginIn(Schema):
    login: str
    password: str
    totp: str | None = None


class ProjectIn(Schema):
    slug: str = Field(..., max_length=64)
    name: str = Field(..., max_length=255)
    client_name: str | None = None
    client_base_url: str | None = None
    introspection_url: str | None = None
    webhook_url: str | None = None
    allowed_origins: list[str] | None = None
    settings: dict[str, Any] | None = None


class ProjectPatch(Schema):
    name: str | None = None
    client_name: str | None = None
    client_base_url: str | None = None
    introspection_url: str | None = None
    webhook_url: str | None = None
    allowed_origins: list[str] | None = None
    settings: dict[str, Any] | None = None
    status: str | None = None


class KeyIn(Schema):
    name: str = Field(..., max_length=128)
    scopes: list[str] | None = None
    env: str = "live"
    require_signature: bool = False


class EditorSessionIn(Schema):
    template: str | None = None


def _project_stats(p: Project) -> dict[str, Any]:
    from datetime import timedelta

    from snapfile.jobs.models import RenderJob

    now = timezone.now()
    jobs = RenderJob.objects.filter(project=p, kind="render")
    last = jobs.order_by("-created_at").values_list("created_at", flat=True).first()
    return {
        "renders_7d": jobs.filter(created_at__gte=now - timedelta(days=7)).count(),
        "failed_24h": jobs.filter(created_at__gte=now - timedelta(hours=24), status="failed").count(),
        "last_render_at": last.isoformat() if last else None,
        "keys_active": ApiKey.objects.filter(project=p, revoked_at__isnull=True).count(),
    }


def project_dict(p: Project, *, stats: bool = True) -> dict[str, Any]:
    return {
        "id": ids.encode("prj", p.id),
        "slug": p.slug,
        "name": p.name,
        "client_name": p.client_name,
        "client_base_url": p.client_base_url,
        "introspection_url": p.introspection_url,
        "webhook_url": p.webhook_url,
        "allowed_origins": p.allowed_origins or [],
        "settings": p.effective_settings,
        "status": p.status,
        "created_at": p.created_at.isoformat(),
        "templates": p.templates.filter(deleted_at__isnull=True).count(),
        **({"stats": _project_stats(p)} if stats else {}),
    }


def _project(project_id: str) -> Project:
    q = Project.objects.alive()
    p = q.filter(slug=project_id).first()
    if p is None:
        try:
            p = q.filter(pk=ids.decode("prj", project_id)).first()
        except ids.InvalidId:
            p = None
    if p is None:
        raise ApiError(404, "NOT_FOUND", "Project not found")
    return p


@router.post("login", auth=None, summary="Super-admin login (.env credentials) -> session cookie")
def login(request: HttpRequest, body: LoginIn) -> Any:
    if not superadmin_enabled():
        raise ApiError(404, "NOT_FOUND", "Admin API is disabled")
    if is_blocked(body.login, request):
        raise ApiError(429, "RATE_LIMITED", "Too many failed attempts, try again later", headers={"Retry-After": "900"})
    user = check_credentials(body.login, body.password, request)
    if user is None:
        raise ApiError(401, "UNAUTHENTICATED", "Invalid login or password")
    django_login(request, user, backend="snapfile.core.superadmin.EnvSuperAdminBackend")
    audit("superadmin.login", ADMIN, request=request)
    return {"ok": True, "login": user.login, "csrfToken": get_token(request)}


@router.post("logout", summary="Logout")
def logout(request: HttpRequest) -> Any:
    django_logout(request)
    return {"ok": True}


@router.get("me", summary="Current super-admin")
def me(request: HttpRequest) -> Any:
    return {"login": request.user.login, "csrfToken": get_token(request)}  # type: ignore[union-attr]


@router.get("projects", summary="List projects")
def list_projects(request: HttpRequest) -> Any:
    return {"data": [project_dict(p) for p in Project.objects.alive().order_by("slug")]}  # few projects per install


@router.post("projects", response={201: dict}, summary="Create a project")
def create_project(request: HttpRequest, body: ProjectIn) -> Any:
    if not SLUG_RE.match(body.slug):
        raise ApiError(422, "VALIDATION_FAILED", "slug must match [a-z0-9-]", [{"pointer": "/slug"}])
    try:
        p = Project.objects.create(
            slug=body.slug,
            name=body.name,
            client_name=body.client_name,
            client_base_url=body.client_base_url,
            introspection_url=body.introspection_url,
            webhook_url=body.webhook_url,
            allowed_origins=body.allowed_origins,
            settings={**DEFAULT_SETTINGS, **(body.settings or {})},
        )
    except IntegrityError as exc:
        raise ApiError(409, "KEY_EXISTS", f"Project {body.slug!r} already exists") from exc
    audit("project.create", ADMIN, project_id=p.id, subject_type="project", subject_id=p.id, request=request)
    return Status(201, {"project": project_dict(p)})


@router.get("projects/{project_id}", summary="Project details")
def get_project(request: HttpRequest, project_id: str) -> Any:
    return {"project": project_dict(_project(project_id))}


@router.patch("projects/{project_id}", summary="Update a project (suspend, limits, origins, ...)")
def patch_project(request: HttpRequest, project_id: str, body: ProjectPatch) -> Any:
    p = _project(project_id)
    data = body.dict(exclude_unset=True)
    if "settings" in data:
        p.settings = {**(p.settings or {}), **(data.pop("settings") or {})}
    if "status" in data and data["status"] not in ("active", "suspended"):
        raise ApiError(422, "VALIDATION_FAILED", "status must be active or suspended")
    for k, v in data.items():
        setattr(p, k, v)
    p.save()
    audit(
        "project.update",
        ADMIN,
        project_id=p.id,
        subject_type="project",
        subject_id=p.id,
        changes=body.dict(exclude_unset=True),
        request=request,
    )
    return {"project": project_dict(p)}


@router.delete("projects/{project_id}", response={204: None}, summary="Soft-delete a project")
def delete_project(request: HttpRequest, project_id: str) -> Any:
    p = _project(project_id)
    p.deleted_at = timezone.now()
    p.save(update_fields=["deleted_at", "updated_at"])
    audit("project.delete", ADMIN, project_id=p.id, subject_type="project", subject_id=p.id, request=request)
    return Status(204, None)


@router.get("projects/{project_id}/api-keys", summary="List API keys of a project")
def list_keys(request: HttpRequest, project_id: str) -> Any:
    p = _project(project_id)
    return {"data": [key_dict(k) for k in ApiKey.objects.filter(project=p).order_by("-id")]}


@router.post("projects/{project_id}/api-keys", response={201: dict}, summary="Create an API key (secret shown once)")
def create_key(request: HttpRequest, project_id: str, body: KeyIn) -> Any:
    p = _project(project_id)
    bad = [s for s in (body.scopes or []) if s not in SCOPES]
    if bad or body.env not in ("live", "test"):
        raise ApiError(422, "VALIDATION_FAILED", f"Unknown scopes: {bad}" if bad else "env must be live or test")
    issued = issue_key(p, body.name, body.scopes, env=body.env, require_signature=body.require_signature)
    audit("api_key.create", ADMIN, project_id=p.id, subject_type="api_key", subject_id=issued.key.id, request=request)
    return Status(
        201, {"api_key": {**key_dict(issued.key), "secret": issued.secret, "hmac_secret": issued.hmac_secret}}
    )


def _key(key_id: str) -> ApiKey:
    try:
        uid = ids.decode("key", key_id)
    except ids.InvalidId as exc:
        raise ApiError(404, "NOT_FOUND", "API key not found") from exc
    k = ApiKey.objects.select_related("project").filter(pk=uid).first()
    if k is None:
        raise ApiError(404, "NOT_FOUND", "API key not found")
    return k


@router.post("api-keys/{key_id}/rotate", response={201: dict}, summary="Rotate a key (old one valid for 7 days)")
def rotate(request: HttpRequest, key_id: str) -> Any:
    old = _key(key_id)
    issued = rotate_key(old)
    audit(
        "api_key.rotate", ADMIN, project_id=old.project_id, subject_type="api_key", subject_id=old.id, request=request
    )
    return Status(
        201,
        {
            "api_key": {**key_dict(issued.key), "secret": issued.secret, "hmac_secret": issued.hmac_secret},
            "previous": key_dict(ApiKey.objects.get(pk=old.pk)),
        },
    )


@router.delete("api-keys/{key_id}", response={204: None}, summary="Revoke a key")
def revoke_key(request: HttpRequest, key_id: str) -> Any:
    k = _key(key_id)
    ApiKey.objects.filter(pk=k.pk).update(revoked_at=timezone.now())
    audit("api_key.revoke", ADMIN, project_id=k.project_id, subject_type="api_key", subject_id=k.id, request=request)
    return Status(204, None)


@router.post("projects/{project_id}/editor-session", summary="Enter the editor of a project as super-admin")
def editor_session(request: HttpRequest, project_id: str, body: EditorSessionIn | None = None) -> Any:
    from snapfile.auth_sso.sessions import access_token, issue_session, session_payload, set_refresh_cookie

    p = _project(project_id)
    session, token = issue_session(
        p,
        api_key=None,
        user={"id": "superadmin", "name": f"Super admin ({request.user.login})"},  # type: ignore[union-attr]
        role="admin",
        open_target={"template": body.template} if body and body.template else None,
        actor_type="superadmin",
        ttl_minutes=480,
    )
    from snapfile.auth_sso.models import EditSession

    EditSession.objects.filter(pk=session.pk).update(handoff_used_at=timezone.now())
    access, ttl = access_token(session)
    resp = JsonResponse({"access_token": access, "expires_in": ttl, "token_type": "Bearer", **session_payload(session)})
    set_refresh_cookie(request, resp, session)
    del token
    audit(
        "superadmin.editor_session",
        ADMIN,
        project_id=p.id,
        subject_type="edit_session",
        subject_id=session.id,
        request=request,
    )
    return resp


@router.get("system", summary="Environment diagnostics (like snapfile_doctor)")
def system(request: HttpRequest) -> Any:
    from snapfile.core.doctor import diagnostics

    return diagnostics()


@router.get("jobs", summary="Generations across projects (newest first), e.g. status=failed")
def list_jobs(
    request: HttpRequest, status: str | None = None, project: str | None = None, limit: int = 50
) -> Any:
    from snapfile.jobs.models import RenderJob

    qs = RenderJob.objects.select_related("project", "template").filter(kind="render").order_by("-created_at")
    if status:
        qs = qs.filter(status__in=[x for x in status.split(",") if x])
    if project:
        qs = qs.filter(project=_project(project))
    rows = qs[: max(1, min(limit, 200))]
    return {
        "data": [
            {
                "id": ids.encode("job", j.id),
                "project": {"id": ids.encode("prj", j.project_id), "slug": j.project.slug, "name": j.project.name},
                "template": {"key": j.template.key, "name": j.template.name},
                "status": j.status,
                "mode": j.mode,
                "attempts": j.attempts,
                "error_code": j.error_code,
                "error_message": j.error_message,
                "created_at": j.created_at.isoformat(),
                "finished_at": j.finished_at.isoformat() if j.finished_at else None,
            }
            for j in rows
        ]
    }


@router.get("audit", summary="Audit log (newest first), optionally for one project")
def audit_log(request: HttpRequest, project: str | None = None, limit: int = 100) -> Any:
    from snapfile.core.models import AuditLog

    qs = AuditLog.objects.order_by("-created_at")
    if project:
        qs = qs.filter(project_id=_project(project).id)
    rows = list(qs[: max(1, min(limit, 500))])
    slugs = dict(Project.objects.filter(id__in={r.project_id for r in rows if r.project_id}).values_list("id", "slug"))
    return {
        "data": [
            {
                "id": str(r.id),
                "action": r.action,
                "actor": {"type": r.actor_type, "id": r.actor_id, "name": r.actor_name},
                "project": slugs.get(r.project_id) if r.project_id else None,
                "subject_type": r.subject_type,
                "changes": r.changes,
                "ip": r.ip,
                "created_at": r.created_at.isoformat(),
            }
            for r in rows
        ]
    }


@router.post("jobs/{job_id}/requeue", summary="Requeue a failed job")
def requeue(request: HttpRequest, job_id: str) -> Any:
    from snapfile.jobs.models import RenderJob

    try:
        uid = ids.decode("job", job_id)
    except ids.InvalidId as exc:
        raise ApiError(404, "JOB_NOT_FOUND", "Job not found") from exc
    n = RenderJob.objects.filter(pk=uid, status__in=("failed", "canceled")).update(
        status="queued",
        available_at=timezone.now(),
        attempts=0,
        lease_owner=None,
        lease_until=None,
        error_code=None,
        error_message=None,
        mode="async",
    )
    if not n:
        raise ApiError(409, "CONFLICT", "Only failed or canceled jobs can be requeued")
    return {"ok": True}
