"""Encrypted face enrollment references (no raw biometrics in API responses)."""

from __future__ import annotations

import json
import logging
import re
import threading
from dataclasses import asdict, dataclass, field
from datetime import datetime, timezone
from pathlib import Path
from typing import Any
from uuid import uuid4

from app.config import get_settings
from app.services.id.crypto_store import IdImageCryptoStore

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


def _utc_now() -> datetime:
    return datetime.now(timezone.utc)


def _iso(dt: datetime | None = None) -> str:
    return (dt or _utc_now()).astimezone(timezone.utc).isoformat()


@dataclass
class FaceEnrollmentRecord:
    enrollment_id: str
    user_id: str
    company_id: str | None
    encrypted_storage_id: str
    image_sha256: str
    consent_id: str | None
    status: str  # active | revoked
    created_at: str = field(default_factory=_iso)
    updated_at: str = field(default_factory=_iso)
    meta: dict[str, Any] = field(default_factory=dict)


class FaceEnrollmentStore:
    """Maps user_id → encrypted face reference metadata (image bytes via crypto store)."""

    def __init__(
        self,
        *,
        persist_dir: str | Path | None = None,
        crypto: IdImageCryptoStore | None = None,
    ) -> None:
        self._lock = threading.RLock()
        self._by_user: dict[str, FaceEnrollmentRecord] = {}
        self._persist_dir = Path(persist_dir) if persist_dir else None
        if self._persist_dir is not None:
            self._persist_dir.mkdir(parents=True, exist_ok=True)
        self._crypto = crypto

    def configure(
        self,
        *,
        persist_dir: str | Path | None = None,
        crypto: IdImageCryptoStore | 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 crypto is not None:
                self._crypto = crypto

    def _crypto_store(self) -> IdImageCryptoStore:
        if self._crypto is None:
            settings = get_settings()
            persist = getattr(settings, "face_enrollment_store_dir", None) or (
                ".data/face_enrollment"
            )
            key = getattr(settings, "id_verification_encryption_key", None)
            self._crypto = IdImageCryptoStore(
                persist_dir=Path(persist) / "blobs",
                encryption_key=key,
            )
        return self._crypto

    def save_enrollment(
        self,
        *,
        user_id: str,
        image_bytes: bytes,
        company_id: str | None = None,
        consent_id: str | None = None,
        meta: dict[str, Any] | None = None,
    ) -> FaceEnrollmentRecord:
        if not user_id or not _SAFE_ID.match(user_id):
            raise ValueError("Invalid user_id")
        blob = self._crypto_store().store(image_bytes, interview_id=f"enroll-{user_id}")
        rec = FaceEnrollmentRecord(
            enrollment_id=f"fenr-{uuid4().hex[:16]}",
            user_id=user_id,
            company_id=company_id,
            encrypted_storage_id=blob.storage_id,
            image_sha256=blob.sha256,
            consent_id=consent_id,
            status="active",
            meta=dict(meta or {}),
        )
        with self._lock:
            self._by_user[user_id] = rec
            self._persist(rec)
        return rec

    def get_active(self, user_id: str) -> FaceEnrollmentRecord | None:
        if not user_id:
            return None
        with self._lock:
            rec = self._by_user.get(user_id)
        if rec is None:
            rec = self._load(user_id)
            if rec is not None:
                with self._lock:
                    self._by_user[user_id] = rec
        if rec is None or rec.status != "active":
            return None
        return rec

    def load_image_bytes(self, user_id: str) -> bytes | None:
        rec = self.get_active(user_id)
        if rec is None:
            return None
        return self._crypto_store().load(
            rec.encrypted_storage_id, interview_id=f"enroll-{user_id}"
        )

    def revoke(self, user_id: str) -> bool:
        rec = self.get_active(user_id)
        if rec is None:
            return False
        rec.status = "revoked"
        rec.updated_at = _iso()
        with self._lock:
            self._by_user[user_id] = rec
            self._persist(rec)
        return True

    def clear(self) -> None:
        with self._lock:
            self._by_user.clear()

    def _persist(self, rec: FaceEnrollmentRecord) -> None:
        if self._persist_dir is None:
            return
        path = self._persist_dir / f"{rec.user_id}.json"
        path.write_text(json.dumps(asdict(rec), indent=2), encoding="utf-8")

    def _load(self, user_id: str) -> FaceEnrollmentRecord | None:
        if self._persist_dir is None or not _SAFE_ID.match(user_id):
            return None
        path = self._persist_dir / f"{user_id}.json"
        if not path.exists():
            return None
        try:
            data = json.loads(path.read_text(encoding="utf-8"))
            fields = FaceEnrollmentRecord.__dataclass_fields__
            return FaceEnrollmentRecord(**{k: data.get(k) for k in fields})
        except Exception:  # noqa: BLE001
            logger.exception("Failed to load face enrollment for %s", user_id)
            return None


def build_face_enrollment_store() -> FaceEnrollmentStore:
    try:
        settings = get_settings()
        persist = getattr(settings, "face_enrollment_store_dir", None) or (
            ".data/face_enrollment"
        )
    except Exception:  # noqa: BLE001
        persist = ".data/face_enrollment"
    return FaceEnrollmentStore(persist_dir=persist)


face_enrollment_store = build_face_enrollment_store()
