"""Assessment generate / grade — technical, aptitude, domain-specific."""

import logging
from typing import Any
from uuid import uuid4

from app.schemas.assessments import (
    AssessmentGenerateRequest,
    AssessmentGenerateResponse,
    AssessmentGradeRequest,
    AssessmentGradeResponse,
    AssessmentKind,
)
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,
    is_kind_label,
    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

_log = logging.getLogger(__name__)


def _persist_grade_for_performance(
    payload: AssessmentGradeRequest,
    response: AssessmentGradeResponse,
) -> str | None:
    """Best-effort write into Candidate Performance store when candidate_id set."""
    candidate_id = (payload.candidate_id or "").strip() or None
    if not candidate_id:
        opts = payload.options or {}
        raw = opts.get("candidate_id")
        if isinstance(raw, str) and raw.strip():
            candidate_id = raw.strip()
    if not candidate_id:
        return None
    company_id = (payload.company_id or "").strip() or None
    if not company_id:
        raw_co = (payload.options or {}).get("company_id")
        if isinstance(raw_co, str) and raw_co.strip():
            company_id = raw_co.strip()
    attempt_number = None
    raw_attempt = (payload.options or {}).get("attempt_number")
    if isinstance(raw_attempt, int) and raw_attempt >= 1:
        attempt_number = raw_attempt
    role_title = None
    if isinstance(payload.rubric.get("role_title"), str):
        role_title = payload.rubric.get("role_title")
    skill_scores: list[dict[str, Any]] = []
    for item in response.skill_scores or []:
        if hasattr(item, "model_dump"):
            skill_scores.append(item.model_dump())
        elif isinstance(item, dict):
            skill_scores.append(item)
    meta: dict[str, Any] = {"auto_scored": response.auto_scored}
    for key in ("submission_id", "assessment_type", "passing_score", "time_taken"):
        if key in (payload.options or {}) and payload.options.get(key) is not None:
            meta[key] = payload.options.get(key)
    try:
        from app.services.talent.performance import CandidatePerformanceService

        return CandidatePerformanceService().record_from_assessment_grade(
            candidate_id=candidate_id,
            company_id=company_id,
            assessment_id=payload.assessment_id,
            kind=payload.kind.value if payload.kind else None,
            role_title=role_title,
            total_score=float(response.total_score or 0),
            max_total_score=float(response.max_total_score or 0),
            passed=response.passed,
            skill_scores=skill_scores,
            feedback_markdown=response.feedback_markdown,
            attempt_number=attempt_number,
            meta=meta,
        )
    except Exception:  # noqa: BLE001
        _log.exception(
            "assessment performance persist failed assessment_id=%s",
            payload.assessment_id,
        )
        return None


_DEFAULT_TIME = {
    AssessmentKind.MCQ: 30,
    AssessmentKind.APTITUDE: 30,
    AssessmentKind.PUZZLE: 20,
    AssessmentKind.CODING: 60,
    AssessmentKind.TECHNICAL: 45,
    AssessmentKind.DOMAIN: 40,
    AssessmentKind.CASE_STUDY: 45,
    AssessmentKind.SCENARIO: 30,
    AssessmentKind.ESSAY: 40,
}


class AssessmentsService:
    async def generate(
        self, payload: AssessmentGenerateRequest
    ) -> AssessmentGenerateResponse:
        skills = [s for s in list(payload.skills) if s and not is_kind_label(s)]
        if payload.domain and payload.domain not in skills and not is_kind_label(
            payload.domain
        ):
            skills = skills or [payload.domain]
        if not skills and payload.role_title and not is_kind_label(payload.role_title):
            skills = [payload.role_title]
        time_limit = payload.time_limit_minutes or _DEFAULT_TIME.get(payload.kind, 30)

        jd = (payload.job_description or "").strip()
        system = (
            "Generate an assessment with answer keys for auto-scoring where possible. "
            "Every question MUST be grounded in the job description: test skills, "
            "tools, responsibilities, and domain knowledge from the JD. "
            "Return JSON: "
            '{"questions":[{"id","question_type","stem","answer","explanation",'
            '"options":[{"key","text","is_correct"}],"metadata":{"skills":[]}}],'
            '"rubric":{"passing_score":0.7,"criteria":[]}}'
        )
        user = (
            f"Role: {payload.role_title}\nKind: {payload.kind.value}\n"
            f"Domain: {payload.domain}\n"
            f"Difficulty: {payload.difficulty.value}\n"
            f"Types: {[t.value for t in payload.question_types]}\n"
            f"Count: {payload.count}\nSkills: {skills}\n"
            f"Time limit minutes: {time_limit}\nLanguage: {payload.language}\n"
            f"Job description (REQUIRED — derive all questions from this):\n{jd}"
        )
        primary = (
            payload.question_types[0] if payload.question_types else QuestionType.MCQ
        )
        if payload.kind == AssessmentKind.CODING:
            primary = QuestionType.CODING
        topic = (
            f"{payload.kind.value} / {payload.domain or payload.role_title} / "
            f"{(skills[0] if skills else '')} | {jd[:160]}"
        )

        def local() -> dict:
            return {
                "questions": _local_questions(
                    count=payload.count,
                    qtype=primary,
                    difficulty=payload.difficulty,
                    topic=topic,
                ),
                "rubric": {
                    "passing_score": 0.7,
                    "time_limit_minutes": time_limit,
                    "kind": payload.kind.value,
                    "skills": skills,
                    "domain": payload.domain,
                },
            }

        data, stub, provider = await generate_json(
            system=system, user=user, local_factory=local
        )
        questions = _parse_questions(
            data.get("questions", []), primary, payload.difficulty
        )
        if not questions:
            questions = _parse_questions(
                local()["questions"], primary, payload.difficulty
            )
            stub, provider = True, "local"

        questions = tag_questions_with_skills(
            questions, skills, domain=payload.domain
        )
        # Stamp time limit onto each question so evaluate can recover it without
        # requiring the client to resend top-level time_limit_minutes.
        stamped: list[Any] = []
        for q in questions:
            if hasattr(q, "model_copy"):
                meta = dict(getattr(q, "metadata", None) or {})
                meta.setdefault("time_limit_minutes", time_limit)
                stamped.append(q.model_copy(update={"metadata": meta}))
            else:
                stamped.append(q)
        questions = stamped
        rubric = dict(data.get("rubric") or {})
        rubric.setdefault("passing_score", 0.7)
        rubric.setdefault("time_limit_minutes", time_limit)
        rubric.setdefault("kind", payload.kind.value)
        rubric.setdefault("skills", skills)
        if payload.domain:
            rubric.setdefault("domain", payload.domain)

        answer_key = export_answer_key(questions)
        answer_key["_meta"] = {
            "time_limit_minutes": time_limit,
            "skills": skills,
        }

        return AssessmentGenerateResponse(
            correlation_id=payload.correlation_id,
            assessment_id=str(uuid4()),
            kind=payload.kind,
            role_title=payload.role_title,
            time_limit_minutes=time_limit,
            skills=skills,
            status=JobStatus.SUCCEEDED,
            stub=stub,
            message=f"Assessment generated via {provider}",
            questions=questions,
            answer_key=answer_key,
            rubric=rubric,
        )

    async def grade(self, payload: AssessmentGradeRequest) -> AssessmentGradeResponse:
        raw_key = payload.answer_key or payload.options.get("answer_key")
        questions = payload.questions or payload.options.get("questions") or []
        answer_key = normalize_answer_key(
            answer_key=raw_key,
            questions=questions,
        )
        # Recover assessment-level meta stamped at generate time
        meta: dict[str, Any] = {}
        if isinstance(raw_key, dict) and isinstance(raw_key.get("_meta"), dict):
            meta = dict(raw_key["_meta"])
        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()
        )
        default_minutes = _DEFAULT_TIME.get(payload.kind, 30)
        time_limit = resolve_time_limit(
            payload.time_limit_minutes,
            payload.options,
            payload.rubric,
            questions=questions,
            answer_key=answer_key,
            default=(
                int(meta["time_limit_minutes"])
                if meta.get("time_limit_minutes") is not None
                else default_minutes
            ),
        )
        time_taken = resolve_time_taken(payload.time_taken_seconds, payload.options)
        timing = evaluate_timing(
            time_limit_minutes=time_limit,
            time_taken_seconds=time_taken,
            overtime_fail=bool(payload.options.get("fail_on_overtime", True)),
            overtime_penalty_ratio=float(
                payload.options.get("overtime_penalty_ratio") or 0.0
            ),
        )
        raw_pass = payload.rubric.get("passing_score")
        if raw_pass is None:
            raw_pass = payload.options.get("passing_ratio")
        if raw_pass is None:
            raw_pass = payload.options.get("passing_score")
        if raw_pass is None:
            raw_pass = 70
        # Accept 0–1 ratio or 0–100 percentage from Platform
        passing_ratio = float(raw_pass)
        if passing_ratio > 1.0:
            passing_ratio = passing_ratio / 100.0
        passing_ratio = max(0.0, min(1.0, passing_ratio))
        # Prefer real competency skills from rubric / generate meta — never kind labels.
        assessment_skills: list[str] = []
        for source in (
            payload.rubric.get("skills") if isinstance(payload.rubric, dict) else None,
            meta.get("skills"),
            payload.options.get("skills"),
        ):
            if isinstance(source, list) and source:
                assessment_skills = [str(s) for s in source if s and not is_kind_label(str(s))]
                if assessment_skills:
                    break
        default_skill = assessment_skills[0] if assessment_skills else None

        # MCQ / aptitude / puzzle / technical / domain → prefer auto-score
        auto_kinds = {
            AssessmentKind.MCQ,
            AssessmentKind.APTITUDE,
            AssessmentKind.PUZZLE,
            AssessmentKind.TECHNICAL,
            AssessmentKind.DOMAIN,
            AssessmentKind.CUSTOM,
            AssessmentKind.CODING,
            AssessmentKind.CASE_STUDY,
            AssessmentKind.SCENARIO,
        }
        if has_key and payload.kind in auto_kinds:
            items, total, max_total, skill_scores, passed = auto_grade_answers(
                answers=payload.answers,
                answer_key=answer_key,
                default_skill=default_skill,
                assessment_skills=assessment_skills,
                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)),
            )
            response = AssessmentGradeResponse(
                correlation_id=payload.correlation_id,
                assessment_id=payload.assessment_id,
                status=JobStatus.SUCCEEDED,
                stub=False,
                message="Assessment auto-scored from answer key",
                total_score=total,
                max_total_score=max_total,
                passed=passed,
                auto_scored=True,
                feedback_markdown=feedback_from_items(
                    items=items,
                    total=total,
                    max_total=max_total,
                    timing=timing,
                    label=f"{payload.kind.value} assessment",
                ),
                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()),
            )
            attempt_id = _persist_grade_for_performance(payload, response)
            response.attempt_id = attempt_id
            response.persisted = bool(attempt_id)
            return response

        system = (
            "Grade assessment submissions. Return JSON: "
            '{"total_score","max_total_score","passed","feedback_markdown",'
            '"item_results":[],"skill_scores":[]}'
        )
        user = (
            f"assessment_id={payload.assessment_id}\nkind={payload.kind.value}\n"
            f"rubric={payload.rubric}\nanswers={payload.answers}\n"
            f"answer_key={answer_key or None}\ntime_limit={time_limit}\n"
            f"time_taken={payload.time_taken_seconds}"
        )

        def local() -> dict:
            items, total, max_total, skill_scores, passed = auto_grade_answers(
                answers=payload.answers,
                answer_key=answer_key or None,
                default_skill=default_skill,
                assessment_skills=assessment_skills,
                passing_ratio=passing_ratio,
            )
            total, passed, _ = apply_timing_to_result(
                total=total, max_total=max_total, passed=passed, timing=timing
            )
            return {
                "total_score": total,
                "max_total_score": max_total,
                "passed": passed,
                "feedback_markdown": feedback_from_items(
                    items=items,
                    total=total,
                    max_total=max_total,
                    timing=timing,
                    label=f"{payload.kind.value} assessment",
                ),
                "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 [])
        response = AssessmentGradeResponse(
            correlation_id=payload.correlation_id,
            assessment_id=payload.assessment_id,
            status=JobStatus.SUCCEEDED,
            stub=stub,
            message=f"Assessment 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=bool(has_key),
            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()),
        )
        attempt_id = _persist_grade_for_performance(payload, response)
        response.attempt_id = attempt_id
        response.persisted = bool(attempt_id)
        return response
