"""Durable ID verification status tracking (JSONL + DB; no raw images)."""

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.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 IdVerificationRecord:
    verification_id: str
    interview_id: str | None
    candidate_id: str | None
    verification_status: str  # verified | manual_review | rejected
    verified: bool
    consent_given: bool
    consent_id: str | None
    consent_version: str | None
    consent_timestamp: str | None
    extracted_name: str | None
    extracted_id_number_masked: str | None
    document_type: str | None
    match_score: float | None
    identity_matched: bool | None
    liveness_passed: bool | None
    expiry_valid: bool | None
    authenticity_passed: bool | None
    name_matched: bool | None
    encrypted_storage_id: str | None
    id_image_sha256: str | None
    attempt: int
    error_code: str | None = None
    warnings: list[str] = field(default_factory=list)
    checks: list[dict[str, Any]] = field(default_factory=list)
    created_at: str = field(default_factory=lambda: _iso(_utc_now()))
    verified_at: str | None = None
    expires_at: str | None = None


def mask_id_number(value: str | None) -> str | None:
    if not value:
        return None
    v = value.strip()
    if len(v) <= 4:
        return "****"
    return f"{'*' * max(4, len(v) - 4)}{v[-4:]}"


class IdVerificationStatusStore:
    def __init__(
        self,
        *,
        persist_dir: str | Path | None = None,
        backend: str | None = None,
    ) -> None:
        self._lock = threading.RLock()
        self._by_id: dict[str, IdVerificationRecord] = {}
        self._by_interview: dict[str, list[str]] = {}
        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 _index_path(self) -> Path | None:
        if self._persist_dir is None:
            return None
        return self._persist_dir / "status_index.jsonl"

    def _interview_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 / "by_interview" / f"{safe}.jsonl"

    def save(self, record: IdVerificationRecord) -> IdVerificationRecord:
        with self._lock:
            self._by_id[record.verification_id] = record
            if record.interview_id:
                self._by_interview.setdefault(record.interview_id, []).append(
                    record.verification_id
                )
            if self._use_disk():
                index = self._index_path()
                if index is not None:
                    try:
                        with index.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 ID status verification_id=%s",
                            record.verification_id,
                            exc_info=True,
                        )
                if record.interview_id:
                    ipath = self._interview_path(record.interview_id)
                    if ipath is not None:
                        try:
                            ipath.parent.mkdir(parents=True, exist_ok=True)
                            with ipath.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 ID status by interview=%s",
                                record.interview_id,
                                exc_info=True,
                            )
            if self._use_db():
                try:
                    from app.services.id.status_db import upsert_record

                    upsert_record(record)
                except Exception:  # noqa: BLE001
                    logger.warning(
                        "Failed to DB-persist ID status %s",
                        record.verification_id,
                        exc_info=True,
                    )
                    if self._backend == "postgres":
                        raise
            return record

    def get(self, verification_id: str) -> IdVerificationRecord | None:
        with self._lock:
            rec = self._by_id.get(verification_id)
        if rec:
            return rec
        if self._use_db():
            from app.services.id.status_db import get_record

            rec = get_record(verification_id)
            if rec:
                with self._lock:
                    self._by_id[rec.verification_id] = rec
                return rec
        return self._load_from_index(verification_id)

    def latest_for_interview(self, interview_id: str) -> IdVerificationRecord | None:
        with self._lock:
            ids = list(self._by_interview.get(interview_id, []))
        if ids:
            with self._lock:
                return self._by_id.get(ids[-1])
        if self._use_db():
            from app.services.id.status_db import list_for_interview

            records = list_for_interview(interview_id)
            if records:
                with self._lock:
                    for r in records:
                        self._by_id[r.verification_id] = r
                    self._by_interview[interview_id] = [
                        r.verification_id for r in records
                    ]
                return records[-1]
        records = self._load_interview_disk(interview_id)
        if not records:
            return None
        with self._lock:
            for r in records:
                self._by_id[r.verification_id] = r
            self._by_interview[interview_id] = [r.verification_id for r in records]
        return records[-1]

    def attempt_count(self, interview_id: str | None) -> int:
        if not interview_id:
            return 0
        with self._lock:
            n = len(self._by_interview.get(interview_id, []))
        if n:
            return n
        if self._use_db():
            from app.services.id.status_db import list_for_interview

            n = len(list_for_interview(interview_id))
            if n:
                return n
        return len(self._load_interview_disk(interview_id))

    def _load_from_index(self, verification_id: str) -> IdVerificationRecord | None:
        path = self._index_path()
        if path is None or not path.exists():
            return None
        found: IdVerificationRecord | None = None
        try:
            for line in path.read_text(encoding="utf-8").splitlines():
                if not line.strip():
                    continue
                data = json.loads(line)
                if isinstance(data, dict) and data.get("verification_id") == verification_id:
                    found = self._from_dict(data)
        except Exception:  # noqa: BLE001
            logger.warning("Failed to load ID status index", exc_info=True)
        if found:
            with self._lock:
                self._by_id[found.verification_id] = found
        return found

    def _load_interview_disk(self, interview_id: str) -> list[IdVerificationRecord]:
        path = self._interview_path(interview_id)
        if path is None or not path.exists():
            return []
        out: list[IdVerificationRecord] = []
        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(self._from_dict(data))
        except Exception:  # noqa: BLE001
            logger.warning(
                "Failed to load ID statuses for interview=%s", interview_id, exc_info=True
            )
        return out

    @staticmethod
    def _from_dict(data: dict[str, Any]) -> IdVerificationRecord:
        fields = IdVerificationRecord.__dataclass_fields__
        return IdVerificationRecord(**{k: data.get(k) for k in fields})

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


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


def build_id_status_store() -> IdVerificationStatusStore:
    try:
        settings = get_settings()
        persist = getattr(settings, "id_verification_status_dir", None) or (
            ".data/id_verification/status"
        )
    except Exception:  # noqa: BLE001
        persist = ".data/id_verification/status"
    return IdVerificationStatusStore(persist_dir=persist)


id_status_store = build_id_status_store()
