"""In-process STT / video-intel prep for final-evaluation (no HTTP self-calls).

Supports N questions with exactly one media answer each:
  Q1 → 1 audio/video
  Q2 → 1 audio/video
"""

from __future__ import annotations

import logging
from dataclasses import dataclass, field
from typing import Any

from app.schemas.final_evaluation import (
    FinalEvaluationRequest,
    MediaEvidenceIn,
    QaItemIn,
)
from app.schemas.interviews import InterviewMode
from app.schemas.transcription import TranscriptionProvider, TranscriptionRequest
from app.schemas.video_intelligence import VideoIntelligenceRequest
from app.services.voice.transcription import TranscriptionService
from app.services.video.intelligence import VideoIntelligenceService

logger = logging.getLogger(__name__)


class EvaluationMediaError(Exception):
    def __init__(self, message: str, *, code: str = "media_processing_failed") -> None:
        super().__init__(message)
        self.code = code


@dataclass
class MediaPrepResult:
    qa_items: list[QaItemIn]
    media_evidence: MediaEvidenceIn | None
    transcription_refs: list[dict[str, Any]] = field(default_factory=list)
    video_analysis_refs: list[dict[str, Any]] = field(default_factory=list)
    warnings: list[str] = field(default_factory=list)
    stage: str = "evaluating"


def _trim_text(text: str, *, max_chars: int = 4000) -> str:
    t = (text or "").strip()
    if len(t) <= max_chars:
        return t
    return t[: max_chars - 20].rstrip() + " …[truncated]"


async def prepare_media_for_evaluation(
    payload: FinalEvaluationRequest,
) -> MediaPrepResult:
    """Fill each QA answer from its single audio/video based on interview_mode."""
    mode = payload.interview_mode
    qa_items = [item.model_copy(deep=True) for item in payload.qa_items]
    warnings: list[str] = []
    transcription_refs: list[dict[str, Any]] = []
    video_analysis_refs: list[dict[str, Any]] = []
    media_evidence = payload.media_evidence

    if mode == InterviewMode.TEXT:
        return MediaPrepResult(
            qa_items=qa_items,
            media_evidence=media_evidence,
            stage="evaluating",
        )

    if mode == InterviewMode.VOICE:
        stt = TranscriptionService()
        for item in qa_items:
            if (item.answer or "").strip():
                continue
            if not item.has_voice_media():
                raise EvaluationMediaError(
                    f"Missing audio for question {item.question_id or item.question[:40]}",
                    code="audio_required",
                )
            req = TranscriptionRequest(
                interview_id=payload.interview_id,
                provider=TranscriptionProvider.OPENAI,
                audio_base64=item.audio_base64,
                source_url=item.audio_source_url,
                language=payload.language,
                options=dict(payload.options or {}),
            )
            try:
                resp = await stt.transcribe(req)
            except Exception as exc:  # noqa: BLE001
                logger.exception("Transcription failed for %s", item.question_id)
                raise EvaluationMediaError(
                    f"Transcription failed for question {item.question_id}: {exc}",
                    code="transcription_failed",
                ) from exc
            text = _trim_text(resp.text or "")
            if not text:
                raise EvaluationMediaError(
                    f"Empty transcription for question {item.question_id}",
                    code="transcription_empty",
                )
            item.answer = text
            transcription_refs.append(
                {
                    "question_id": item.question_id,
                    "provider": getattr(resp.provider, "value", resp.provider),
                    "model": resp.model,
                    "chars": len(text),
                    "error_code": resp.error_code,
                }
            )
        return MediaPrepResult(
            qa_items=qa_items,
            media_evidence=media_evidence,
            transcription_refs=transcription_refs,
            stage="evaluating",
            warnings=warnings,
        )

    # VIDEO — one video per question
    if not payload.consent_given and any(
        item.has_video_media() and not (item.answer or "").strip() for item in qa_items
    ):
        raise EvaluationMediaError(
            "consent_given=true required for video analysis",
            code="consent_required",
        )

    vi = VideoIntelligenceService()
    vi_blob: dict[str, Any] | None = None

    for item in qa_items:
        if (item.answer or "").strip() and not item.has_video_media():
            continue
        if not item.has_video_media():
            if (item.answer or "").strip():
                continue
            raise EvaluationMediaError(
                f"Missing video for question {item.question_id or item.question[:40]}",
                code="video_required",
            )

        vreq = VideoIntelligenceRequest(
            interview_id=payload.interview_id,
            video_base64=item.video_base64,
            source_url=item.video_source_url,
            consent_given=True,
            include_transcript=True,
            include_report=True,
            options=dict(payload.options or {}),
        )
        try:
            vresp = await vi.analyze(vreq)
        except Exception as exc:  # noqa: BLE001
            logger.exception("Video intelligence failed for %s", item.question_id)
            raise EvaluationMediaError(
                f"Video analysis failed for question {item.question_id}: {exc}",
                code="video_analysis_failed",
            ) from exc

        transcript_text = ""
        if vresp.transcript and getattr(vresp.transcript, "text", None):
            transcript_text = _trim_text(vresp.transcript.text or "")
        if not transcript_text and not (item.answer or "").strip():
            raise EvaluationMediaError(
                f"No transcript extracted for question {item.question_id}",
                code="transcription_empty",
            )
        if transcript_text:
            item.answer = transcript_text
            transcription_refs.append(
                {
                    "question_id": item.question_id,
                    "source": "video_intelligence_transcript",
                    "chars": len(transcript_text),
                }
            )

        safe_vi = {
            "faces_detected_ratio": vresp.faces_detected_ratio,
            "multi_face_frames": vresp.multi_face_frames,
            "visual_events": [
                e.model_dump(mode="json") if hasattr(e, "model_dump") else e
                for e in (vresp.visual_events or [])[:40]
            ],
            "report_summary": (
                vresp.report.summary
                if vresp.report and getattr(vresp.report, "summary", None)
                else None
            ),
            "limitations": (
                list(vresp.report.limitations or [])
                if vresp.report and getattr(vresp.report, "limitations", None)
                else []
            ),
            "note": (
                "Visual observations are not used for hiring suitability, "
                "personality, emotion, or appearance scoring"
            ),
        }
        video_analysis_refs.append(
            {
                "question_id": item.question_id,
                "has_transcript": bool(transcript_text),
                "faces_detected_ratio": vresp.faces_detected_ratio,
            }
        )
        vi_blob = safe_vi
        warnings.append(
            "Video intelligence used for transcript/observational context only "
            "(not facial emotion or appearance-based hiring scores)"
        )

    if vi_blob is not None:
        base = media_evidence.model_dump() if media_evidence else {}
        base["video_intelligence"] = vi_blob
        media_evidence = MediaEvidenceIn(**base)

    return MediaPrepResult(
        qa_items=qa_items,
        media_evidence=media_evidence,
        transcription_refs=transcription_refs,
        video_analysis_refs=video_analysis_refs,
        warnings=warnings,
        stage="evaluating",
    )
