"""Key derivation, secret hashing, AES-GCM for secrets at rest, tokens (TZ 2.9.1, 2.9.10)."""

from __future__ import annotations

import base64
import hashlib
import hmac
import json
import secrets
from functools import lru_cache
from typing import Any

from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
from cryptography.hazmat.primitives.kdf.hkdf import HKDF
from django.conf import settings

_B62 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"


@lru_cache(maxsize=16)
def derive_key(purpose: str, length: int = 32) -> bytes:
    """HKDF-SHA256 from SECRET_KEY: pepper for API keys, plan signing, download links, ..."""
    # the salt keeps the product's old name: changing it invalidates every stored key hash and encrypted secret
    hkdf = HKDF(algorithm=hashes.SHA256(), length=length, salt=b"visual", info=purpose.encode())
    return hkdf.derive(settings.SECRET_KEY.encode())


def base62(nbytes: int = 32) -> str:
    n = int.from_bytes(secrets.token_bytes(nbytes), "big")
    out = []
    while n:
        n, r = divmod(n, 62)
        out.append(_B62[r])
    return "".join(reversed(out)) or "0"


def random_lower(n: int) -> str:
    alphabet = "0123456789abcdefghijklmnopqrstuvwxyz"
    return "".join(secrets.choice(alphabet) for _ in range(n))


def sha256_hex(data: str | bytes) -> str:
    if isinstance(data, str):
        data = data.encode()
    return hashlib.sha256(data).hexdigest()


def hmac_hex(key: bytes, data: str | bytes) -> str:
    if isinstance(data, str):
        data = data.encode()
    return hmac.new(key, data, hashlib.sha256).hexdigest()


def canonical_json(value: Any) -> str:
    """Sorted keys, compact separators, ``x-*`` keys removed (TZ 2.3.1 p.7)."""

    def strip(v: Any) -> Any:
        if isinstance(v, dict):
            return {k: strip(x) for k, x in v.items() if not (isinstance(k, str) and k.startswith("x-"))}
        if isinstance(v, list):
            return [strip(x) for x in v]
        return v

    return json.dumps(strip(value), sort_keys=True, separators=(",", ":"), ensure_ascii=False, default=str)


def _enc_keys() -> list[tuple[str, bytes]]:
    raw = getattr(settings, "SNAPFILE_ENC_KEYS", "") or ""
    keys = []
    for i, item in enumerate(k.strip() for k in raw.split(",") if k.strip()):
        keys.append((f"k{i}", base64.b64decode(item)))
    if not keys:
        keys.append(("d0", derive_key("enc-default")))
    return keys


def encrypt_secret(plain: str) -> str:
    kid, key = _enc_keys()[0]
    nonce = secrets.token_bytes(12)
    ct = AESGCM(key).encrypt(nonce, plain.encode(), kid.encode())
    return f"{kid}:{base64.b64encode(nonce + ct).decode()}"


def decrypt_secret(token: str | None) -> str | None:
    if not token:
        return None
    kid, _, payload = token.partition(":")
    raw = base64.b64decode(payload)
    for k_id, key in _enc_keys():
        if k_id == kid:
            return AESGCM(key).decrypt(raw[:12], raw[12:], kid.encode()).decode()
    raise ValueError("unknown encryption key id")
