"""In-memory reference-check state for questionnaire → responses → report."""

from __future__ import annotations

import threading
from copy import deepcopy
from dataclasses import dataclass, field
from datetime import datetime, timezone
from typing import Any
from uuid import uuid4


def _utc_iso() -> str:
    return datetime.now(timezone.utc).isoformat()


@dataclass
class ReferenceCheckRecord:
    reference_check_id: str
    candidate_id: str
    role_title: str
    status: str
    candidate_name: str | None = None
    job_description: str | None = None
    language: str = "en"
    questions: list[dict[str, Any]] = field(default_factory=list)
    referees: list[dict[str, Any]] = field(default_factory=list)
    responses: list[dict[str, Any]] = field(default_factory=list)
    report: dict[str, Any] | None = None
    created_at: str = field(default_factory=_utc_iso)
    updated_at: str = field(default_factory=_utc_iso)

    def to_dict(self) -> dict[str, Any]:
        return {
            "reference_check_id": self.reference_check_id,
            "questionnaire_id": self.reference_check_id,
            "candidate_id": self.candidate_id,
            "candidate_name": self.candidate_name,
            "role_title": self.role_title,
            "job_description": self.job_description,
            "language": self.language,
            "status": self.status,
            "questions": deepcopy(self.questions),
            "referees": deepcopy(self.referees),
            "responses": deepcopy(self.responses),
            "report": deepcopy(self.report),
            "created_at": self.created_at,
            "updated_at": self.updated_at,
        }


class ReferenceCheckStore:
    def __init__(self) -> None:
        self._lock = threading.RLock()
        self._by_id: dict[str, ReferenceCheckRecord] = {}

    def create(
        self,
        *,
        candidate_id: str,
        role_title: str,
        candidate_name: str | None = None,
        job_description: str | None = None,
        language: str = "en",
        questions: list[dict[str, Any]] | None = None,
        referees: list[dict[str, Any]] | None = None,
        status: str = "questionnaire_ready",
    ) -> ReferenceCheckRecord:
        rid = str(uuid4())
        rec = ReferenceCheckRecord(
            reference_check_id=rid,
            candidate_id=candidate_id,
            candidate_name=candidate_name,
            role_title=role_title,
            job_description=job_description,
            language=language,
            status=status,
            questions=list(questions or []),
            referees=list(referees or []),
        )
        with self._lock:
            self._by_id[rid] = rec
        return deepcopy(rec)

    def get(self, reference_check_id: str) -> ReferenceCheckRecord | None:
        with self._lock:
            rec = self._by_id.get(reference_check_id)
            return deepcopy(rec) if rec else None

    def find_latest_for_candidate(self, candidate_id: str) -> ReferenceCheckRecord | None:
        cid = (candidate_id or "").strip()
        if not cid:
            return None
        with self._lock:
            matches = [r for r in self._by_id.values() if r.candidate_id == cid]
            if not matches:
                return None
            matches.sort(key=lambda r: r.updated_at, reverse=True)
            return deepcopy(matches[0])

    def update(self, rec: ReferenceCheckRecord) -> ReferenceCheckRecord:
        rec.updated_at = _utc_iso()
        with self._lock:
            self._by_id[rec.reference_check_id] = deepcopy(rec)
        return deepcopy(rec)


_STORE: ReferenceCheckStore | None = None
_STORE_LOCK = threading.Lock()


def get_reference_check_store() -> ReferenceCheckStore:
    global _STORE
    with _STORE_LOCK:
        if _STORE is None:
            _STORE = ReferenceCheckStore()
        return _STORE
