"""Postgres persistence for interview session checkpoints."""

from __future__ import annotations

import logging
from typing import Any

from app.database import SessionLocal
from app.models.interview_session import InterviewSessionRecord
from app.services.interviews.session_store import (
    InterviewSession,
    session_from_dict,
    session_to_dict,
)

logger = logging.getLogger(__name__)


def _row_to_payload(row: InterviewSessionRecord) -> dict[str, Any]:
    return {
        "interview_id": row.interview_id,
        "role_title": row.role_title or "",
        "job_description": row.job_description or "",
        "persona": row.persona or "technical",
        "language": row.language or "en",
        "skills_focus": list(row.skills_focus or []),
        "planned_questions": list(row.planned_questions or []),
        "asked_question_ids": list(row.asked_question_ids or []),
        "asked_question_texts_norm": list(row.asked_question_texts_norm or []),
        "current_question": row.current_question,
        "transcript": list(row.transcript or []),
        "evaluations": list(row.evaluations or []),
        "processed_answer_keys": list(row.processed_answer_keys or []),
        "follow_ups_for_parent": dict(row.follow_ups_for_parent or {}),
        "max_follow_ups_per_question": int(row.max_follow_ups_per_question or 1),
        "follow_up_score_threshold": float(row.follow_up_score_threshold or 0.75),
        "last_score": row.last_score,
        "status": row.status or "active",
        "phase": row.phase or "awaiting_answer",
        "turn_count": int(row.turn_count or 0),
        "face_verified": bool(row.face_verified),
        "face_audit_id": row.face_audit_id,
        "face_verified_at": row.face_verified_at,
        "access_token": row.access_token,
        "owner_id": row.owner_id,
        "created_at": row.created_at.isoformat() if row.created_at else None,
        "updated_at": row.updated_at.isoformat() if row.updated_at else None,
        "checkpoint_version": int(row.checkpoint_version or 0),
    }


def _apply_payload(row: InterviewSessionRecord, payload: dict[str, Any]) -> None:
    row.role_title = str(payload.get("role_title") or "")
    row.job_description = str(payload.get("job_description") or "")
    row.persona = str(payload.get("persona") or "technical")
    row.language = str(payload.get("language") or "en")
    row.status = str(payload.get("status") or "active")
    row.phase = str(payload.get("phase") or "awaiting_answer")
    row.turn_count = int(payload.get("turn_count") or 0)
    row.last_score = payload.get("last_score")
    row.face_verified = bool(payload.get("face_verified") or False)
    row.face_audit_id = payload.get("face_audit_id")
    row.face_verified_at = payload.get("face_verified_at")
    row.access_token = payload.get("access_token")
    row.owner_id = payload.get("owner_id")
    row.max_follow_ups_per_question = int(payload.get("max_follow_ups_per_question") or 1)
    row.follow_up_score_threshold = float(payload.get("follow_up_score_threshold") or 0.75)
    row.skills_focus = list(payload.get("skills_focus") or [])
    row.planned_questions = list(payload.get("planned_questions") or [])
    row.asked_question_ids = list(payload.get("asked_question_ids") or [])
    row.asked_question_texts_norm = list(payload.get("asked_question_texts_norm") or [])
    row.current_question = payload.get("current_question")
    row.transcript = list(payload.get("transcript") or [])
    row.evaluations = list(payload.get("evaluations") or [])
    row.processed_answer_keys = list(payload.get("processed_answer_keys") or [])
    row.follow_ups_for_parent = dict(payload.get("follow_ups_for_parent") or {})
    row.checkpoint_version = int(payload.get("checkpoint_version") or 0)
    # created_at / updated_at set by caller from session objects


def load_session(interview_id: str) -> InterviewSession | None:
    db = SessionLocal()
    try:
        row = db.get(InterviewSessionRecord, interview_id)
        if row is None:
            return None
        return session_from_dict(_row_to_payload(row))
    except Exception as exc:  # noqa: BLE001
        logger.warning("DB load failed for session %s: %s", interview_id, exc)
        return None
    finally:
        db.close()


def peek_auth_db(interview_id: str) -> tuple[str | None, str | None] | None:
    db = SessionLocal()
    try:
        row = db.get(InterviewSessionRecord, interview_id)
        if row is None:
            return None
        return row.access_token, row.owner_id
    except Exception as exc:  # noqa: BLE001
        logger.warning("DB peek_auth failed for session %s: %s", interview_id, exc)
        return None
    finally:
        db.close()


def exists(interview_id: str) -> bool:
    db = SessionLocal()
    try:
        return db.get(InterviewSessionRecord, interview_id) is not None
    except Exception as exc:  # noqa: BLE001
        logger.warning("DB exists check failed for %s: %s", interview_id, exc)
        return False
    finally:
        db.close()


def upsert_session(session: InterviewSession) -> None:
    """Insert or update checkpoint. Best-effort; raises on hard DB errors."""
    payload = session_to_dict(session)
    db = SessionLocal()
    try:
        row = db.get(InterviewSessionRecord, session.interview_id)
        if row is None:
            row = InterviewSessionRecord(interview_id=session.interview_id)
            db.add(row)
        _apply_payload(row, payload)
        row.created_at = session.created_at
        row.updated_at = session.updated_at
        db.commit()
    except Exception:
        db.rollback()
        raise
    finally:
        db.close()


def delete_session(interview_id: str) -> None:
    db = SessionLocal()
    try:
        row = db.get(InterviewSessionRecord, interview_id)
        if row is not None:
            db.delete(row)
            db.commit()
    except Exception:
        db.rollback()
        raise
    finally:
        db.close()


def upsert_from_payload(payload: dict[str, Any], *, only_if_newer: bool = True) -> str:
    """Import a JSON checkpoint dict. Returns 'inserted'|'updated'|'skipped'."""
    interview_id = str(payload.get("interview_id") or "").strip()
    if not interview_id:
        raise ValueError("payload missing interview_id")
    incoming_ver = int(payload.get("checkpoint_version") or 0)
    session = session_from_dict(payload)

    db = SessionLocal()
    try:
        row = db.get(InterviewSessionRecord, interview_id)
        if row is not None and only_if_newer:
            if int(row.checkpoint_version or 0) >= incoming_ver:
                return "skipped"
        if row is None:
            row = InterviewSessionRecord(interview_id=interview_id)
            db.add(row)
            action = "inserted"
        else:
            action = "updated"
        _apply_payload(row, session_to_dict(session))
        row.created_at = session.created_at
        row.updated_at = session.updated_at
        db.commit()
        return action
    except Exception:
        db.rollback()
        raise
    finally:
        db.close()
