"""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.schemas.scoring import SkillScoreItem, TimingReport
from app.services.assessments.grading import (
    apply_timing_to_result,
    auto_grade_answers,
    evaluate_timing,
    export_answer_key,
    feedback_from_items,
    normalize_answer_key,
    resolve_time_limit,
    resolve_time_taken,
    tag_questions_with_skills,
)
from app.services.shared.ai_generate import generate_json
from app.services.screening.questions import _local_questions, _parse_questions


class AptitudeService:
    async def generate(self, payload: AptitudeGenerateRequest) -> AptitudeGenerateResponse:
        skills = list(payload.skills) or [payload.domain]
        jd = str(payload.options.get("job_description") or "").strip()
        system = (
            "Generate timed aptitude / reasoning MCQs with one correct answer. "
            "Ground every question in the provided job description and role "
            "(situations, tools, and skills from the JD). "
            "Return JSON: "
            '{"questions":[{"id","stem","answer","explanation",'
            '"options":[{"key","text","is_correct"}],"metadata":{"skills":[]}}]}'
        )
        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}\nSkills: {skills}\n"
            f"Language: {payload.language}\n"
            f"Job description (REQUIRED — derive questions from this):\n{jd}"
        )
        topic = (skills[0] if skills else None) or payload.role_title or payload.domain

        def local() -> dict:
            return {
                "questions": _local_questions(
                    count=payload.count,
                    qtype=QuestionType.MCQ,
                    difficulty=payload.difficulty,
                    topic=f"{topic} | {jd[:160]}",
                )
            }

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

    async def grade(self, payload: AptitudeGradeRequest) -> AptitudeGradeResponse:
        answer_key = normalize_answer_key(
            answer_key=payload.answer_key or payload.options.get("answer_key"),
            questions=payload.questions or payload.options.get("questions"),
        )
        has_key = bool(answer_key) and any(
            (row.get("answer") is not None and str(row.get("answer")).strip() != "")
            for row in answer_key.values()
        )
        time_limit = resolve_time_limit(
            payload.time_limit_minutes,
            payload.options,
            questions=payload.questions,
            answer_key=answer_key,
            default=30,
        )
        timing = evaluate_timing(
            time_limit_minutes=time_limit,
            time_taken_seconds=resolve_time_taken(
                payload.time_taken_seconds, payload.options
            ),
            overtime_fail=bool(payload.options.get("fail_on_overtime", True)),
            overtime_penalty_ratio=float(
                payload.options.get("overtime_penalty_ratio") or 0.0
            ),
        )
        passing_ratio = float(payload.options.get("passing_ratio") or 0.6)

        if has_key:
            items, total, max_total, skill_scores, passed = auto_grade_answers(
                answers=payload.answers,
                answer_key=answer_key,
                default_skill="logical_reasoning",
                passing_ratio=passing_ratio,
            )
            total, passed, timing = apply_timing_to_result(
                total=total,
                max_total=max_total,
                passed=passed,
                timing=timing,
                fail_on_overtime=bool(payload.options.get("fail_on_overtime", True)),
            )
            ratio = (total / max_total) if max_total else 0.0
            percentile = round(min(99.0, max(1.0, ratio * 100.0)), 1)
            return AptitudeGradeResponse(
                correlation_id=payload.correlation_id,
                aptitude_id=payload.aptitude_id,
                status=JobStatus.SUCCEEDED,
                stub=False,
                message="Aptitude auto-scored from answer key",
                total_score=total,
                max_total_score=max_total,
                passed=passed,
                auto_scored=True,
                percentile_estimate=percentile,
                feedback_markdown=feedback_from_items(
                    items=items,
                    total=total,
                    max_total=max_total,
                    timing=timing,
                    label="Aptitude",
                ),
                item_results=[i.as_dict() for i in items],
                skill_scores=[SkillScoreItem(**s.as_dict()) for s in skill_scores],
                timing=TimingReport(**timing.as_dict()),
            )

        system = (
            "Grade aptitude answers. Return JSON: "
            '{"total_score","max_total_score","passed","percentile_estimate",'
            '"feedback_markdown","item_results":[],"skill_scores":[]}'
        )
        user = (
            f"id={payload.aptitude_id}\nanswers={payload.answers}\n"
            f"time={payload.time_taken_seconds}\ntime_limit={time_limit}"
        )

        def local() -> dict:
            items, total, max_total, skill_scores, passed = auto_grade_answers(
                answers=payload.answers,
                answer_key=None,
                default_skill="logical_reasoning",
                passing_ratio=passing_ratio,
            )
            total, passed, _ = apply_timing_to_result(
                total=total, max_total=max_total, passed=passed, timing=timing
            )
            ratio = (total / max_total) if max_total else 0.0
            return {
                "total_score": total,
                "max_total_score": max_total,
                "passed": passed,
                "percentile_estimate": round(min(99.0, max(1.0, ratio * 100.0)), 1),
                "feedback_markdown": feedback_from_items(
                    items=items,
                    total=total,
                    max_total=max_total,
                    timing=timing,
                    label="Aptitude",
                ),
                "item_results": [i.as_dict() for i in items],
                "skill_scores": [s.as_dict() for s in skill_scores],
            }

        data, stub, provider = await generate_json(
            system=system, user=user, local_factory=local
        )
        skill_raw = list(data.get("skill_scores") or [])
        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"),
            auto_scored=False,
            percentile_estimate=data.get("percentile_estimate"),
            feedback_markdown=data.get("feedback_markdown"),
            item_results=list(data.get("item_results") or []),
            skill_scores=[
                SkillScoreItem(**s) if isinstance(s, dict) else s for s in skill_raw
            ],
            timing=TimingReport(**timing.as_dict()),
        )
