"""Schemas — Live interview session orchestration (composes existing AI APIs)."""

from enum import Enum
from typing import Any
from uuid import UUID

from pydantic import BaseModel, Field, model_validator

from app.prompts import Persona
from app.schemas.common import StubMeta
from app.schemas.questions import Difficulty, QuestionType


class SessionStatus(str, Enum):
    ACTIVE = "active"
    COMPLETED = "completed"


class SessionPhase(str, Enum):
    AWAITING_ANSWER = "awaiting_answer"
    COMPLETED = "completed"


class SessionQuestionOut(BaseModel):
    id: str
    text: str
    kind: str = Field(description="planned | follow_up")
    parent_question_id: str | None = None


class EvaluationSummary(BaseModel):
    score: float | None = None
    score_band: str | None = None
    explanation: str | None = None
    feedback: str | None = None
    strengths: list[str] = Field(default_factory=list)
    weaknesses: list[str] = Field(default_factory=list)
    gaps: list[str] = Field(default_factory=list)
    improvement_feedback: list[str] = Field(default_factory=list)
    next_action: str | None = None
    degraded: bool = False
    calibrated: bool = False
    partial_credit: bool = False
    dimensions: list[dict[str, Any]] = Field(
        default_factory=list,
        description="Rubric dimension scores (correctness, relevance, depth, …)",
    )


class PlannedQuestionIn(BaseModel):
    """Pre-authored question from Interview Design (workflow preview)."""

    id: str | None = None
    text: str = Field(..., min_length=1)


class InterviewSessionStartRequest(BaseModel):
    """POST /api/v1/interviews/sessions/start

    Live interview displays **only** questions authored in Interview Design
    (workflow generate/preview). No runtime question generation.
    Provide ``workflow_id`` and/or ``planned_questions`` (or an ``interview_id``
    that already has a workflow).
    """

    correlation_id: UUID | None = None
    interview_id: str | None = Field(
        default=None,
        description=(
            "Optional client interview id; when omitted the server generates "
            "`int-{12 hex}`. Prefer omitting in production and reuse the returned id."
        ),
    )
    workflow_id: str | None = Field(
        default=None,
        description="Interview Design workflowId whose previewed questions to run",
    )
    planned_questions: list[PlannedQuestionIn] = Field(
        default_factory=list,
        description="Explicit question bank (from workflow preview). Required if no workflow_id.",
    )
    owner_id: str | None = Field(
        default=None,
        description=(
            "Optional platform owner (candidate/user id). When set, subsequent "
            "session calls must send the same value as header X-Interview-Owner."
        ),
    )
    role_title: str = Field(..., min_length=1)
    job_description: str = Field(..., min_length=20)
    persona: Persona = Persona.TECHNICAL
    seniority: str | None = None
    department: str | None = None
    skills: list[str] = Field(default_factory=list)
    question_types: list[QuestionType] = Field(
        default_factory=lambda: [QuestionType.SHORT_ANSWER],
    )
    difficulty: Difficulty = Difficulty.MEDIUM
    question_count: int | None = Field(
        default=None,
        ge=1,
        le=50,
        description="Optional cap on planned questions (defaults to full bank)",
    )
    language: str = Field(default="en", min_length=2, max_length=10)
    instructions: str | None = None
    max_follow_ups_per_question: int = Field(
        default=0,
        ge=0,
        le=3,
        description="Deprecated — live adaptive follow-ups removed; kept for compat (ignored unless 0)",
    )
    follow_up_score_threshold: float = Field(
        default=0.75,
        ge=0.0,
        le=1.0,
        description="Unused — live follow-up generation removed",
    )
    require_face_verification: bool | None = Field(
        default=None,
        description=(
            "When true, session start requires a recent passed "
            "POST /face-verification/verify for this interview_id after "
            "registration enroll. "
            "When null, uses FACE_VERIFICATION_REQUIRED_FOR_SESSION."
        ),
    )
    options: dict[str, Any] = Field(default_factory=dict)

    @model_validator(mode="after")
    def _require_question_source(self) -> "InterviewSessionStartRequest":
        has_bank = bool(self.planned_questions)
        has_workflow = bool((self.workflow_id or "").strip())
        # interview_id alone may resolve a Design workflow at runtime.
        has_interview = bool((self.interview_id or "").strip())
        if not (has_bank or has_workflow or has_interview):
            raise ValueError(
                "Provide planned_questions and/or workflow_id "
                "(Interview Design preview bank). "
                "Live sessions never generate questions."
            )
        return self


class InterviewSessionStartResponse(StubMeta):
    correlation_id: UUID | None = None
    interview_id: str
    session_access_token: str = Field(
        ...,
        description=(
            "Capability token for this session. Send as header "
            "X-Interview-Access-Token on answer/GET/recover/complete/final-evaluation."
        ),
    )
    owner_id: str | None = None
    session_status: SessionStatus
    phase: SessionPhase
    role_title: str
    persona: Persona
    planned_question_ids: list[str] = Field(default_factory=list)
    current_question: SessionQuestionOut | None = None
    questions_remaining: int = 0
    face_verified: bool = False
    face_audit_id: str | None = None
    degraded: bool = False
    warnings: list[str] = Field(default_factory=list)
    checkpoint_version: int = 0


class InterviewSessionAnswerRequest(BaseModel):
    """POST /api/v1/interviews/sessions/{interview_id}/answer

    Provide either `answer` text or `audio_base64` (Whisper STT).
    """

    correlation_id: UUID | None = None
    question_id: str | None = Field(
        default=None,
        description=(
            "Question being answered. Omit to use the session's current question "
            "(Swagger Try-it-out after sessions/start)."
        ),
    )
    answer: str | None = Field(
        default=None,
        description="Text answer; optional when audio_base64 is provided",
    )
    audio_base64: str | None = Field(
        default=None,
        description="Candidate answer audio (base64); transcribed via Whisper STT",
    )
    audio_mime_type: str = Field(default="audio/wav")
    idempotency_key: str | None = Field(
        default=None,
        description="Optional key to ignore duplicate submissions of the same answer",
    )
    language: str = Field(default="en", min_length=2, max_length=10)
    options: dict[str, Any] = Field(default_factory=dict)

    @model_validator(mode="after")
    def require_text_or_audio(self) -> "InterviewSessionAnswerRequest":
        has_text = bool(self.answer and self.answer.strip())
        has_audio = bool(self.audio_base64 and self.audio_base64.strip())
        if not has_text and not has_audio:
            raise ValueError("Provide answer text or audio_base64")
        if has_text and len(self.answer.strip()) < 1:  # type: ignore[union-attr]
            raise ValueError("answer must be non-empty when provided")
        return self


class InterviewSessionAnswerResponse(StubMeta):
    correlation_id: UUID | None = None
    interview_id: str
    session_status: SessionStatus
    phase: SessionPhase
    duplicate: bool = False
    evaluation: EvaluationSummary | None = None
    current_question: SessionQuestionOut | None = None
    questions_remaining: int = 0
    asked_question_ids: list[str] = Field(default_factory=list)
    completed: bool = False
    transcript_text: str | None = Field(
        default=None,
        description="Resolved candidate answer text (from STT when audio was sent)",
    )
    stt_provider: str | None = None
    degraded: bool = False
    warnings: list[str] = Field(default_factory=list)
    recovered: bool = False
    checkpoint_version: int = 0


class InterviewSessionStateResponse(StubMeta):
    correlation_id: UUID | None = None
    interview_id: str
    session_status: SessionStatus
    phase: SessionPhase
    role_title: str
    persona: Persona
    planned_question_ids: list[str] = Field(default_factory=list)
    asked_question_ids: list[str] = Field(default_factory=list)
    current_question: SessionQuestionOut | None = None
    questions_remaining: int = 0
    last_score: float | None = None
    turn_count: int = 0
    transcript: list[dict[str, Any]] = Field(default_factory=list)
    evaluations: list[dict[str, Any]] = Field(default_factory=list)
    recovered: bool = False
    checkpoint_version: int = 0


class InterviewSessionCompleteRequest(BaseModel):
    correlation_id: UUID | None = None
    reason: str | None = Field(default="client_complete")


class InterviewSessionCompleteResponse(StubMeta):
    correlation_id: UUID | None = None
    interview_id: str
    session_status: SessionStatus
    phase: SessionPhase
    asked_question_ids: list[str] = Field(default_factory=list)
    turn_count: int = 0
    last_score: float | None = None
    recovered: bool = False
    checkpoint_version: int = 0
