"""Timed aptitude / logical reasoning tests."""

from uuid import uuid4

from app.schemas.aptitude import (
    AptitudeGenerateRequest,
    AptitudeGenerateResponse,
    AptitudeGradeRequest,
    AptitudeGradeResponse,
)
from app.schemas.common import JobStatus
from app.schemas.questions import QuestionType
from app.services.ai_generate import generate_json
from app.services.questions import _local_questions, _parse_questions


class AptitudeService:
    async def generate(self, payload: AptitudeGenerateRequest) -> AptitudeGenerateResponse:
        system = (
            "Generate timed aptitude / reasoning questions. Return JSON: {\"questions\":[...]}"
        )
        user = (
            f"Domain: {payload.domain}\nRole: {payload.role_title}\n"
            f"Difficulty: {payload.difficulty.value}\nCount: {payload.count}\n"
            f"Time limit: {payload.time_limit_minutes}"
        )

        def local() -> dict:
            return {
                "questions": _local_questions(
                    count=payload.count,
                    qtype=QuestionType.MCQ,
                    difficulty=payload.difficulty,
                    topic=payload.domain,
                )
            }

        data, stub, provider = await generate_json(
            system=system, user=user, local_factory=local
        )
        questions = _parse_questions(
            data.get("questions", []), QuestionType.MCQ, payload.difficulty
        )
        return AptitudeGenerateResponse(
            correlation_id=payload.correlation_id,
            aptitude_id=str(uuid4()),
            domain=payload.domain,
            time_limit_minutes=payload.time_limit_minutes,
            status=JobStatus.SUCCEEDED,
            stub=stub,
            message=f"Aptitude generated via {provider}",
            questions=questions,
        )

    async def grade(self, payload: AptitudeGradeRequest) -> AptitudeGradeResponse:
        system = (
            "Grade aptitude answers. Return JSON: "
            "{\"total_score\",\"max_total_score\",\"passed\",\"percentile_estimate\","
            "\"feedback_markdown\",\"item_results\":[]}"
        )
        user = f"id={payload.aptitude_id}\nanswers={payload.answers}\ntime={payload.time_taken_seconds}"

        def local() -> dict:
            n = len(payload.answers)
            max_total = float(n)
            total = round(max_total * 0.7, 2)
            return {
                "total_score": total,
                "max_total_score": max_total,
                "passed": total >= max_total * 0.6,
                "percentile_estimate": 65.0,
                "feedback_markdown": "Good logical consistency. Practice timed sets.",
                "item_results": [{"index": i, "score": 0.7} for i in range(n)],
            }

        data, stub, provider = await generate_json(
            system=system, user=user, local_factory=local
        )
        return AptitudeGradeResponse(
            correlation_id=payload.correlation_id,
            aptitude_id=payload.aptitude_id,
            status=JobStatus.SUCCEEDED,
            stub=stub,
            message=f"Aptitude graded via {provider}",
            total_score=float(data.get("total_score") or 0),
            max_total_score=float(data.get("max_total_score") or 0),
            passed=data.get("passed"),
            percentile_estimate=data.get("percentile_estimate"),
            feedback_markdown=data.get("feedback_markdown"),
            item_results=list(data.get("item_results") or []),
        )