"""Unified AI assessment hub — generate / evaluate / code judge contracts."""

from __future__ import annotations

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

from pydantic import BaseModel, ConfigDict, Field, model_validator

from app.schemas.assessments import AssessmentKind
from app.schemas.common import StubMeta
from app.schemas.questions import Difficulty, GeneratedQuestion, QuestionType
from app.schemas.scoring import SkillScoreItem, TestCaseResult, TimingReport


class AssessmentType(str, Enum):
    """POST /ai/generate — only these four assessment types."""

    CODING_CHALLENGE = "coding_challenge"
    APTITUDE_AND_REASONING = "aptitude_and_reasoning"
    PERSONALITY_EVAL = "personality_eval"
    ROLE_CASE_PLAY = "role_case_play"


# Backward-compatible alias used by older imports / OpenAPI titles
AiGenerateKind = AssessmentType


class AssessmentQuestionType(str, Enum):
    """Question format for generated assessments."""

    MCQ = "mcq"
    SHORT_ANSWER = "short_answer"
    MCQ_AND_SHORT_ANSWER = "mcq_and_short_answer"


class AssessmentDifficulty(str, Enum):
    BASIC = "basic"
    MODERATE = "moderate"
    HARD = "hard"


def assessment_kind_from_generate(assessment_type: AssessmentType) -> AssessmentKind:
    """Map public assessment_type → internal AssessmentsService kind."""
    return {
        AssessmentType.CODING_CHALLENGE: AssessmentKind.CODING,
        AssessmentType.APTITUDE_AND_REASONING: AssessmentKind.APTITUDE,
        AssessmentType.PERSONALITY_EVAL: AssessmentKind.CUSTOM,
        AssessmentType.ROLE_CASE_PLAY: AssessmentKind.CASE_STUDY,
    }[assessment_type]


def assessment_kind_from_evaluate(assessment_type: AssessmentType) -> AssessmentKind:
    return assessment_kind_from_generate(assessment_type)


class AssessmentQuestionAnswer(BaseModel):
    """One question + candidate answer (+ Platform-held expected key)."""

    model_config = ConfigDict(populate_by_name=True, extra="ignore")

    question_id: str = Field(..., min_length=1, alias="questionId")
    stem: str | None = None
    answer: Any = Field(
        default=None,
        description="Candidate's submitted answer (selected option, text, etc.)",
    )
    expected_answer: Any = Field(
        default=None,
        alias="expectedAnswer",
        description="Correct answer from Platform-held generate answer_key",
    )
    max_score: float = Field(default=1.0, alias="maxScore", ge=0)
    skills: list[str] = Field(default_factory=list)
    question_type: str | None = Field(default=None, alias="questionType")


def map_assessment_difficulty(level: AssessmentDifficulty) -> Difficulty:
    return {
        AssessmentDifficulty.BASIC: Difficulty.EASY,
        AssessmentDifficulty.MODERATE: Difficulty.MEDIUM,
        AssessmentDifficulty.HARD: Difficulty.HARD,
    }[level]


def map_assessment_question_types(
    question_type: AssessmentQuestionType,
    *,
    assessment_type: AssessmentType,
) -> list[QuestionType]:
    if assessment_type == AssessmentType.CODING_CHALLENGE:
        # Coding challenge always includes coding tasks; mix with MCQ/short when requested
        if question_type == AssessmentQuestionType.MCQ:
            return [QuestionType.CODING, QuestionType.MCQ]
        if question_type == AssessmentQuestionType.SHORT_ANSWER:
            return [QuestionType.CODING, QuestionType.SHORT_ANSWER]
        return [QuestionType.CODING, QuestionType.MCQ, QuestionType.SHORT_ANSWER]
    if question_type == AssessmentQuestionType.MCQ:
        return [QuestionType.MCQ]
    if question_type == AssessmentQuestionType.SHORT_ANSWER:
        return [QuestionType.SHORT_ANSWER]
    return [QuestionType.MCQ, QuestionType.SHORT_ANSWER]


class AiGenerateRequest(BaseModel):
    """POST /api/v1/ai/generate — same body for all assessment_type values.

    JD / skills / role title are **not** sent here; they are loaded from
    ``ai_jobs`` using ``linked_job``.
    """

    model_config = ConfigDict(extra="ignore")

    assessment_type: AssessmentType = Field(
        ...,
        description=(
            "One of: coding_challenge | aptitude_and_reasoning | "
            "personality_eval | role_case_play"
        ),
    )
    question_type: AssessmentQuestionType = Field(
        ...,
        description="mcq | short_answer | mcq_and_short_answer",
    )
    assessment_name: str = Field(..., min_length=1, max_length=200)
    linked_job: str = Field(
        ...,
        min_length=1,
        max_length=128,
        description="Gateway `ai_jobs.job_id` used to fetch JD + skills",
    )
    duration: int = Field(
        ...,
        ge=1,
        le=480,
        description="Assessment duration in minutes",
    )
    difficulty: AssessmentDifficulty = Field(
        ...,
        description="basic | moderate | hard",
    )
    number_of_questions: int = Field(..., ge=1, le=50)
    passing_score: float = Field(
        ...,
        ge=0,
        le=100,
        description="Passing threshold as a percentage (0–100)",
    )

    @model_validator(mode="after")
    def _validate_limits(self) -> AiGenerateRequest:
        if (
            self.assessment_type == AssessmentType.ROLE_CASE_PLAY
            and self.number_of_questions > 10
        ):
            raise ValueError("number_of_questions must be <= 10 for role_case_play")
        return self


class AiGenerateResponse(StubMeta):
    """Normalized generate response echoing request config + generated content."""

    correlation_id: UUID | None = None
    assessment_type: AssessmentType
    question_type: AssessmentQuestionType
    assessment_name: str
    linked_job: str
    duration: int | None = None
    difficulty: AssessmentDifficulty
    number_of_questions: int | None = None
    passing_score: float | None = None
    # Resource ids
    assessment_id: str | None = None
    aptitude_id: str | None = None
    case_id: str | None = None
    scenario_set_id: str | None = None
    role_title: str | None = None
    title: str | None = None
    scenario_markdown: str | None = None
    skills: list[str] = Field(default_factory=list)
    questions: list[GeneratedQuestion] = Field(default_factory=list)
    scenarios: list[GeneratedQuestion] = Field(default_factory=list)
    tasks: list[str] = Field(default_factory=list)
    answer_key: dict[str, Any] = Field(default_factory=dict)
    rubric: dict[str, Any] = Field(default_factory=dict)


class AiEvaluateRequest(BaseModel):
    """POST /api/v1/ai/evaluate — grade a candidate submission.

    Platform sends ``assessmentId`` + ``candidateId`` (required) and the
    question list with candidate answers (+ expected answers from the stored
    generate payload). Result is persisted to ``candidate_assessment_attempts``.
    """

    model_config = ConfigDict(populate_by_name=True, extra="ignore")

    correlation_id: UUID | None = Field(default=None, alias="correlationId")
    assessment_id: str = Field(..., min_length=1, alias="assessmentId")
    candidate_id: str = Field(..., min_length=1, alias="candidateId")
    submission_id: str | None = Field(
        default=None,
        alias="submissionId",
        description="Optional Platform submission / attempt id",
    )
    assessment_type: AssessmentType = Field(..., alias="assessmentType")
    time_taken: int = Field(
        ...,
        ge=0,
        alias="timeTaken",
        description="Time taken in seconds",
    )
    passing_score: float = Field(
        ...,
        ge=0,
        le=100,
        alias="passingScore",
        description="Passing threshold as a percentage (0–100)",
    )
    questions: list[AssessmentQuestionAnswer] = Field(
        ...,
        min_length=1,
        description="Questions with candidate answers (and expected answers for scoring)",
    )
    company_id: str | None = Field(default=None, alias="companyId")
    language: str = Field(default="en", min_length=2, max_length=10)

    @model_validator(mode="after")
    def _require_answers(self) -> AiEvaluateRequest:
        if not any(q.answer is not None and str(q.answer).strip() != "" for q in self.questions):
            raise ValueError("At least one question must include a candidate answer")
        return self


class AiEvaluateResponse(StubMeta):
    """Normalized evaluate response; attempt is stored when candidate_id is present."""

    correlation_id: UUID | None = None
    assessment_id: str
    candidate_id: str
    submission_id: str | None = None
    assessment_type: AssessmentType
    time_taken: int | None = None
    passing_score: float | None = None
    total_score: float = 0.0
    max_total_score: float = 0.0
    score_percent: float | None = None
    passed: bool | None = None
    auto_scored: bool = False
    persisted: bool = Field(
        default=False,
        description="True when written to candidate_assessment_attempts",
    )
    attempt_id: str | None = None
    feedback_markdown: str | None = None
    item_results: list[dict[str, Any]] = Field(default_factory=list)
    skill_scores: list[SkillScoreItem] = Field(default_factory=list)
    timing: TimingReport | None = None
    rubric_scores: dict[str, Any] = Field(default_factory=dict)


# Re-export coding judge schemas under hub for OpenAPI clarity
class AiCodeJudgeRequest(BaseModel):
    """POST /api/v1/ai/code/judge — same contract as legacy /coding/judge."""

    correlation_id: UUID | None = None
    challenge_id: str | None = None
    language: str = Field(..., examples=["python", "javascript", "java", "go"])
    problem_statement: str = Field(..., min_length=10)
    starter_code: str | None = None
    candidate_code: str = Field(..., min_length=1)
    test_cases: list[dict[str, Any]] = Field(default_factory=list)
    execute_tests: bool = True
    skills: list[str] = Field(default_factory=list)
    rubric: dict[str, Any] = Field(default_factory=dict)


class AiCodeJudgeResponse(StubMeta):
    correlation_id: UUID | None = None
    challenge_id: str | None = None
    total_score: float = 0.0
    max_total_score: float = 100.0
    passed: bool | None = None
    correctness: float | None = None
    code_quality: float | None = None
    efficiency: float | None = None
    feedback_markdown: str | None = None
    failing_tests: list[str] = Field(default_factory=list)
    test_results: list[TestCaseResult] = Field(default_factory=list)
    tests_executed: bool = False
    skill_scores: list[SkillScoreItem] = Field(default_factory=list)
