"""Postgres store for interview_evaluations (completed evals drive PDF)."""

from __future__ import annotations

import logging
from datetime import datetime, timezone
from typing import Any
from uuid import uuid4

from app.database import SessionLocal
from app.models.interview_evaluation import InterviewEvaluationRecord

logger = logging.getLogger(__name__)


def _utc_now() -> datetime:
    return datetime.now(timezone.utc)


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


def get_by_candidate_interview(
    candidate_id: str, interview_id: str
) -> InterviewEvaluationRecord | None:
    db = SessionLocal()
    try:
        row = (
            db.query(InterviewEvaluationRecord)
            .filter(
                InterviewEvaluationRecord.candidate_id == candidate_id,
                InterviewEvaluationRecord.interview_id == interview_id,
            )
            .first()
        )
        if row is not None:
            db.expunge(row)
        return row
    finally:
        db.close()


def begin_processing(
    *,
    candidate_id: str,
    interview_id: str,
    interview_mode: str,
    role_title: str,
    company_name: str | None = None,
) -> InterviewEvaluationRecord:
    """Create or reset row to processing (clears prior completed scores)."""
    db = SessionLocal()
    try:
        row = (
            db.query(InterviewEvaluationRecord)
            .filter(
                InterviewEvaluationRecord.candidate_id == candidate_id,
                InterviewEvaluationRecord.interview_id == interview_id,
            )
            .first()
        )
        now = _utc_now()
        if row is None:
            row = InterviewEvaluationRecord(
                evaluation_id=_new_id(),
                candidate_id=candidate_id,
                interview_id=interview_id,
                interview_mode=interview_mode,
                company_name=company_name,
                role_title=role_title or "",
                evaluation_status="processing",
                processing_stage="media_pending",
                evaluation_version=1,
                competency_scores=[],
                question_evaluations=[],
                strengths=[],
                improvement_areas=[],
                transcription_refs=[],
                video_analysis_refs=[],
                meta={},
                created_at=now,
                updated_at=now,
            )
            db.add(row)
        else:
            row.interview_mode = interview_mode
            row.company_name = company_name
            row.role_title = role_title or row.role_title or ""
            row.evaluation_status = "processing"
            row.processing_stage = "media_pending"
            row.evaluation_version = int(row.evaluation_version or 0) + 1
            row.overall_score = None
            row.competency_scores = []
            row.question_evaluations = []
            row.strengths = []
            row.improvement_areas = []
            row.evaluation_summary = None
            row.final_recommendation = None
            row.result_payload = None
            row.transcription_refs = []
            row.video_analysis_refs = []
            row.error_code = None
            row.error_message = None
            row.meta = dict(row.meta or {})
            row.updated_at = now
        db.commit()
        db.refresh(row)
        db.expunge(row)
        return row
    finally:
        db.close()


def update_stage(
    evaluation_id: str,
    *,
    processing_stage: str,
    transcription_refs: list[dict[str, Any]] | None = None,
    video_analysis_refs: list[dict[str, Any]] | None = None,
    meta_patch: dict[str, Any] | None = None,
) -> None:
    db = SessionLocal()
    try:
        row = (
            db.query(InterviewEvaluationRecord)
            .filter(InterviewEvaluationRecord.evaluation_id == evaluation_id)
            .first()
        )
        if row is None:
            return
        row.processing_stage = processing_stage
        if transcription_refs is not None:
            row.transcription_refs = list(transcription_refs)
        if video_analysis_refs is not None:
            row.video_analysis_refs = list(video_analysis_refs)
        if meta_patch:
            meta = dict(row.meta or {})
            meta.update(meta_patch)
            row.meta = meta
        row.updated_at = _utc_now()
        db.commit()
    finally:
        db.close()


def mark_failed(
    evaluation_id: str,
    *,
    error_code: str,
    error_message: str,
    processing_stage: str | None = None,
) -> InterviewEvaluationRecord | None:
    db = SessionLocal()
    try:
        row = (
            db.query(InterviewEvaluationRecord)
            .filter(InterviewEvaluationRecord.evaluation_id == evaluation_id)
            .first()
        )
        if row is None:
            return None
        row.evaluation_status = "failed"
        row.processing_stage = processing_stage or row.processing_stage or "failed"
        row.error_code = error_code
        row.error_message = error_message
        # Never leave completed-looking scores on a failed row
        row.overall_score = None
        row.result_payload = None
        row.updated_at = _utc_now()
        db.commit()
        db.refresh(row)
        db.expunge(row)
        return row
    finally:
        db.close()


def mark_completed(
    evaluation_id: str,
    *,
    overall_score: float | None,
    competency_scores: list[Any],
    question_evaluations: list[Any],
    strengths: list[str],
    improvement_areas: list[str],
    evaluation_summary: str,
    final_recommendation: dict[str, Any],
    result_payload: dict[str, Any],
    transcription_refs: list[dict[str, Any]] | None = None,
    video_analysis_refs: list[dict[str, Any]] | None = None,
) -> InterviewEvaluationRecord | None:
    """Persist structured fields then set completed — only after successful save."""
    db = SessionLocal()
    try:
        row = (
            db.query(InterviewEvaluationRecord)
            .filter(InterviewEvaluationRecord.evaluation_id == evaluation_id)
            .first()
        )
        if row is None:
            return None
        row.processing_stage = "saving"
        row.overall_score = overall_score
        row.competency_scores = list(competency_scores or [])
        row.question_evaluations = list(question_evaluations or [])
        row.strengths = list(strengths or [])
        row.improvement_areas = list(improvement_areas or [])
        row.evaluation_summary = evaluation_summary
        row.final_recommendation = dict(final_recommendation or {})
        row.result_payload = dict(result_payload or {})
        if transcription_refs is not None:
            row.transcription_refs = list(transcription_refs)
        if video_analysis_refs is not None:
            row.video_analysis_refs = list(video_analysis_refs)
        row.error_code = None
        row.error_message = None
        row.evaluation_status = "completed"
        row.processing_stage = "completed"
        row.updated_at = _utc_now()
        db.commit()
        db.refresh(row)
        db.expunge(row)
        return row
    except Exception:
        logger.exception("Failed to persist completed evaluation %s", evaluation_id)
        db.rollback()
        raise
    finally:
        db.close()
