"""Schemas — Interview creation workflow (setup → persona → questions)."""

from __future__ import annotations

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

from pydantic import BaseModel, ConfigDict, Field

from app.schemas.common import StubMeta


class WorkflowStatus(str, Enum):
    DRAFT = "draft"
    PERSONA_SELECTED = "persona_selected"
    QUESTIONS_READY = "questions_ready"
    PREVIEW_READY = "preview_ready"
    READY_FOR_SCHEDULING = "ready_for_scheduling"


class InterviewMode(str, Enum):
    TEXT = "text"
    VOICE = "voice"
    VIDEO = "video"


class QuestionSource(str, Enum):
    AI = "ai"
    CUSTOM = "custom"


class _CamelModel(BaseModel):
    model_config = ConfigDict(populate_by_name=True, extra="ignore")


class InterviewWorkflowCreateRequest(_CamelModel):
    """POST /api/v1/interview-workflows"""

    correlation_id: UUID | None = None
    title: str = Field(..., min_length=1, examples=["Backend Developer Interview"])
    role: str | None = Field(default=None, alias="role", examples=["Backend Developer"])
    role_title: str | None = Field(
        default=None, alias="roleTitle", examples=["Backend Developer"]
    )
    skills: list[str] = Field(
        default_factory=list, examples=[["Python", "FastAPI", "PostgreSQL"]]
    )
    experience_level: str | None = Field(
        default=None, alias="experienceLevel", examples=["Mid-level"]
    )
    duration_minutes: int | None = Field(
        default=30, alias="durationMinutes", ge=5, le=480, examples=[30]
    )
    language: str = Field(
        default="en",
        examples=["en"],
        description=(
            "Interview content language. Question generate uses this value "
            "(no separate /translate call)."
        ),
    )
    difficulty: str = Field(default="medium", examples=["medium"])
    mode: InterviewMode = Field(
        default=InterviewMode.VIDEO,
        description="Interview mode selected before live: text | voice | video",
        examples=["video"],
    )
    job_description: str | None = Field(
        default=None,
        alias="jobDescription",
        examples=[
            "Build and operate FastAPI services with PostgreSQL and Redis. "
            "Own latency, reliability, and code quality."
        ],
    )
    interview_id: str | None = Field(default=None, alias="interviewId")
    options: dict[str, Any] = Field(default_factory=dict)

    model_config = ConfigDict(
        populate_by_name=True,
        extra="ignore",
        json_schema_extra={
            "example": {
                "title": "Backend Developer Interview",
                "role": "Backend Developer",
                "skills": ["Python", "FastAPI", "PostgreSQL"],
                "experienceLevel": "Mid-level",
                "durationMinutes": 30,
                "language": "en",
                "difficulty": "medium",
                "mode": "video",
                "jobDescription": (
                    "Build and operate FastAPI services with PostgreSQL and Redis. "
                    "Own latency, reliability, and code quality."
                ),
            }
        },
    )

    def resolved_role_title(self) -> str:
        return (self.role_title or self.role or self.title or "").strip()


class InterviewWorkflowPatchRequest(_CamelModel):
    """PATCH /api/v1/interview-workflows/{workflow_id}"""

    correlation_id: UUID | None = None
    title: str | None = None
    role: str | None = None
    role_title: str | None = Field(default=None, alias="roleTitle")
    skills: list[str] | None = None
    experience_level: str | None = Field(default=None, alias="experienceLevel")
    duration_minutes: int | None = Field(default=None, alias="durationMinutes", ge=5, le=480)
    language: str | None = None
    difficulty: str | None = None
    mode: InterviewMode | None = Field(
        default=None,
        description="Interview mode: text | voice | video",
    )
    job_description: str | None = Field(default=None, alias="jobDescription")
    persona_id: str | None = Field(
        default=None,
        alias="personaId",
        examples=["183f7121-8d2c-4782-95be-5b0d27d9f956"],
        description="Persona UUID from POST /personas (or built-in catalog id).",
    )
    interview_id: str | None = Field(default=None, alias="interviewId")
    options: dict[str, Any] | None = None

    model_config = ConfigDict(
        populate_by_name=True,
        extra="ignore",
        json_schema_extra={
            "example": {
                "personaId": "183f7121-8d2c-4782-95be-5b0d27d9f956",
                "mode": "video",
                "durationMinutes": 45,
            }
        },
    )


class WorkflowQuestionGenerateRequest(_CamelModel):
    """POST .../questions/generate

    Questions are generated for the given ``personaId`` — normally the UUID
    returned by ``POST /personas``. Persona is saved on the workflow and used
    for generation; successful generate completes the workflow
    (``ready_for_scheduling``).
    """

    correlation_id: UUID | None = None
    persona_id: str = Field(
        ...,
        alias="personaId",
        min_length=1,
        description=(
            "Persona id from POST /personas (UUID, e.g. "
            "183f7121-8d2c-4782-95be-5b0d27d9f956). Built-in catalog ids "
            "(technical, hr_behavioral, …) are also accepted."
        ),
        examples=["183f7121-8d2c-4782-95be-5b0d27d9f956"],
    )
    question_count: int = Field(
        default=8, alias="questionCount", ge=1, le=40, examples=[5]
    )
    question_types: list[str] = Field(
        default_factory=lambda: ["technical", "scenario"],
        alias="questionTypes",
        examples=[["technical", "scenario", "behavioral"]],
    )
    replace_existing: bool = Field(
        default=True,
        alias="replaceExisting",
        description="When true, replace prior AI questions; custom questions are kept",
        examples=[True],
    )
    candidate_id: str | None = Field(
        default=None,
        alias="candidateId",
        description="Optional candidate — ResumeInputProcessor loads stored resume",
    )
    resume_text: str | None = Field(
        default=None,
        alias="resumeText",
        description="Optional resume text (or use candidateId for stored profile)",
    )
    resume_structured: dict[str, Any] = Field(
        default_factory=dict,
        alias="resumeStructured",
    )
    content_base64: str | None = Field(
        default=None,
        alias="contentBase64",
        description="Optional resume file (base64) normalized before question generation",
    )
    source_url: str | None = Field(default=None, alias="sourceUrl")
    document_type: str | None = Field(default=None, alias="documentType")
    filename: str | None = None
    options: dict[str, Any] = Field(default_factory=dict)

    model_config = ConfigDict(
        populate_by_name=True,
        extra="ignore",
        json_schema_extra={
            "example": {
                "personaId": "183f7121-8d2c-4782-95be-5b0d27d9f956",
                "questionCount": 5,
                "questionTypes": ["technical", "scenario"],
                "replaceExisting": True,
            }
        },
    )


class WorkflowQuestionCreateRequest(_CamelModel):
    """Create item for POST .../questions/batch (and legacy single-create shape)."""

    text: str = Field(
        ...,
        min_length=3,
        examples=["Describe a time you reduced API p95 latency."],
    )
    question_type: str = Field(
        default="short_answer",
        alias="questionType",
        examples=["short_answer", "scenario", "behavioral"],
    )
    skill: str | None = Field(default=None, examples=["FastAPI"])
    difficulty: str | None = Field(default=None, examples=["medium"])
    category: str | None = Field(default=None, examples=["Technical"])
    evaluation_criteria: list[str] = Field(
        default_factory=list,
        alias="evaluationCriteria",
        examples=[["technical_depth", "clarity", "ownership"]],
    )
    response_format: str | None = Field(
        default="text", alias="responseFormat", examples=["text"]
    )
    response_time_seconds: int | None = Field(
        default=None, alias="responseTimeSeconds", examples=[180]
    )
    position: int | None = Field(default=None, examples=[0])
    meta: dict[str, Any] = Field(default_factory=dict)


class WorkflowQuestionPatchRequest(_CamelModel):
    """Patch fields for a question (used inside batch update items)."""

    text: str | None = None
    question_type: str | None = Field(default=None, alias="questionType")
    skill: str | None = None
    difficulty: str | None = None
    category: str | None = None
    evaluation_criteria: list[str] | None = Field(default=None, alias="evaluationCriteria")
    response_format: str | None = Field(default=None, alias="responseFormat")
    response_time_seconds: int | None = Field(default=None, alias="responseTimeSeconds")
    position: int | None = None
    meta: dict[str, Any] | None = None


class WorkflowQuestionBatchUpdateItem(WorkflowQuestionPatchRequest):
    """Update item for POST .../questions/batch."""

    question_id: str = Field(
        ..., min_length=1, alias="questionId", examples=["q-a1b2c3d4e5"]
    )


# Swagger Try-it-out dropdown for POST .../questions/batch
WORKFLOW_QUESTIONS_BATCH_OPENAPI_EXAMPLES: dict[str, dict[str, Any]] = {
    "create_only": {
        "summary": "Add custom questions",
        "value": {
            "create": [
                {
                    "text": "Describe a time you reduced API p95 latency.",
                    "questionType": "short_answer",
                    "skill": "FastAPI",
                    "difficulty": "medium",
                    "category": "Technical",
                    "evaluationCriteria": ["technical_depth", "clarity", "ownership"],
                    "responseFormat": "text",
                    "responseTimeSeconds": 180,
                },
                {
                    "text": "How would you design a cache-aside Redis layer?",
                    "questionType": "scenario",
                    "skill": "Redis",
                    "difficulty": "medium",
                    "category": "Scenario",
                    "evaluationCriteria": [
                        "problem_framing",
                        "decision_quality",
                        "tradeoff_reasoning",
                    ],
                    "responseFormat": "text",
                    "responseTimeSeconds": 240,
                },
            ]
        },
    },
    "mixed": {
        "summary": "Create + update + delete + reorder",
        "value": {
            "create": [
                {
                    "text": "Walk through a production incident you owned.",
                    "questionType": "behavioral",
                    "category": "Behavioral",
                    "difficulty": "medium",
                    "responseFormat": "text",
                    "responseTimeSeconds": 300,
                }
            ],
            "update": [
                {
                    "questionId": "q-a1b2c3d4e5",
                    "text": "Describe how you measured and improved p95 latency.",
                    "difficulty": "hard",
                }
            ],
            "delete": ["q-old9f8e7d6c"],
            "reorder": ["q-a1b2c3d4e5", "q-new1234567"],
        },
    },
    "reorder_only": {
        "summary": "Reorder existing questions",
        "value": {
            "reorder": ["q-a1b2c3d4e5", "q-b2c3d4e5f6", "q-c3d4e5f6a7"]
        },
    },
}


class WorkflowQuestionsBatchRequest(_CamelModel):
    """POST .../questions/batch — create, update, delete, reorder in one request.

    Applied in a single transaction: delete → update → create → reorder.
    At least one of create / update / delete / reorder must be non-empty.
    """

    correlation_id: UUID | None = None
    create: list[WorkflowQuestionCreateRequest] = Field(default_factory=list)
    update: list[WorkflowQuestionBatchUpdateItem] = Field(default_factory=list)
    delete: list[str] = Field(
        default_factory=list,
        description="questionId values to remove",
        examples=[["q-old9f8e7d6c"]],
    )
    reorder: list[str] | None = Field(
        default=None,
        alias="reorder",
        description="Full questionId order after mutations (optional)",
        examples=[["q-a1b2c3d4e5", "q-b2c3d4e5f6"]],
    )

    model_config = ConfigDict(
        populate_by_name=True,
        extra="ignore",
        json_schema_extra={
            "example": WORKFLOW_QUESTIONS_BATCH_OPENAPI_EXAMPLES["create_only"]["value"]
        },
    )

    def has_ops(self) -> bool:
        return bool(self.create or self.update or self.delete or self.reorder)


class WorkflowQuestionOut(_CamelModel):
    """Question row for workflow GET/preview — includes old preview aliases (stem/id)."""

    question_id: str = Field(alias="questionId")
    # Old interview-preview used `id` + `stem`; keep both for UI parity.
    id: str | None = None
    text: str
    stem: str | None = None
    question_type: str = Field(alias="questionType")
    skill: str | None = None
    difficulty: str | None = None
    category: str | None = None
    evaluation_criteria: list[str] = Field(default_factory=list, alias="evaluationCriteria")
    source: str
    position: int
    response_format: str | None = Field(default=None, alias="responseFormat")
    response_time_seconds: int | None = Field(default=None, alias="responseTimeSeconds")
    options: list[Any] = Field(default_factory=list)
    explanation: str | None = None
    answer: str | None = None
    locked: bool = False
    created_at: datetime | None = Field(default=None, alias="createdAt")
    updated_at: datetime | None = Field(default=None, alias="updatedAt")


class InterviewWorkflowResponse(StubMeta):
    correlation_id: UUID | None = None
    workflow_id: str = Field(alias="workflowId")
    interview_id: str | None = Field(default=None, alias="interviewId")
    company_id: str | None = Field(default=None, alias="companyId")
    user_id: str | None = Field(default=None, alias="userId")
    title: str
    role_title: str = Field(alias="roleTitle")
    skills: list[str] = Field(default_factory=list)
    experience_level: str | None = Field(default=None, alias="experienceLevel")
    duration_minutes: int | None = Field(default=None, alias="durationMinutes")
    language: str = "en"
    difficulty: str = "medium"
    mode: str = "video"
    persona_id: str | None = Field(default=None, alias="personaId")
    job_description: str | None = Field(default=None, alias="jobDescription")
    status: str
    version: int = 1
    questions: list[WorkflowQuestionOut] = Field(default_factory=list)
    question_count: int = Field(default=0, alias="questionCount")
    created_at: datetime | None = Field(default=None, alias="createdAt")
    updated_at: datetime | None = Field(default=None, alias="updatedAt")

    model_config = ConfigDict(populate_by_name=True)


class WorkflowPreviewResponse(StubMeta):
    """Preview pack — workflow readiness + old ``/interview-preview`` field parity."""

    correlation_id: UUID | None = None
    workflow_id: str = Field(alias="workflowId")
    # Old preview used preview_id; alias to workflowId for continuity.
    preview_id: str | None = Field(default=None, alias="previewId")
    interview_id: str | None = Field(default=None, alias="interviewId")
    status: str
    workflow_status: str | None = Field(default=None, alias="workflowStatus")
    ready_for_scheduling: bool = Field(default=False, alias="readyForScheduling")
    locked: bool = False
    ready_to_lock: bool = Field(default=False, alias="readyToLock")
    question_count: int = Field(default=0, alias="questionCount")
    persona_id: str | None = Field(default=None, alias="personaId")
    persona: str | None = None
    role_title: str = Field(default="", alias="roleTitle")
    mode: str | None = None
    questions: list[WorkflowQuestionOut] = Field(default_factory=list)
    follow_up_logic: list[dict[str, Any]] = Field(
        default_factory=list, alias="followUpLogic"
    )
    warnings: list[str] = Field(default_factory=list)
    issues: list[str] = Field(default_factory=list)
    preview: dict[str, Any] = Field(default_factory=dict)

    model_config = ConfigDict(populate_by_name=True)
