"""Internal API for the Integration page (03_frontend 3.4.6 d, role admin): API keys and the webhook.

Deviation from the role matrix of TZ 2.9.3 ("API keys: super-admin only"), agreed for iteration 1: the
project admin of an editor session manages the keys *of its own project* (create / rotate / revoke, the
``admin`` scope cannot be granted) and the project webhook. Every action is audited. Creating projects and
admin-scope keys stays with the super-admin (``/admin/v1``).
"""

from __future__ import annotations

from typing import Any, Literal
from urllib.parse import urlsplit

from django.conf import settings
from django.db import transaction
from django.http import HttpRequest
from django.utils import timezone
from ninja import Field, Router, Schema, Status

from snapfile.auth_sso.auth import EditorJwtAuth, require
from snapfile.core import ids
from snapfile.core.audit import audit
from snapfile.core.crypto import base62, decrypt_secret, encrypt_secret
from snapfile.core.errors import ApiError
from snapfile.jobs.webhooks import EVENTS, send_test_event

from .connector import probe, service_list
from .keys import ROTATION_GRACE, issue_key, key_dict, rotate_key, sign_with_key
from .models import SCOPES, ApiKey

router = Router(auth=EditorJwtAuth(), tags=["internal: integration"])
ADMIN_GRANTABLE = tuple(s for s in SCOPES if s != "admin")
SERVICE_KEY_SCOPES = ADMIN_GRANTABLE


class KeyCreateIn(Schema):
    name: str = Field(..., min_length=1, max_length=128)
    env: Literal["live", "test"] = "live"
    scopes: list[str] = Field(default_factory=lambda: ["render", "templates:read"])


class ServiceConnectorIn(Schema):
    base_url: str | None = Field(None, max_length=512, description="Empty string disconnects the service")
    secret: str | None = Field(None, min_length=16, max_length=255)
    rotate_secret: bool = False


class WebhookIn(Schema):
    url: str | None = Field(None, max_length=512)
    events: list[str] | None = None
    enabled: bool | None = None
    rotate_secret: bool = False


def _admin(request: HttpRequest) -> Any:
    return require(request, "admin")


def _key_out(k: ApiKey) -> dict[str, Any]:
    now = timezone.now()
    if k.revoked_at is not None or (k.expires_at is not None and k.expires_at <= now):
        status = "revoked"
    elif k.expires_at is not None and k.expires_at <= now + ROTATION_GRACE:
        status = "expiring"
    else:
        status = "active"
    return {**key_dict(k), "masked": f"vk_{k.env}_{k.prefix}.••••••••", "status": status}


def _key(request: HttpRequest, 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.filter(project=request.project, pk=uid).first()  # type: ignore[attr-defined]
    if k is None:
        raise ApiError(404, "NOT_FOUND", "API key not found")
    return k


@router.get("integration/api-keys", summary="API keys of the project (admin)")
def list_keys(request: HttpRequest) -> Any:
    _admin(request)
    rows = ApiKey.objects.filter(project=request.project).order_by("-created_at")  # type: ignore[attr-defined]
    signer = request.project.setting("service_key_id")  # type: ignore[attr-defined]
    data = []
    for k in rows:
        out = _key_out(k)
        data.append({**out, "signs": out["status"] != "revoked" and ids.encode("key", k.id) == signer})
    return {"data": data, "next_cursor": None}


@router.post("integration/service-key", response={201: dict}, summary="Generate a key of the service (admin)")
def issue_service_key(request: HttpRequest) -> Any:
    """The newest key signs the connector requests and the webhooks. The other keys work until they are revoked."""
    principal = _admin(request)
    p = request.project  # type: ignore[attr-defined]
    with transaction.atomic():
        issued = issue_key(p, "Service key", list(SERVICE_KEY_SCOPES))
        sign_with_key(p, issued.key, issued.secret)
    audit(
        "api_key.create",
        principal.actor,
        project_id=p.id,
        subject_type="api_key",
        subject_id=issued.key.id,
        changes={"service_key": True},
        request=request,
    )
    return Status(201, {**_key_out(issued.key), "signs": True, "secret": issued.secret})


@router.delete("integration/api-keys/{key_id}/purge", response={204: None}, summary="Delete a revoked or expired key")
def purge_key(request: HttpRequest, key_id: str) -> Any:
    principal = _admin(request)
    k = _key(request, key_id)
    if _key_out(k)["status"] != "revoked":
        raise ApiError(409, "KEY_ACTIVE", "Revoke the key before deleting it")
    subject = k.id
    k.delete()
    audit(
        "api_key.delete",
        principal.actor,
        project_id=request.project.id,  # type: ignore[attr-defined]
        subject_type="api_key",
        subject_id=subject,
        request=request,
    )
    return Status(204, None)


@router.post("integration/api-keys", response={201: dict}, summary="Create an API key (secret shown once, admin)")
def create_key(request: HttpRequest, body: KeyCreateIn) -> Any:
    principal = _admin(request)
    bad = [s for s in body.scopes if s not in ADMIN_GRANTABLE]
    if bad or not body.scopes:
        raise ApiError(
            422, "VALIDATION_FAILED", f"Scopes not allowed: {', '.join(bad) or '(empty)'}", [{"pointer": "/scopes"}]
        )
    issued = issue_key(request.project, body.name, body.scopes, env=body.env)  # type: ignore[attr-defined]
    audit(
        "api_key.create",
        principal.actor,
        project_id=issued.key.project_id,
        subject_type="api_key",
        subject_id=issued.key.id,
        request=request,
    )
    return Status(201, {**_key_out(issued.key), "secret": issued.secret})


@router.post("integration/api-keys/{key_id}/rotate", response={201: dict}, summary="Rotate a key (admin)")
def rotate(request: HttpRequest, key_id: str) -> Any:
    principal = _admin(request)
    old = _key(request, key_id)
    if old.revoked_at is not None or "admin" in (old.scopes or []):
        raise ApiError(409, "KEY_NOT_ROTATABLE", "Revoked keys and admin-scope keys cannot be rotated here")
    issued = rotate_key(old)
    audit(
        "api_key.rotate",
        principal.actor,
        project_id=old.project_id,
        subject_type="api_key",
        subject_id=old.id,
        request=request,
    )
    return Status(201, {**_key_out(issued.key), "secret": issued.secret})


@router.delete("integration/api-keys/{key_id}", response={204: None}, summary="Revoke a key (admin)")
def revoke(request: HttpRequest, key_id: str) -> Any:
    principal = _admin(request)
    k = _key(request, key_id)
    if k.revoked_at is None:
        k.revoked_at = timezone.now()
        k.save(update_fields=["revoked_at", "updated_at"])
        audit(
            "api_key.revoke",
            principal.actor,
            project_id=k.project_id,
            subject_type="api_key",
            subject_id=k.id,
            request=request,
        )
    return Status(204, None)


def _webhook_out(p: Any, secret: str | None = None) -> dict[str, Any]:
    stored = decrypt_secret(p.webhook_secret_enc) if p.webhook_secret_enc else None
    events = p.setting("webhook_events")
    out: dict[str, Any] = {
        "url": p.webhook_url or "",
        "events": list(events) if isinstance(events, list) and events else list(EVENTS),
        "enabled": p.setting("webhook_enabled") is not False,
        "secret_masked": f"whsec_••••••{stored[-4:]}" if stored else None,
        "available_events": list(EVENTS),
    }
    if secret:
        out["secret"] = secret  # shown once
    return out


def _check_url(project: Any, url: str) -> None:
    parts = urlsplit(url)
    allowed_schemes = ("https", "http") if settings.ALLOW_HTTP_FETCH else ("https",)
    if parts.scheme not in allowed_schemes or not parts.hostname:
        raise ApiError(422, "VALIDATION_FAILED", "Webhook URL must be https://", [{"pointer": "/url"}])
    hosts = project.setting("allowed_webhook_hosts") or []
    if hosts and parts.hostname not in hosts:
        raise ApiError(
            422, "VALIDATION_FAILED", "Host is not in allowed_webhook_hosts of the project", [{"pointer": "/url"}]
        )


@router.get("integration/webhook", summary="Project webhook settings (admin)")
def get_webhook(request: HttpRequest) -> Any:
    _admin(request)
    return _webhook_out(request.project)  # type: ignore[attr-defined]


@router.put("integration/webhook", summary="Update the project webhook: URL, events, on/off, secret (admin)")
def put_webhook(request: HttpRequest, body: WebhookIn) -> Any:
    principal = _admin(request)
    p = request.project  # type: ignore[attr-defined]
    fields = body.dict(exclude_unset=True)
    changes: dict[str, Any] = {}
    if "url" in fields:
        url = (body.url or "").strip()
        if url:
            _check_url(p, url)
        p.webhook_url = url or None
        changes["url"] = p.webhook_url
    settings_patch: dict[str, Any] = {}
    if body.events is not None:
        unknown = [e for e in body.events if e not in EVENTS]
        if unknown:
            raise ApiError(422, "VALIDATION_FAILED", f"Unknown events: {', '.join(unknown)}", [{"pointer": "/events"}])
        settings_patch["webhook_events"] = list(dict.fromkeys(body.events))
    if body.enabled is not None:
        settings_patch["webhook_enabled"] = bool(body.enabled)
    if settings_patch:
        p.settings = {**(p.settings or {}), **settings_patch}
        changes.update(settings_patch)
    secret = None
    if body.rotate_secret or (p.webhook_url and not p.webhook_secret_enc):
        secret = "whsec_" + base62(24)
        p.webhook_secret_enc = encrypt_secret(secret)
        changes["secret"] = "rotated"
    p.save(update_fields=["webhook_url", "webhook_secret_enc", "settings", "updated_at"])
    audit(
        "webhook.update",
        principal.actor,
        project_id=p.id,
        subject_type="project",
        subject_id=p.id,
        changes=changes,
        request=request,
    )
    return _webhook_out(p, secret)


@router.post("integration/webhook/test", summary="Send a signed webhook.test event now (admin)")
def test_webhook(request: HttpRequest) -> Any:
    _admin(request)
    return send_test_event(request.project)  # type: ignore[attr-defined]


# --------------------------------------------------------------------------------------------- client service


def _connector_out(p: Any, secret: str | None = None) -> dict[str, Any]:
    out = {
        "configured": bool(p.service_base_url),
        "base_url": p.service_base_url,
        "has_secret": bool(p.service_secret_enc),
    }
    if secret:
        out["secret"] = secret
    return out


@router.get("integration/service", summary="Client service connector (admin)")
def get_service_connector(request: HttpRequest) -> dict[str, Any]:
    _admin(request)
    return _connector_out(request.project)  # type: ignore[attr-defined]


@router.put("integration/service", summary="Set the client service connector; a new secret is shown once (admin)")
def put_service_connector(request: HttpRequest, body: ServiceConnectorIn) -> dict[str, Any]:
    principal = _admin(request)
    p = request.project  # type: ignore[attr-defined]
    if body.base_url is not None:
        parts = urlsplit(body.base_url)
        if body.base_url and (parts.scheme not in ("http", "https") or not parts.netloc):
            raise ApiError(422, "VALIDATION_FAILED", "Invalid URL", [{"pointer": "/base_url"}])
        p.service_base_url = body.base_url or None
    secret = None
    if body.secret:
        p.service_secret_enc = encrypt_secret(body.secret)
    elif body.rotate_secret or (p.service_base_url and not p.service_secret_enc):
        secret = "svc_" + base62(32)
        p.service_secret_enc = encrypt_secret(secret)
    p.service_cache = {}
    p.save(update_fields=["service_base_url", "service_secret_enc", "service_cache", "updated_at"])
    audit(
        "service_connector.update",
        principal.actor,
        project_id=p.id,
        subject_type="project",
        subject_id=p.id,
        changes={"base_url": p.service_base_url, "secret": "rotated" if secret or body.secret else None},
        request=request,
    )
    return _connector_out(p, secret)


@router.post("integration/service/test", summary="Ask the service for its lists now (admin)")
def test_service_connector(request: HttpRequest) -> dict[str, Any]:
    _admin(request)
    p = request.project  # type: ignore[attr-defined]
    if not p.service_base_url:
        raise ApiError(409, "SERVICE_NOT_CONFIGURED", "Save the service address first")
    return probe(p)


@router.get("service/languages", summary="Languages of the client service")
def service_languages(request: HttpRequest) -> dict[str, Any]:
    return service_list(request.project, "languages")  # type: ignore[attr-defined]


@router.get("service/users", summary="Users of the client service (admin), filtered by q")
def service_users(request: HttpRequest, q: str | None = None) -> dict[str, Any]:
    _admin(request)
    out = service_list(request.project, "users")  # type: ignore[attr-defined]
    if q:
        needle = q.casefold()
        out["items"] = [
            u for u in out["items"] if needle in u["name"].casefold() or needle in (u.get("email") or "").casefold()
        ]
    return out
