"""Dispatch unified /ai/* assessment calls to existing generators and graders."""

from __future__ import annotations

from typing import Any

from fastapi import HTTPException, status

from app.schemas.ai_hub import (
    AiCodeJudgeRequest,
    AiCodeJudgeResponse,
    AiEvaluateRequest,
    AiEvaluateResponse,
    AiGenerateRequest,
    AiGenerateResponse,
    AssessmentType,
    assessment_kind_from_evaluate,
    assessment_kind_from_generate,
    map_assessment_difficulty,
    map_assessment_question_types,
)
from app.schemas.aptitude import AptitudeGenerateRequest
from app.schemas.assessments import AssessmentGenerateRequest, AssessmentGradeRequest
from app.schemas.case_studies import CaseStudyGenerateRequest
from app.schemas.coding import CodingJudgeRequest
from app.schemas.helpers import ScenarioGenerateRequest
from app.schemas.questions import GeneratedQuestion
from app.services.assessments.aptitude import AptitudeService
from app.services.assessments.assessments import AssessmentsService
from app.services.assessments.case_studies import CaseStudiesService
from app.services.assessments.coding import CodingService
from app.services.assessments.scenarios import ScenariosService
from app.services.screening.job_store import get_job


def _dump_items(items: list[Any]) -> list[dict[str, Any]]:
    out: list[dict[str, Any]] = []
    for item in items or []:
        if hasattr(item, "model_dump"):
            out.append(item.model_dump())
        elif isinstance(item, dict):
            out.append(item)
        else:
            out.append({"value": item})
    return out


def _dedupe_skills(*groups: list[str]) -> list[str]:
    seen: set[str] = set()
    out: list[str] = []
    for group in groups:
        for raw in group or []:
            skill = str(raw).strip()
            if not skill:
                continue
            key = skill.lower()
            if key in seen:
                continue
            seen.add(key)
            out.append(skill)
    return out


def _skills_from_job(sections: dict[str, Any], meta: dict[str, Any]) -> list[str]:
    skills: list[str] = []
    for key in ("preferred_skills", "skills", "required_skills"):
        vals = sections.get(key) if isinstance(sections, dict) else None
        if isinstance(vals, list):
            skills.extend(str(v) for v in vals if v)
    meta_skills = meta.get("skills") if isinstance(meta, dict) else None
    if isinstance(meta_skills, list):
        skills.extend(str(v) for v in meta_skills if v)
    return _dedupe_skills(skills)


def _jd_from_job(
    *,
    markdown: str | None,
    sections: dict[str, Any],
    role_title: str,
) -> str:
    parts: list[str] = []
    if markdown and str(markdown).strip():
        parts.append(str(markdown).strip())
    if isinstance(sections, dict):
        summary = sections.get("summary")
        if summary and str(summary).strip():
            parts.append(str(summary).strip())
        for key, label in (
            ("responsibilities", "Responsibilities"),
            ("requirements", "Requirements"),
            ("nice_to_have", "Nice to have"),
        ):
            vals = sections.get(key) or []
            if isinstance(vals, list) and vals:
                bullets = "\n".join(f"- {v}" for v in vals if v)
                if bullets:
                    parts.append(f"{label}:\n{bullets}")
    jd = "\n\n".join(parts).strip()
    return jd or f"Role: {role_title}"


def resolve_linked_job(job_id: str) -> tuple[str, str, list[str]]:
    """Load role title, JD, and skills from ``ai_jobs`` by job id."""
    row = get_job(job_id)
    if row is None:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail=f"linked_job not found in ai_jobs: {job_id}",
        )
    role = (row.title or row.role_title or "").strip() or "Role"
    sections = row.sections if isinstance(row.sections, dict) else {}
    meta = row.meta if isinstance(row.meta, dict) else {}
    jd = _jd_from_job(markdown=row.markdown, sections=sections, role_title=role)
    if not jd or len(jd.strip()) < 20:
        raise HTTPException(
            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
            detail=(
                f"Job {job_id} has no usable job description in ai_jobs; "
                "cannot generate assessment questions"
            ),
        )
    skills = _skills_from_job(sections, meta)
    return role, jd, skills


class AiHubService:
    def __init__(self) -> None:
        self._assessments = AssessmentsService()
        self._aptitude = AptitudeService()
        self._case_studies = CaseStudiesService()
        self._scenarios = ScenariosService()
        self._coding = CodingService()

    async def generate(self, payload: AiGenerateRequest) -> AiGenerateResponse:
        difficulty = map_assessment_difficulty(payload.difficulty)
        qtypes = map_assessment_question_types(
            payload.question_type, assessment_type=payload.assessment_type
        )
        role, job_description, skills = resolve_linked_job(payload.linked_job)
        atype = payload.assessment_type

        def _base(**extra: Any) -> dict[str, Any]:
            return {
                "assessment_type": atype,
                "question_type": payload.question_type,
                "assessment_name": payload.assessment_name,
                "linked_job": payload.linked_job,
                "duration": payload.duration,
                "difficulty": payload.difficulty,
                "number_of_questions": payload.number_of_questions,
                "passing_score": payload.passing_score,
                "role_title": role,
                "skills": list(skills),
                **extra,
            }

        if atype == AssessmentType.APTITUDE_AND_REASONING:
            raw = await self._aptitude.generate(
                AptitudeGenerateRequest(
                    domain="logical_reasoning",
                    role_title=role,
                    difficulty=difficulty,
                    count=payload.number_of_questions,
                    time_limit_minutes=payload.duration,
                    skills=skills,
                    options={"job_description": job_description},
                )
            )
            return AiGenerateResponse(
                **_base(
                    status=raw.status,
                    stub=raw.stub,
                    message=raw.message,
                    aptitude_id=raw.aptitude_id,
                    assessment_id=raw.aptitude_id,
                    questions=list(raw.questions or []),
                    answer_key=dict(raw.answer_key or {}),
                    skills=list(raw.skills or skills),
                )
            )

        if atype == AssessmentType.ROLE_CASE_PLAY:
            raw = await self._case_studies.generate(
                CaseStudyGenerateRequest(
                    role_title=role,
                    industry=None,
                    job_description=job_description,
                    difficulty=difficulty,
                    time_limit_minutes=payload.duration,
                )
            )
            scenarios: list[GeneratedQuestion] = []
            scenario_set_id: str | None = None
            scen_stub = raw.stub
            scen_msg = raw.message
            if payload.number_of_questions >= 1:
                scen = await self._scenarios.generate(
                    ScenarioGenerateRequest(
                        role_title=role,
                        job_description=job_description,
                        difficulty=difficulty,
                        count=min(payload.number_of_questions, 10),
                    )
                )
                scenarios = list(scen.scenarios or [])
                scenario_set_id = scen.scenario_set_id
                scen_stub = scen.stub
                scen_msg = scen.message

            rubric = dict(raw.rubric or {})
            rubric.setdefault("passing_score", payload.passing_score)
            rubric.setdefault("time_limit_minutes", payload.duration)
            return AiGenerateResponse(
                **_base(
                    status=raw.status,
                    stub=bool(raw.stub and scen_stub),
                    message=f"{raw.message}; {scen_msg}",
                    case_id=raw.case_id,
                    scenario_set_id=scenario_set_id,
                    assessment_id=raw.case_id,
                    title=raw.title or payload.assessment_name,
                    scenario_markdown=raw.scenario_markdown,
                    tasks=list(raw.tasks or []),
                    scenarios=scenarios,
                    questions=scenarios,
                    rubric=rubric,
                )
            )

        # coding_challenge + personality_eval → AssessmentsService
        raw = await self._assessments.generate(
            AssessmentGenerateRequest(
                role_title=role,
                job_description=job_description,
                kind=assessment_kind_from_generate(atype),
                difficulty=difficulty,
                question_types=qtypes,
                count=payload.number_of_questions,
                time_limit_minutes=payload.duration,
                skills=skills,
                domain=(
                    "personality"
                    if atype == AssessmentType.PERSONALITY_EVAL
                    else None
                ),
                options={
                    "assessment_name": payload.assessment_name,
                    "passing_score": payload.passing_score,
                    "assessment_type": atype.value,
                    "linked_job": payload.linked_job,
                },
            )
        )
        rubric = dict(raw.rubric or {})
        rubric.setdefault("passing_score", payload.passing_score)
        rubric.setdefault("time_limit_minutes", payload.duration)
        return AiGenerateResponse(
            **_base(
                status=raw.status,
                stub=raw.stub,
                message=raw.message,
                assessment_id=raw.assessment_id,
                questions=list(raw.questions or []),
                answer_key=dict(raw.answer_key or {}),
                rubric=rubric,
                skills=list(raw.skills or skills),
            )
        )

    async def evaluate(self, payload: AiEvaluateRequest) -> AiEvaluateResponse:
        """Grade questions+answers; always persist under candidate_id."""
        answers: list[dict[str, Any]] = []
        answer_key: dict[str, Any] = {}
        questions_payload: list[dict[str, Any]] = []
        for q in payload.questions:
            answers.append(
                {
                    "question_id": q.question_id,
                    "selected": q.answer,
                    "answer": q.answer,
                    "student_answer": q.answer,
                }
            )
            expected = q.expected_answer
            if expected is not None and str(expected).strip() != "":
                answer_key[q.question_id] = {
                    "answer": expected,
                    "skills": list(q.skills or []),
                    "max_score": float(q.max_score or 1.0),
                }
            questions_payload.append(
                {
                    "id": q.question_id,
                    "stem": q.stem,
                    "answer": expected,
                    "question_type": q.question_type,
                    "metadata": {"skills": list(q.skills or [])},
                    "max_score": float(q.max_score or 1.0),
                }
            )

        if not answer_key:
            raise HTTPException(
                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
                detail=(
                    "Each question needs expectedAnswer (from Platform-held "
                    "generate answer_key) for scoring"
                ),
            )

        rubric = {
            "passing_score": payload.passing_score,
            "assessment_type": payload.assessment_type.value,
        }
        raw = await self._assessments.grade(
            AssessmentGradeRequest(
                correlation_id=payload.correlation_id,
                assessment_id=payload.assessment_id,
                kind=assessment_kind_from_evaluate(payload.assessment_type),
                answers=answers,
                questions=questions_payload,
                answer_key=answer_key,
                time_taken_seconds=payload.time_taken,
                rubric=rubric,
                language=payload.language,
                candidate_id=payload.candidate_id,
                company_id=payload.company_id,
                options={
                    "submission_id": payload.submission_id,
                    "assessment_type": payload.assessment_type.value,
                    "passing_score": payload.passing_score,
                    "time_taken": payload.time_taken,
                    "fail_on_overtime": False,
                },
            )
        )
        max_total = float(raw.max_total_score or 0)
        total = float(raw.total_score or 0)
        score_percent = (
            round((total / max_total) * 100.0, 2) if max_total > 0 else None
        )
        # Re-apply Platform passing_score % if grader used ratio differently
        passed = raw.passed
        if score_percent is not None:
            passed = score_percent >= float(payload.passing_score)

        return AiEvaluateResponse(
            correlation_id=raw.correlation_id,
            status=raw.status,
            stub=raw.stub,
            message=(
                f"{raw.message}; persisted={bool(raw.persisted)}"
                if raw.persisted
                else raw.message
            ),
            assessment_id=payload.assessment_id,
            candidate_id=payload.candidate_id,
            submission_id=payload.submission_id,
            assessment_type=payload.assessment_type,
            time_taken=payload.time_taken,
            passing_score=payload.passing_score,
            total_score=total,
            max_total_score=max_total,
            score_percent=score_percent,
            passed=passed,
            auto_scored=raw.auto_scored,
            persisted=bool(raw.persisted),
            attempt_id=raw.attempt_id,
            feedback_markdown=raw.feedback_markdown,
            item_results=_dump_items(raw.item_results),
            skill_scores=list(raw.skill_scores or []),
            timing=raw.timing,
        )

    # /ai/code/judge route disabled — coding_challenge uses /ai/evaluate.
    async def judge_code(self, payload: AiCodeJudgeRequest) -> AiCodeJudgeResponse:
        raw = await self._coding.judge(
            CodingJudgeRequest(
                correlation_id=payload.correlation_id,
                challenge_id=payload.challenge_id,
                language=payload.language,
                problem_statement=payload.problem_statement,
                starter_code=payload.starter_code,
                candidate_code=payload.candidate_code,
                test_cases=payload.test_cases,
                execute_tests=payload.execute_tests,
                skills=payload.skills,
                rubric=payload.rubric,
            )
        )
        return AiCodeJudgeResponse(
            correlation_id=raw.correlation_id,
            status=raw.status,
            stub=raw.stub,
            message=raw.message,
            challenge_id=raw.challenge_id,
            total_score=raw.total_score,
            max_total_score=raw.max_total_score,
            passed=raw.passed,
            correctness=raw.correctness,
            code_quality=raw.code_quality,
            efficiency=raw.efficiency,
            feedback_markdown=raw.feedback_markdown,
            failing_tests=list(raw.failing_tests or []),
            test_results=list(raw.test_results or []),
            tests_executed=raw.tests_executed,
            skill_scores=list(raw.skill_scores or []),
        )
