"""Level-based interview track generation."""

from uuid import uuid4

from app.schemas.common import JobStatus
from app.schemas.interview_tracks import (
    InterviewTrackRequest,
    InterviewTrackResponse,
    TrackLevel,
)
from app.schemas.questions import Difficulty, QuestionType
from app.services.ai_generate import generate_json
from app.services.questions import _local_questions, _parse_questions


class InterviewTracksService:
    async def generate(self, payload: InterviewTrackRequest) -> InterviewTrackResponse:
        system = (
            "Create a progressive interview track. Return JSON: "
            "{\"levels\":[{\"level\",\"badge_name\",\"passing_score\",\"questions\":[...]}]}"
        )
        user = (
            f"Role: {payload.role_title}\nNiche: {payload.niche}\n"
            f"JD: {payload.job_description}\nLevels: {payload.levels}\n"
            f"Per level: {payload.questions_per_level}\nPersona: {payload.persona.value}"
        )

        def local() -> dict:
            diff_map = {
                "beginner": Difficulty.EASY,
                "intermediate": Difficulty.MEDIUM,
                "advanced": Difficulty.HARD,
            }
            levels = []
            for level in payload.levels:
                diff = diff_map.get(level.lower(), Difficulty.MEDIUM)
                qs = _local_questions(
                    count=payload.questions_per_level,
                    qtype=QuestionType.SHORT_ANSWER,
                    difficulty=diff,
                    topic=f"{payload.role_title} / {level}",
                )
                levels.append(
                    {
                        "level": level,
                        "badge_name": f"{payload.role_title} {level.title()}",
                        "passing_score": 0.7,
                        "questions": qs,
                    }
                )
            return {"levels": levels}

        data, stub, provider = await generate_json(
            system=system, user=user, local_factory=local
        )
        levels: list[TrackLevel] = []
        for raw in data.get("levels") or []:
            if not isinstance(raw, dict):
                continue
            level_name = str(raw.get("level", "intermediate"))
            diff = {
                "beginner": Difficulty.EASY,
                "intermediate": Difficulty.MEDIUM,
                "advanced": Difficulty.HARD,
            }.get(level_name.lower(), Difficulty.MEDIUM)
            questions = _parse_questions(
                raw.get("questions") or [], QuestionType.SHORT_ANSWER, diff
            )
            levels.append(
                TrackLevel(
                    level=level_name,
                    badge_name=raw.get("badge_name"),
                    questions=questions,
                    passing_score=raw.get("passing_score", 0.7),
                )
            )
        return InterviewTrackResponse(
            correlation_id=payload.correlation_id,
            track_id=str(uuid4()),
            role_title=payload.role_title,
            status=JobStatus.SUCCEEDED,
            stub=stub,
            message=f"Interview track via {provider}",
            levels=levels,
        )