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

import re
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.shared.ai_generate import generate_json
from app.services.screening.questions import _local_questions, _parse_questions


def _normalize_passing_score(value) -> float:
    """Convert AI-generated passing scores to a valid numeric value.

    Supports values such as:
    - 0.7
    - 70
    - "0.7"
    - "3 out of 5"
    - "3/5"
    """
    default_score = 0.7

    try:
        if isinstance(value, bool) or value is None:
            return default_score

        if isinstance(value, (int, float)):
            score = float(value)
        elif isinstance(value, str):
            value = value.strip()

            # Handle fractions and expressions such as "3 out of 5".
            match = re.search(
                r"^\s*(\d+(?:\.\d+)?)\s*(?:out\s+of|/)\s*"
                r"(\d+(?:\.\d+)?)\s*$",
                value,
                re.IGNORECASE,
            )

            if match:
                numerator = float(match.group(1))
                denominator = float(match.group(2))

                if denominator <= 0:
                    return default_score

                score = numerator / denominator
            else:
                score = float(value)
        else:
            return default_score

        # Track scores use a normalized 0.0–1.0 scale.
        # Convert percentage-style values such as 70 to 0.7.
        if 1 < score <= 100:
            score /= 100

        if not 0 <= score <= 1:
            return default_score

        return score

    except (TypeError, ValueError, OverflowError):
        return default_score


class InterviewTracksService:
    async def generate(
        self,
        payload: InterviewTrackRequest,
    ) -> InterviewTrackResponse:
        system = (
            "Create a progressive interview track. Return valid JSON only "
            "with this structure: "
            '{"levels":[{"level":"beginner",'
            '"badge_name":"Example Badge",'
            '"passing_score":0.7,'
            '"questions":[...]}]}. '
            "passing_score MUST be a numeric value between 0 and 1, "
            "not a string or fraction. For example, use 0.7 instead of "
            '"70%", "3 out of 5", or "3/5". '
            "Each level must contain relevant interview questions."
        )

        user = (
            f"Role: {payload.role_title}\n"
            f"Niche: {payload.niche}\n"
            f"JD: {payload.job_description}\n"
            f"Levels: {payload.levels}\n"
            f"Per level: {payload.questions_per_level}\n"
            f"Persona: {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,
                )

                questions = _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": questions,
                    }
                )

            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") or "intermediate"
            ).strip()

            if not level_name:
                level_name = "intermediate"

            diff_map = {
                "beginner": Difficulty.EASY,
                "intermediate": Difficulty.MEDIUM,
                "advanced": Difficulty.HARD,
            }

            diff = diff_map.get(
                level_name.lower(),
                Difficulty.MEDIUM,
            )

            # Parse AI-generated questions. If none are returned, fall back to local generation.
            questions = _parse_questions(
                raw.get("questions") or [],
                QuestionType.SHORT_ANSWER,
                diff,
            )
            if not questions:
                # Use local question generator as a fallback for this level
                questions = _local_questions(
                    count=payload.questions_per_level,
                    qtype=QuestionType.SHORT_ANSWER,
                    difficulty=diff,
                    topic=f"{payload.role_title} / {raw.get('level', 'level')}",
                )

            passing_score = _normalize_passing_score(
                raw.get("passing_score", 0.7)
            )

            badge_name = raw.get("badge_name")

            if not isinstance(badge_name, str) or not badge_name.strip():
                badge_name = f"{payload.role_title} {level_name.title()}"

            levels.append(
                TrackLevel(
                    level=level_name,
                    badge_name=badge_name,
                    questions=questions,
                    passing_score=passing_score,
                )
            )

        # Protect against an empty or malformed AI response.
        # If the AI response is empty or malformed, fall back to locally generated track.
        if not levels:
            fallback_data = local()
            for raw in fallback_data["levels"]:
                level_name = raw["level"]
                diff = {
                    "beginner": Difficulty.EASY,
                    "intermediate": Difficulty.MEDIUM,
                    "advanced": Difficulty.HARD,
                }.get(level_name.lower(), Difficulty.MEDIUM)
                # Use local questions directly; they are guaranteed to be non‑empty.
                questions = _local_questions(
                    count=payload.questions_per_level,
                    qtype=QuestionType.SHORT_ANSWER,
                    difficulty=diff,
                    topic=f"{payload.role_title} / {level_name}",
                )
                levels.append(
                    TrackLevel(
                        level=level_name,
                        badge_name=raw["badge_name"],
                        questions=questions,
                        passing_score=0.7,
                    )
                )
            stub = True

        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,
        )
