"""Role-scenario generate / grade (assessment-family).

Public route: ``POST /api/v1/ai/generate|evaluate`` with ``kind=scenario``.
Moved from ``shared.helpers`` for package consistency with aptitude/puzzles/cases.
"""

from __future__ import annotations

from typing import Any
from uuid import uuid4

from app.schemas.common import JobStatus
from app.schemas.helpers import (
    ScenarioGenerateRequest,
    ScenarioGenerateResponse,
    ScenarioGradeRequest,
    ScenarioGradeResponse,
)
from app.schemas.questions import QuestionType
from app.services.screening.questions import _local_questions, _parse_questions
from app.services.shared.ai_generate import generate_json


class ScenariosService:
    async def generate(
        self, payload: ScenarioGenerateRequest
    ) -> ScenarioGenerateResponse:
        system = (
            "Generate role-based situational scenario questions for hiring. "
            "Return only valid JSON: "
            '{"scenarios":[{"id","question_type","stem","answer","explanation",'
            '"options":[],"metadata":{}}]}\n'
            "Rules:\n"
            "- Provide exactly the requested count of scenarios.\n"
            "- Prefer long_answer / open-ended situational prompts.\n"
            "- Ground EVERY scenario in the provided job description "
            "(responsibilities, tools, stakeholders).\n"
            "- Match the requested difficulty.\n"
        )
        jd = (payload.job_description or "").strip()
        user = (
            f"Role: {payload.role_title}\n"
            f"Difficulty: {payload.difficulty.value}\nCount: {payload.count}\n"
            f"Language: {payload.language}\n"
            f"Job description (REQUIRED — derive scenarios from this):\n{jd}"
        )

        def local() -> dict[str, Any]:
            return {
                "scenarios": _local_questions(
                    count=payload.count,
                    qtype=QuestionType.LONG_ANSWER,
                    difficulty=payload.difficulty,
                    topic=f"scenario / {payload.role_title} | {jd[:160]}",
                )
            }

        data, stub, provider = await generate_json(
            system=system, user=user, local_factory=local
        )
        if not isinstance(data, dict):
            data = local()
            stub, provider = True, "local"

        scenarios = _parse_questions(
            data.get("scenarios", []), QuestionType.LONG_ANSWER, payload.difficulty
        )
        if not scenarios:
            scenarios = _parse_questions(
                local()["scenarios"], QuestionType.LONG_ANSWER, payload.difficulty
            )
            stub, provider = True, "local"

        return ScenarioGenerateResponse(
            correlation_id=payload.correlation_id,
            scenario_set_id=str(uuid4()),
            status=JobStatus.SUCCEEDED,
            stub=stub,
            message=f"Scenarios via {provider}",
            scenarios=scenarios,
        )

    async def grade(self, payload: ScenarioGradeRequest) -> ScenarioGradeResponse:
        system = (
            "Grade scenario answers. Return only valid JSON: "
            '{"total_score":0,"max_total_score":100,"passed":false,'
            '"feedback_markdown":""}\n'
            "Rules:\n"
            "- Score on structure, judgment, trade-offs, and role fit.\n"
            "- max_total_score defaults to 100; passed if total_score >= 70.\n"
            "- feedback_markdown: concise recruiter-facing notes.\n"
        )
        user = (
            f"Role: {payload.role_title}\n"
            f"Scenario set: {payload.scenario_set_id}\n"
            f"Answers: {payload.answers}\n"
            f"Language: {payload.language}"
        )

        def local() -> dict[str, Any]:
            n = len(payload.answers)
            score = min(95.0, 50.0 + 10.0 * n)
            return {
                "total_score": score,
                "max_total_score": 100.0,
                "passed": score >= 70,
                "feedback_markdown": (
                    "Scenarios show structured thinking; add trade-off analysis."
                ),
            }

        data, stub, provider = await generate_json(
            system=system, user=user, local_factory=local
        )
        if not isinstance(data, dict):
            data = local()
            stub, provider = True, "local"

        total = float(data.get("total_score") or 0)
        max_total = float(data.get("max_total_score") or 100)
        passed = data.get("passed")
        if passed is None:
            passed = total >= 70

        return ScenarioGradeResponse(
            correlation_id=payload.correlation_id,
            status=JobStatus.SUCCEEDED,
            stub=stub,
            message=f"Scenario graded via {provider}",
            total_score=total,
            max_total_score=max_total,
            passed=bool(passed),
            feedback_markdown=data.get("feedback_markdown"),
        )
