"""Encrypted at-rest storage for ID image bytes (Fernet). Never logs plaintext."""

from __future__ import annotations

import base64
import hashlib
import logging
import re
import threading
from dataclasses import dataclass
from pathlib import Path
from uuid import uuid4

from app.config import get_settings

logger = logging.getLogger(__name__)
_SAFE_ID = re.compile(r"^[A-Za-z0-9._:-]{1,128}$")


@dataclass
class EncryptedBlobMeta:
    storage_id: str
    sha256: str
    byte_size: int
    path: str | None


class IdImageCryptoStore:
    """Stores Fernet-encrypted ID images under a configured directory."""

    def __init__(
        self,
        *,
        persist_dir: str | Path | None = None,
        encryption_key: str | None = None,
    ) -> None:
        self._lock = threading.RLock()
        self._persist_dir = Path(persist_dir) if persist_dir else None
        self._key_material = encryption_key
        self._fernet = None
        if self._persist_dir is not None:
            self._persist_dir.mkdir(parents=True, exist_ok=True)

    def configure(
        self,
        *,
        persist_dir: str | Path | None = None,
        encryption_key: str | None = None,
    ) -> None:
        with self._lock:
            if persist_dir is not None:
                self._persist_dir = Path(persist_dir)
                self._persist_dir.mkdir(parents=True, exist_ok=True)
            if encryption_key is not None:
                self._key_material = encryption_key
                self._fernet = None

    def _get_fernet(self):
        if self._fernet is not None:
            return self._fernet
        from cryptography.fernet import Fernet

        key = self._resolve_key()
        self._fernet = Fernet(key)
        return self._fernet

    def _resolve_key(self) -> bytes:
        """Fernet key: explicit URL-safe base64, or derive from configured secret."""
        raw = (self._key_material or "").strip()
        if not raw:
            settings = get_settings()
            raw = (getattr(settings, "id_verification_encryption_key", None) or "").strip()
            if not raw:
                # Dev fallback — derived from internal token (not for production rotation)
                raw = settings.internal_api_token
                logger.warning(
                    "ID_VERIFICATION_ENCRYPTION_KEY unset; deriving Fernet key from "
                    "INTERNAL_API_TOKEN (set an explicit key in production)"
                )
        # Already a Fernet key?
        try:
            from cryptography.fernet import Fernet

            if len(raw) == 44:
                Fernet(raw.encode("ascii") if isinstance(raw, str) else raw)
                return raw.encode("ascii") if isinstance(raw, str) else raw
        except Exception:  # noqa: BLE001
            pass
        digest = hashlib.sha256(raw.encode("utf-8")).digest()
        return base64.urlsafe_b64encode(digest)

    def store(
        self,
        image_bytes: bytes,
        *,
        interview_id: str | None = None,
    ) -> EncryptedBlobMeta:
        sha = hashlib.sha256(image_bytes).hexdigest()
        storage_id = f"idimg-{uuid4().hex[:16]}"
        path_str: str | None = None
        with self._lock:
            fernet = self._get_fernet()
            token = fernet.encrypt(image_bytes)
            if self._persist_dir is not None:
                sub = "misc"
                if interview_id and _SAFE_ID.match(interview_id):
                    sub = interview_id.replace(":", "_").replace("/", "_")
                folder = self._persist_dir / sub
                folder.mkdir(parents=True, exist_ok=True)
                path = folder / f"{storage_id}.bin"
                path.write_bytes(token)
                path_str = str(path)
        return EncryptedBlobMeta(
            storage_id=storage_id,
            sha256=sha,
            byte_size=len(image_bytes),
            path=path_str,
        )

    def load(self, storage_id: str, *, interview_id: str | None = None) -> bytes | None:
        if not storage_id or not _SAFE_ID.match(storage_id):
            return None
        with self._lock:
            if self._persist_dir is None:
                return None
            candidates: list[Path] = []
            if interview_id and _SAFE_ID.match(interview_id):
                safe = interview_id.replace(":", "_").replace("/", "_")
                candidates.append(self._persist_dir / safe / f"{storage_id}.bin")
            candidates.append(self._persist_dir / "misc" / f"{storage_id}.bin")
            # Walk one level if needed
            for path in candidates:
                if path.exists():
                    token = path.read_bytes()
                    return self._get_fernet().decrypt(token)
            for path in self._persist_dir.rglob(f"{storage_id}.bin"):
                token = path.read_bytes()
                return self._get_fernet().decrypt(token)
        return None


def build_id_crypto_store() -> IdImageCryptoStore:
    try:
        settings = get_settings()
        persist = getattr(settings, "id_verification_store_dir", None) or (
            ".data/id_verification"
        )
        key = getattr(settings, "id_verification_encryption_key", None)
    except Exception:  # noqa: BLE001
        persist = ".data/id_verification"
        key = None
    return IdImageCryptoStore(persist_dir=persist, encryption_key=key)


id_crypto_store = build_id_crypto_store()
