"""Durable face-verification audit records (no raw image bytes)."""

from __future__ import annotations

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

from app.config import get_settings
from app.persistence import resolve_persist_backend

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) -> str:
    return dt.astimezone(timezone.utc).isoformat()


@dataclass
class FaceAuditRecord:
    audit_id: str
    interview_id: str
    candidate_id: str | None
    status: str  # passed | failed
    verified: bool
    identity_matched: bool
    liveness_passed: bool
    match_score: float | None
    distance: float | None
    threshold: float | None
    liveness_score: float | None
    model: str
    detector: str
    attempt: int
    face_count: int | None
    frame_count: int
    registered_image_sha256: str | None
    live_image_sha256s: list[str] = field(default_factory=list)
    error_code: str | None = None
    warnings: list[str] = field(default_factory=list)
    created_at: str = field(default_factory=lambda: _iso(_utc_now()))
    expires_at: str | None = None


class FaceVerificationAuditStore:
    def __init__(
        self,
        *,
        persist_dir: str | Path | None = None,
        backend: str | None = None,
    ) -> None:
        self._lock = threading.RLock()
        self._by_interview: dict[str, list[FaceAuditRecord]] = {}
        self._persist_dir = Path(persist_dir) if persist_dir else None
        self._backend = (backend or resolve_persist_backend()).strip().lower()
        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,
        backend: str | None = None,
    ) -> None:
        with self._lock:
            if persist_dir is not None:
                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)
            if backend is not None:
                self._backend = backend.strip().lower()

    def _use_disk(self) -> bool:
        return self._backend in {"filesystem", "dual"}

    def _use_db(self) -> bool:
        return self._backend in {"postgres", "dual"}

    def _path(self, interview_id: str) -> Path | None:
        if self._persist_dir is None or not _SAFE_ID.match(interview_id):
            return None
        safe = interview_id.replace(":", "_").replace("/", "_")
        return self._persist_dir / f"{safe}.jsonl"

    def append(self, record: FaceAuditRecord) -> FaceAuditRecord:
        with self._lock:
            self._by_interview.setdefault(record.interview_id, []).append(record)
            if self._use_disk():
                path = self._path(record.interview_id)
                if path is not None:
                    try:
                        with path.open("a", encoding="utf-8") as fh:
                            fh.write(json.dumps(asdict(record), ensure_ascii=False) + "\n")
                    except Exception:  # noqa: BLE001
                        logger.warning(
                            "Failed to persist face audit interview_id=%s",
                            record.interview_id,
                            exc_info=True,
                        )
            if self._use_db():
                try:
                    from app.services.face.audit_db import upsert_audit

                    upsert_audit(record)
                except Exception:  # noqa: BLE001
                    logger.warning(
                        "Failed to DB-persist face audit %s",
                        record.audit_id,
                        exc_info=True,
                    )
                    if self._backend == "postgres":
                        raise
            return record

    def attempt_count(self, interview_id: str) -> int:
        with self._lock:
            n = len(self._by_interview.get(interview_id, []))
        if n:
            return n
        if self._use_db():
            from app.services.face.audit_db import count_for_interview

            n = count_for_interview(interview_id)
            if n:
                return n
        return len(self._load_disk(interview_id))

    def latest_passed(
        self, interview_id: str, *, max_age_seconds: float
    ) -> FaceAuditRecord | None:
        with self._lock:
            records = list(self._by_interview.get(interview_id, []))
        if not records:
            records = self._load_all(interview_id)
            with self._lock:
                if records:
                    self._by_interview[interview_id] = records
        cutoff = _utc_now() - timedelta(seconds=max_age_seconds)
        for rec in reversed(records):
            if not rec.verified or rec.status != "passed":
                continue
            try:
                created = datetime.fromisoformat(rec.created_at.replace("Z", "+00:00"))
            except ValueError:
                continue
            if created.tzinfo is None:
                created = created.replace(tzinfo=timezone.utc)
            if created >= cutoff:
                if rec.expires_at:
                    try:
                        exp = datetime.fromisoformat(rec.expires_at.replace("Z", "+00:00"))
                        if exp.tzinfo is None:
                            exp = exp.replace(tzinfo=timezone.utc)
                        if exp < _utc_now():
                            continue
                    except ValueError:
                        pass
                return rec
        return None

    def _load_all(self, interview_id: str) -> list[FaceAuditRecord]:
        if self._use_db():
            from app.services.face.audit_db import list_for_interview

            rows = list_for_interview(interview_id)
            if rows:
                return rows
        return self._load_disk(interview_id)

    def _load_disk(self, interview_id: str) -> list[FaceAuditRecord]:
        path = self._path(interview_id)
        if path is None or not path.exists():
            return []
        out: list[FaceAuditRecord] = []
        try:
            for line in path.read_text(encoding="utf-8").splitlines():
                if not line.strip():
                    continue
                data = json.loads(line)
                if isinstance(data, dict):
                    out.append(
                        FaceAuditRecord(
                            **{k: data.get(k) for k in FaceAuditRecord.__dataclass_fields__}
                        )
                    )
        except Exception:  # noqa: BLE001
            logger.warning("Failed to load face audits for %s", interview_id, exc_info=True)
        return out

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


def new_audit_id() -> str:
    return f"fv-{uuid4().hex[:16]}"


def build_face_audit_store() -> FaceVerificationAuditStore:
    try:
        settings = get_settings()
        persist = getattr(settings, "face_verification_audit_dir", None) or (
            ".data/face_verification_audits"
        )
    except Exception:  # noqa: BLE001
        persist = ".data/face_verification_audits"
    return FaceVerificationAuditStore(persist_dir=persist)


face_audit_store = build_face_audit_store()
