"""tutor/adaptive.py — LearnerState with Bayesian Knowledge Tracing."""
from __future__ import annotations
import random
from collections import defaultdict
from typing import List, Dict, Any

BKT_DEFAULTS = {"p_init": 0.30, "p_learn": 0.10, "p_guess": 0.20, "p_slip": 0.10}

AGE_CONFIG = {
    5: {"diff_min": 1, "diff_max": 3,  "target_acc": 0.70},
    6: {"diff_min": 1, "diff_max": 4,  "target_acc": 0.72},
    7: {"diff_min": 2, "diff_max": 6,  "target_acc": 0.75},
    8: {"diff_min": 3, "diff_max": 7,  "target_acc": 0.75},
    9: {"diff_min": 4, "diff_max": 9,  "target_acc": 0.78},
}

DYSC_STREAK_THRESHOLD = 5
DYSC_MIN_ATTEMPTS     = 8


class SkillBKT:
    def __init__(self, skill: str, params: Dict | None = None):
        self.skill  = skill
        p           = params or BKT_DEFAULTS
        self.p_init  = p["p_init"]
        self.p_learn = p["p_learn"]
        self.p_guess = p["p_guess"]
        self.p_slip  = p["p_slip"]
        self.p_know  = self.p_init
        self.attempts     = 0
        self.correct      = 0
        self.streak_wrong = 0

    def update(self, is_correct: bool):
        self.attempts += 1
        if is_correct:
            self.correct += 1
            self.streak_wrong = 0
        else:
            self.streak_wrong += 1
        p_ok  = (1 - self.p_slip) if is_correct else self.p_slip
        p_nok = self.p_guess      if is_correct else (1 - self.p_guess)
        num   = p_ok * self.p_know
        den   = num + p_nok * (1 - self.p_know)
        p_kno = num / (den + 1e-9)
        self.p_know = p_kno + (1 - p_kno) * self.p_learn

    def mastery(self) -> float:
        return self.p_know

    def to_dict(self):
        return {k: getattr(self, k) for k in
                ("skill","p_know","p_init","p_learn","p_guess","p_slip",
                 "attempts","correct","streak_wrong")}

    @classmethod
    def from_dict(cls, d):
        obj = cls(d["skill"], {k: d[k] for k in ("p_init","p_learn","p_guess","p_slip")})
        obj.p_know       = d["p_know"]
        obj.attempts     = d["attempts"]
        obj.correct      = d["correct"]
        obj.streak_wrong = d.get("streak_wrong", 0)
        return obj


class LearnerState:
    def __init__(self, learner_id: str, lang: str = "en", age: int = 7):
        self.learner_id = learner_id
        self.lang       = lang
        self.age        = max(5, min(9, age))
        self.bkt: Dict[str, SkillBKT] = {}
        self._history: List[Dict] = []

    @property
    def age_config(self):
        return AGE_CONFIG.get(self.age, AGE_CONFIG[7])

    def _bkt(self, skill: str) -> SkillBKT:
        if skill not in self.bkt:
            self.bkt[skill] = SkillBKT(skill)
        return self.bkt[skill]

    def record_response(self, item: Dict, is_correct: bool):
        self._bkt(item.get("skill", "unknown")).update(is_correct)
        self._history.append({"item_id": item.get("id"), "correct": is_correct})

    def mastery(self, skill: str) -> float:
        return self._bkt(skill).mastery()

    def select_next_item(self, all_items: List[Dict], use_bkt: bool = True) -> Dict:
        cfg = self.age_config
        by_skill: Dict[str, List[Dict]] = defaultdict(list)
        for item in all_items:
            d = item.get("difficulty", 5)
            if cfg["diff_min"] <= d <= cfg["diff_max"]:
                by_skill[item.get("skill", "unknown")].append(item)
        if not by_skill:
            return random.choice(all_items)
        skills = sorted(by_skill.keys(), key=lambda s: self.mastery(s)) if use_bkt \
                 else list(by_skill.keys())
        for skill in skills:
            cands = by_skill[skill]
            if cands:
                m = self.mastery(skill)
                t = cfg["diff_min"] + m * (cfg["diff_max"] - cfg["diff_min"])
                cands.sort(key=lambda i: abs(i.get("difficulty", 5) - t))
                return cands[0]
        return random.choice(all_items)

    def dyscalculia_warning(self) -> List[str]:
        return [s for s, b in self.bkt.items()
                if b.attempts >= DYSC_MIN_ATTEMPTS and b.streak_wrong >= DYSC_STREAK_THRESHOLD]

    def to_dict(self):
        return {
            "learner_id": self.learner_id, "lang": self.lang, "age": self.age,
            "bkt": {k: v.to_dict() for k, v in self.bkt.items()},
            "history_len": len(self._history),
        }

    @classmethod
    def from_dict(cls, d):
        obj = cls(d["learner_id"], d.get("lang","en"), d.get("age",7))
        for skill, bd in d.get("bkt", {}).items():
            obj.bkt[skill] = SkillBKT.from_dict(bd)
        return obj