"""SSO handoff: one-time token -> access JWT (15 min) + rotating refresh cookie (TZ 2.9.3)."""

from __future__ import annotations

import logging
import threading
import time
from dataclasses import dataclass, field
from datetime import timedelta
from typing import Any
from urllib.parse import urlsplit

import jwt
from django.conf import settings
from django.db.models import Q
from django.http import HttpRequest, HttpResponse
from django.utils import timezone

from snapfile.core import ids
from snapfile.core.audit import Actor, audit
from snapfile.core.crypto import base62, sha256_hex
from snapfile.core.errors import ApiError
from snapfile.core.ids import uuid7
from snapfile.integration.models import ApiKey
from snapfile.projects.models import Project

from .models import ROLES, EditSession

log = logging.getLogger("snapfile.security")
JWT_AUDIENCE = "snapfile-editor"
REFRESH_COOKIE = "snapfile_rt"
_REVOKE_CACHE: dict[str, tuple[float, bool]] = {}
_REVOKE_LOCK = threading.Lock()
REVOKE_CACHE_TTL = 30.0


@dataclass
class EditorPrincipal:
    session_id: str
    project_id: str
    user_id: str
    name: str
    email: str | None
    role: str
    perms: list[str] = field(default_factory=list)
    templates: list[str] | None = None
    actor_type: str = "user"

    @property
    def actor(self) -> Actor:
        return Actor(
            self.actor_type, self.user_id, self.name, {"email": self.email, "role": self.role, "sid": self.session_id}
        )

    def snapshot(self) -> dict[str, Any]:
        return self.actor.snapshot()

    def can(self, action: str) -> bool:
        if self.role == "admin":
            return True
        if action == "view":
            return True
        if self.role != "editor":
            return False
        if action == "publish":
            return "publish" in self.perms
        if action == "edit_schema":
            return "edit_schema" in self.perms
        return action in ("edit", "upload")


def _check_return_url(project: Project, url: str | None) -> None:
    if not url:
        return
    origins = project.allowed_origins or []
    parts = urlsplit(url)
    origin = f"{parts.scheme}://{parts.netloc}"
    if origins and origin not in origins:
        raise ApiError(
            422,
            "VALIDATION_FAILED",
            "return_url origin is not in allowed_origins",
            [{"pointer": "/return_url", "message": "origin not allowed"}],
        )


def issue_session(
    project: Project,
    *,
    api_key: ApiKey | None,
    user: dict[str, Any],
    role: str,
    permissions: dict[str, Any] | None = None,
    templates: list[str] | None = None,
    open_target: dict[str, Any] | None = None,
    locale: str | None = None,
    return_url: str | None = None,
    client_session_ref: str | None = None,
    ttl_minutes: int | None = None,
    ip: str | None = None,
    actor_type: str = "user",
) -> tuple[EditSession, str]:
    if role not in ROLES:
        raise ApiError(422, "VALIDATION_FAILED", f"Unknown role {role!r}", [{"pointer": "/role"}])
    if not user.get("id") or not user.get("name"):
        raise ApiError(422, "VALIDATION_FAILED", "user.id and user.name are required", [{"pointer": "/user"}])
    _check_return_url(project, return_url)
    now = timezone.now()
    ttl = min(int(ttl_minutes or 480) * 60, settings.EDIT_SESSION_MAX_TTL)
    token = "hk_" + base62(32)
    perms = dict(permissions or {})
    meta = {k: v for k, v in user.items() if k not in ("id", "name", "email") and v is not None}
    session = EditSession.objects.create(
        project=project,
        api_key=api_key,
        actor_type=actor_type,
        handoff_token_hash=sha256_hex(token),
        handoff_expires_at=now + timedelta(seconds=settings.EDIT_SESSION_HANDOFF_TTL),
        external_user_id=str(user["id"])[:191],
        external_user_name=str(user["name"])[:255],
        external_user_email=(user.get("email") or None),
        external_user_meta=meta or None,
        role=role,
        template_scope=templates or None,
        open_target=open_target or None,
        permissions=perms or None,
        locale=locale,
        return_url=return_url,
        client_session_ref=client_session_ref,
        expires_at=now + timedelta(seconds=ttl),
        ip_issued=ip,
    )
    return session, token


def _perms(session: EditSession) -> list[str]:
    p = session.permissions or {}
    out = []
    can_publish = p.get("can_publish")
    if can_publish is None:
        can_publish = bool(session.project.setting("editors_can_publish"))
    if session.role == "admin" or can_publish:
        out.append("publish")
    if session.role == "admin" or p.get("can_edit_schema"):
        out.append("edit_schema")
    if session.role == "admin" or p.get("can_manage_assets", True):
        out.append("assets")
    return out


def access_token(session: EditSession) -> tuple[str, int]:
    now = int(time.time())
    ttl = settings.EDITOR_JWT_TTL
    claims = {
        "iss": settings.SNAPFILE_BASE_URL,
        "aud": JWT_AUDIENCE,
        "sub": session.external_user_id,
        "name": session.external_user_name,
        "email": session.external_user_email,
        "prj": ids.encode("prj", session.project_id),
        "sid": ids.encode("ses", session.id),
        "role": session.role,
        "perm": _perms(session),
        "tpl": session.template_scope,
        "act": session.actor_type,
        "iat": now,
        "nbf": now,
        "exp": now + ttl,
        "jti": str(uuid7()),
    }
    return jwt.encode(claims, settings.EDITOR_JWT_SECRET, algorithm="HS256", headers={"kid": "k1"}), ttl


def redeem_handoff(token: str, ip: str | None) -> EditSession:
    if not token or not token.startswith("hk_"):
        raise ApiError(401, "TOKEN_INVALID", "Handoff token is malformed")
    now = timezone.now()
    h = sha256_hex(token)
    updated = EditSession.objects.filter(
        handoff_token_hash=h, handoff_used_at__isnull=True, handoff_expires_at__gt=now, revoked_at__isnull=True
    ).update(handoff_used_at=now, ip_last=ip, last_seen_at=now)
    session = EditSession.objects.select_related("project").filter(handoff_token_hash=h).first()
    if not updated:
        if session is None:
            raise ApiError(401, "TOKEN_INVALID", "Handoff token is invalid")
        if session.handoff_used_at is not None:
            # Reuse is a sign of a leaked link: revoke the whole session (TZ 2.9.3 p.4); revoke() also drops
            # the refresh token and this process' revocation cache entry.
            revoke(session)
            audit(
                "edit_session.handoff_reuse",
                Actor("system", "system"),
                project_id=session.project_id,
                subject_type="edit_session",
                subject_id=session.id,
            )
            log.warning("handoff reuse", extra={"event": "security.handoff_reuse", "session": str(session.id)})
            raise ApiError(401, "TOKEN_USED", "This link has already been used")
        if session.revoked_at is not None:
            raise ApiError(401, "TOKEN_INVALID", "Session was revoked")
        raise ApiError(401, "TOKEN_EXPIRED", "Handoff link expired")
    if session is None or session.project.status != "active" or session.project.deleted_at is not None:
        raise ApiError(403, "PROJECT_DISABLED", "Project is not available")
    return session


def set_refresh_cookie(request: HttpRequest, response: HttpResponse, session: EditSession) -> None:
    """Rotate the refresh token: the current one becomes ``refresh_prev_hash`` (reuse detection)."""
    token = "rt_" + base62(32)
    current = EditSession.objects.filter(pk=session.pk).values_list("refresh_token_hash", flat=True).first()
    EditSession.objects.filter(pk=session.pk).update(
        refresh_token_hash=sha256_hex(token),
        refresh_prev_hash=current,
        refresh_rotated_at=timezone.now() if current else None,
    )
    original = getattr(request, "original_path", request.path_info)
    path = "/api/editor/v1/auth" if original.startswith("/api/editor/") else "/internal/v1/auth"
    max_age = max(0, int((session.expires_at - timezone.now()).total_seconds()))
    response.set_cookie(
        REFRESH_COOKIE, token, max_age=max_age, path=path, httponly=True, secure=settings.SECURE_COOKIES, samesite="Lax"
    )


def refresh(request: HttpRequest) -> EditSession:
    token = request.COOKIES.get(REFRESH_COOKIE, "")
    if not token:
        raise ApiError(401, "SESSION_EXPIRED", "No refresh token")
    h = sha256_hex(token)
    session = EditSession.objects.select_related("project").filter(refresh_token_hash=h).first()
    now = timezone.now()
    if session is None:
        session = _check_refresh_reuse(h, now)
    if session is None:
        raise ApiError(401, "SESSION_EXPIRED", "Refresh token is invalid")
    if session.revoked_at is not None or session.expires_at <= now:
        raise ApiError(401, "SESSION_EXPIRED", "Session expired")
    EditSession.objects.filter(pk=session.pk).update(last_seen_at=now)
    return session


def _check_refresh_reuse(token_hash: str, now: Any) -> EditSession | None:
    """A rotated-out refresh token was presented (TZ 2.9.3 p.6): revoke the whole session.

    Within ``REFRESH_REUSE_GRACE`` seconds after a rotation the old token is accepted once more (two tabs or
    a retried request racing on the same cookie); that is not treated as theft.
    """
    session = EditSession.objects.select_related("project").filter(refresh_prev_hash=token_hash).first()
    if session is None or session.revoked_at is not None:
        return None
    rotated = session.refresh_rotated_at
    if rotated and (now - rotated).total_seconds() <= settings.REFRESH_REUSE_GRACE:
        return session
    revoke(session)
    audit(
        "edit_session.refresh_reuse",
        Actor("system", "system"),
        project_id=session.project_id,
        subject_type="edit_session",
        subject_id=session.id,
    )
    log.warning("refresh token reuse", extra={"event": "security.refresh_reuse", "session": str(session.id)})
    raise ApiError(401, "SESSION_EXPIRED", "Refresh token reuse detected; the session was revoked")


def decode_access(token: str) -> EditorPrincipal:
    try:
        claims = jwt.decode(
            token,
            settings.EDITOR_JWT_SECRET,
            algorithms=["HS256"],
            audience=JWT_AUDIENCE,
            issuer=settings.SNAPFILE_BASE_URL,
            leeway=30,
        )
    except jwt.ExpiredSignatureError as exc:
        raise ApiError(401, "TOKEN_EXPIRED", "Access token expired") from exc
    except jwt.PyJWTError as exc:
        raise ApiError(401, "UNAUTHENTICATED", "Invalid access token") from exc
    sid = claims["sid"]
    if is_revoked(sid):
        raise ApiError(401, "SESSION_EXPIRED", "Session revoked")
    return EditorPrincipal(
        session_id=sid,
        project_id=claims["prj"],
        user_id=claims["sub"],
        name=claims.get("name") or "",
        email=claims.get("email"),
        role=claims["role"],
        perms=list(claims.get("perm") or []),
        templates=claims.get("tpl"),
        actor_type=claims.get("act") or "user",
    )


def is_revoked(sid: str) -> bool:
    now = time.monotonic()
    hit = _REVOKE_CACHE.get(sid)
    if hit and now - hit[0] < REVOKE_CACHE_TTL:
        return hit[1]
    try:
        uid = ids.decode("ses", sid)
    except ids.InvalidId:
        return True
    revoked = not EditSession.objects.filter(pk=uid, revoked_at__isnull=True, expires_at__gt=timezone.now()).exists()
    with _REVOKE_LOCK:
        if len(_REVOKE_CACHE) > 10000:
            _REVOKE_CACHE.clear()
        _REVOKE_CACHE[sid] = (now, revoked)
    return revoked


def revoke(session: EditSession) -> None:
    EditSession.objects.filter(pk=session.pk).update(revoked_at=timezone.now(), refresh_token_hash=None)
    _REVOKE_CACHE.pop(ids.encode("ses", session.id) or "", None)


def revoke_user(project: Project, external_user_id: str) -> int:
    now = timezone.now()
    qs = EditSession.objects.filter(
        Q(project=project) & Q(external_user_id=external_user_id) & Q(revoked_at__isnull=True)
    )
    sids = [ids.encode("ses", s) or "" for s in qs.values_list("id", flat=True)]
    n = qs.update(revoked_at=now, refresh_token_hash=None)
    for sid in sids:
        _REVOKE_CACHE.pop(sid, None)
    return n


def session_payload(session: EditSession) -> dict[str, Any]:
    target = None
    if session.open_target and session.open_target.get("template"):
        from snapfile.doctemplates.models import Template

        t = Template.objects.filter(
            project_id=session.project_id, key=session.open_target["template"], deleted_at__isnull=True
        ).first()
        if t is not None:
            target = {"templateId": ids.encode("tpl", t.id), "templateKey": t.key}
    meta = session.external_user_meta or {}
    return {
        "user": {
            "externalId": session.external_user_id,
            "name": session.external_user_name,
            "email": session.external_user_email,
            "avatarUrl": meta.get("avatar_url"),
        },
        "role": session.role,
        "permissions": _perms(session),
        "project": {
            "id": ids.encode("prj", session.project_id),
            "slug": session.project.slug,
            "name": session.project.name,
            "clientName": session.project.client_name,
        },
        "locale": session.locale or session.project.setting("locale"),
        "returnUrl": session.return_url,
        "target": target,
        "sessionExpiresAt": session.expires_at.isoformat(),
    }


def ensure_target_access(session: EditSession) -> None:
    """The template the handoff opens must be accessible to the user (``allowed_users``)."""
    from snapfile.doctemplates.service import get_template

    target = session_payload(session).get("target")
    if not target or not target.get("templateId"):
        return
    project = session.project
    principal = EditorPrincipal(
        session_id="",
        project_id="",
        user_id=session.external_user_id,
        name=session.external_user_name or "",
        email=session.external_user_email,
        role=session.role,
    )
    try:
        get_template(project, target["templateId"], principal)
    except ApiError as exc:
        if exc.code == "ACCESS_DENIED":
            revoke(session)
            raise
