"""Interview session store — in-memory + durable JSON checkpoints for recovery."""

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

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) -> str | None:
    if dt is None:
        return None
    if dt.tzinfo is None:
        dt = dt.replace(tzinfo=timezone.utc)
    return dt.isoformat()


def _parse_dt(value: Any) -> datetime:
    if isinstance(value, datetime):
        return value if value.tzinfo else value.replace(tzinfo=timezone.utc)
    if isinstance(value, str) and value:
        try:
            dt = datetime.fromisoformat(value.replace("Z", "+00:00"))
            return dt if dt.tzinfo else dt.replace(tzinfo=timezone.utc)
        except ValueError:
            pass
    return _utc_now()


@dataclass
class SessionQuestion:
    id: str
    text: str
    kind: str = "planned"  # planned | follow_up
    parent_question_id: str | None = None


@dataclass
class InterviewSession:
    interview_id: str
    role_title: str
    job_description: str
    persona: str
    language: str = "en"
    skills_focus: list[str] = field(default_factory=list)
    planned_questions: list[SessionQuestion] = field(default_factory=list)
    asked_question_ids: list[str] = field(default_factory=list)
    asked_question_texts_norm: set[str] = field(default_factory=set)
    current_question: SessionQuestion | None = None
    transcript: list[dict[str, Any]] = field(default_factory=list)
    evaluations: list[dict[str, Any]] = field(default_factory=list)
    processed_answer_keys: set[str] = field(default_factory=set)
    follow_ups_for_parent: dict[str, int] = field(default_factory=dict)
    max_follow_ups_per_question: int = 1
    follow_up_score_threshold: float = 0.75
    last_score: float | None = None
    status: str = "active"  # active | completed
    phase: str = "awaiting_answer"  # awaiting_answer | completed
    turn_count: int = 0
    face_verified: bool = False
    face_audit_id: str | None = None
    face_verified_at: str | None = None
    # Session capability token — required on answer/GET/recover/complete when set.
    access_token: str | None = None
    # Optional platform owner (candidate / user id) — required via X-Interview-Owner when set.
    owner_id: str | None = None
    created_at: datetime = field(default_factory=_utc_now)
    updated_at: datetime = field(default_factory=_utc_now)
    checkpoint_version: int = 0
    lock: threading.RLock = field(default_factory=threading.RLock, repr=False)


def session_to_dict(session: InterviewSession) -> dict[str, Any]:
    current = None
    if session.current_question is not None:
        current = asdict(session.current_question)
    return {
        "interview_id": session.interview_id,
        "role_title": session.role_title,
        "job_description": session.job_description,
        "persona": session.persona,
        "language": session.language,
        "skills_focus": list(session.skills_focus),
        "planned_questions": [asdict(q) for q in session.planned_questions],
        "asked_question_ids": list(session.asked_question_ids),
        "asked_question_texts_norm": sorted(session.asked_question_texts_norm),
        "current_question": current,
        "transcript": list(session.transcript),
        "evaluations": list(session.evaluations),
        "processed_answer_keys": sorted(session.processed_answer_keys),
        "follow_ups_for_parent": dict(session.follow_ups_for_parent),
        "max_follow_ups_per_question": session.max_follow_ups_per_question,
        "follow_up_score_threshold": session.follow_up_score_threshold,
        "last_score": session.last_score,
        "status": session.status,
        "phase": session.phase,
        "turn_count": session.turn_count,
        "face_verified": bool(session.face_verified),
        "face_audit_id": session.face_audit_id,
        "face_verified_at": session.face_verified_at,
        "access_token": session.access_token,
        "owner_id": session.owner_id,
        "created_at": _iso(session.created_at),
        "updated_at": _iso(session.updated_at),
        "checkpoint_version": session.checkpoint_version,
    }


def session_from_dict(data: dict[str, Any]) -> InterviewSession:
    planned = [
        SessionQuestion(**q)
        for q in (data.get("planned_questions") or [])
        if isinstance(q, dict) and q.get("id") and q.get("text")
    ]
    current_raw = data.get("current_question")
    current = (
        SessionQuestion(**current_raw)
        if isinstance(current_raw, dict) and current_raw.get("id") and current_raw.get("text")
        else None
    )
    return InterviewSession(
        interview_id=str(data["interview_id"]),
        role_title=str(data.get("role_title") or ""),
        job_description=str(data.get("job_description") or ""),
        persona=str(data.get("persona") or "technical"),
        language=str(data.get("language") or "en"),
        skills_focus=list(data.get("skills_focus") or []),
        planned_questions=planned,
        asked_question_ids=list(data.get("asked_question_ids") or []),
        asked_question_texts_norm=set(data.get("asked_question_texts_norm") or []),
        current_question=current,
        transcript=list(data.get("transcript") or []),
        evaluations=list(data.get("evaluations") or []),
        processed_answer_keys=set(data.get("processed_answer_keys") or []),
        follow_ups_for_parent={
            str(k): int(v) for k, v in (data.get("follow_ups_for_parent") or {}).items()
        },
        max_follow_ups_per_question=int(data.get("max_follow_ups_per_question") or 1),
        follow_up_score_threshold=float(data.get("follow_up_score_threshold") or 0.75),
        last_score=data.get("last_score"),
        status=str(data.get("status") or "active"),
        phase=str(data.get("phase") or "awaiting_answer"),
        turn_count=int(data.get("turn_count") or 0),
        face_verified=bool(data.get("face_verified") or False),
        face_audit_id=data.get("face_audit_id"),
        face_verified_at=data.get("face_verified_at"),
        access_token=(
            str(data["access_token"]) if data.get("access_token") else None
        ),
        owner_id=str(data["owner_id"]) if data.get("owner_id") else None,
        created_at=_parse_dt(data.get("created_at")),
        updated_at=_parse_dt(data.get("updated_at")),
        checkpoint_version=int(data.get("checkpoint_version") or 0),
    )


def _resolve_backend() -> str:
    from app.persistence import resolve_persist_backend

    return resolve_persist_backend()


class InterviewSessionStore:
    """Process-local cache with durable JSON and/or Postgres checkpoints."""

    def __init__(
        self,
        *,
        persist_dir: str | Path | None = None,
        backend: str | None = None,
    ) -> None:
        self._sessions: dict[str, InterviewSession] = {}
        self._lock = threading.RLock()
        self._persist_dir = Path(persist_dir) if persist_dir else None
        self._last_interview_id: str | None = None
        self._backend = (backend or _resolve_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_for(self, interview_id: str) -> Path | None:
        if self._persist_dir is None:
            return None
        if not _SAFE_ID.match(interview_id):
            logger.warning("Refusing to persist unsafe interview_id=%r", interview_id)
            return None
        safe = interview_id.replace(":", "_").replace("/", "_")
        return self._persist_dir / f"{safe}.json"

    def _save_disk(self, session: InterviewSession) -> None:
        path = self._path_for(session.interview_id)
        if path is None:
            return
        tmp = path.with_suffix(".json.tmp")
        try:
            payload = session_to_dict(session)
            tmp.write_text(json.dumps(payload, indent=2, ensure_ascii=False), encoding="utf-8")
            tmp.replace(path)
        except Exception as exc:  # noqa: BLE001
            logger.warning("Failed to checkpoint session %s: %s", session.interview_id, exc)
            try:
                if tmp.exists():
                    tmp.unlink()
            except OSError:
                pass

    def _save_db(self, session: InterviewSession) -> None:
        from app.services.interviews.session_db import upsert_session

        try:
            upsert_session(session)
        except Exception as exc:  # noqa: BLE001
            logger.warning("Failed to DB-checkpoint session %s: %s", session.interview_id, exc)
            if self._backend == "postgres":
                raise

    def save(self, session: InterviewSession) -> None:
        """Checkpoint session progress (disk and/or DB)."""
        session.updated_at = _utc_now()
        session.checkpoint_version += 1
        if self._use_disk():
            self._save_disk(session)
        if self._use_db():
            self._save_db(session)

    def _load_from_disk(self, interview_id: str) -> InterviewSession | None:
        path = self._path_for(interview_id)
        if path is None or not path.exists():
            return None
        try:
            data = json.loads(path.read_text(encoding="utf-8"))
            if not isinstance(data, dict) or not data.get("interview_id"):
                logger.warning("Invalid checkpoint payload for %s", interview_id)
                return None
            return session_from_dict(data)
        except Exception as exc:  # noqa: BLE001
            logger.warning("Failed to load checkpoint %s: %s", interview_id, exc)
            return None

    def _load_durable(
        self, interview_id: str
    ) -> tuple[InterviewSession | None, str | None]:
        """Load from DB then disk (dual-read). Returns (session, source)."""
        if self._use_db():
            from app.services.interviews.session_db import load_session

            loaded = load_session(interview_id)
            if loaded is not None:
                return loaded, "db"
        if self._use_disk():
            loaded = self._load_from_disk(interview_id)
            if loaded is not None:
                return loaded, "disk"
        # postgres-only: still allow recovering from leftover JSON during cutover
        if self._backend == "postgres":
            loaded = self._load_from_disk(interview_id)
            if loaded is not None:
                return loaded, "disk"
        return None, None

    def _durable_exists(self, interview_id: str) -> bool:
        if self._use_db():
            from app.services.interviews.session_db import exists

            if exists(interview_id):
                return True
        if self._use_disk() and self._load_from_disk(interview_id) is not None:
            return True
        if self._backend == "postgres" and self._load_from_disk(interview_id) is not None:
            return True
        return False

    def create(self, session: InterviewSession) -> InterviewSession:
        with self._lock:
            if session.interview_id in self._sessions:
                raise KeyError(session.interview_id)
            if self._durable_exists(session.interview_id):
                raise KeyError(session.interview_id)
            self._sessions[session.interview_id] = session
            self._last_interview_id = session.interview_id
            self.save(session)
            return session

    def last_interview_id(self) -> str | None:
        """Most recently started session id (Swagger Try-it-out chaining)."""
        with self._lock:
            return self._last_interview_id

    def get(
        self, interview_id: str, *, allow_recover: bool = True
    ) -> tuple[InterviewSession | None, bool]:
        """Return (session, recovered_from_durable_store)."""
        with self._lock:
            session = self._sessions.get(interview_id)
            if session is not None:
                return session, False
            if not allow_recover:
                return None, False
            loaded, source = self._load_durable(interview_id)
            if loaded is None:
                return None, False
            # Write-through: disk → DB during dual cutover
            if source == "disk" and self._use_db():
                try:
                    from app.services.interviews.session_db import upsert_session

                    upsert_session(loaded)
                except Exception as exc:  # noqa: BLE001
                    logger.warning(
                        "Write-through to DB failed for %s: %s", interview_id, exc
                    )
            self._sessions[interview_id] = loaded
            logger.info(
                "Recovered interview session %s from %s", interview_id, source or "store"
            )
            return loaded, True

    def peek_auth(
        self, interview_id: str
    ) -> tuple[str | None, str | None] | None:
        """Return (access_token, owner_id) without warming the in-memory cache."""
        with self._lock:
            session = self._sessions.get(interview_id)
            if session is not None:
                return session.access_token, session.owner_id
            if self._use_db():
                from app.services.interviews.session_db import peek_auth_db

                auth = peek_auth_db(interview_id)
                if auth is not None:
                    return auth
            loaded = self._load_from_disk(interview_id) if self._use_disk() else None
            if loaded is None and self._backend == "postgres":
                loaded = self._load_from_disk(interview_id)
            if loaded is None:
                return None
            return loaded.access_token, loaded.owner_id

    def evict(self, interview_id: str) -> None:
        """Drop in-memory copy only (keeps durable checkpoint)."""
        with self._lock:
            self._sessions.pop(interview_id, None)

    def delete(self, interview_id: str) -> None:
        with self._lock:
            self._sessions.pop(interview_id, None)
            path = self._path_for(interview_id)
            if path is not None and path.exists():
                try:
                    path.unlink()
                except OSError as exc:
                    logger.warning("Failed to delete checkpoint %s: %s", interview_id, exc)
            if self._use_db():
                try:
                    from app.services.interviews.session_db import delete_session

                    delete_session(interview_id)
                except Exception as exc:  # noqa: BLE001
                    logger.warning("Failed to delete DB session %s: %s", interview_id, exc)

    def clear(self) -> None:
        """Clear memory + local JSON. Does not wipe Postgres (safety)."""
        with self._lock:
            self._sessions.clear()
            self._last_interview_id = None
            if self._persist_dir is None or not self._persist_dir.exists():
                return
            for path in self._persist_dir.glob("*.json"):
                try:
                    path.unlink()
                except OSError:
                    pass
            for path in self._persist_dir.glob("*.json.tmp"):
                try:
                    path.unlink()
                except OSError:
                    pass


def _default_persist_dir() -> Path:
    try:
        from app.config import get_settings

        settings = get_settings()
        raw = getattr(settings, "interview_session_persist_dir", None) or ".data/interview_sessions"
        return Path(raw)
    except Exception:  # noqa: BLE001
        return Path(".data/interview_sessions")


# Shared process store (tests can clear / reconfigure)
session_store = InterviewSessionStore(persist_dir=_default_persist_dir())
