from __future__ import annotations

from dataclasses import dataclass, field
from typing import Dict, Hashable, Iterable, List, Mapping, MutableMapping, Sequence, Tuple

import numpy as np
import pandas as pd

from .config import SuiteConfig


@dataclass
class SemesterStat:
    semester: float
    count: int
    failures: int
    grade_sum: float

    @property
    def failure_rate(self) -> float:
        return self.failures / self.count if self.count else np.nan

    @property
    def mean_grade(self) -> float:
        return self.grade_sum / self.count if self.count else np.nan


@dataclass
class EntityState:
    count: int = 0
    failures: int = 0
    grade_sum: float = 0.0
    grades: List[float] = field(default_factory=list)
    semester_stats: List[SemesterStat] = field(default_factory=list)
    last_semester: float | None = None
    last_failure_semester: float | None = None

    def mean_grade(self) -> float:
        return self.grade_sum / self.count if self.count else np.nan

    def failure_rate(self) -> float:
        return self.failures / self.count if self.count else np.nan

    def recent(self, n_semesters: int) -> Tuple[int, int, float, int]:
        stats = self.semester_stats[-n_semesters:]
        count = sum(s.count for s in stats)
        failures = sum(s.failures for s in stats)
        grade_sum = sum(s.grade_sum for s in stats)
        return count, failures, grade_sum, len(stats)

    def semester_failure_rates(self) -> np.ndarray:
        if not self.semester_stats:
            return np.array([], dtype=float)
        return np.asarray([s.failure_rate for s in self.semester_stats], dtype=float)

    def trailing_failure_semesters(self) -> int:
        run = 0
        for s in reversed(self.semester_stats):
            if s.failures > 0:
                run += 1
            else:
                break
        return run

    def update(self, semester: float, grades: Sequence[float], event: float) -> None:
        arr = np.asarray(grades, dtype=float)
        arr = arr[np.isfinite(arr)]
        if arr.size == 0:
            return
        failures = int((arr < event).sum())
        stat = SemesterStat(
            semester=float(semester),
            count=int(arr.size),
            failures=failures,
            grade_sum=float(arr.sum()),
        )
        self.count += stat.count
        self.failures += stat.failures
        self.grade_sum += stat.grade_sum
        self.grades.extend(arr.tolist())
        self.semester_stats.append(stat)
        self.last_semester = float(semester)
        if failures > 0:
            self.last_failure_semester = float(semester)


@dataclass
class GlobalState:
    count: int = 0
    failures: int = 0

    def rate(self, default: float) -> float:
        return self.failures / self.count if self.count else default

    def update(self, grades: Sequence[float], event: float) -> None:
        arr = np.asarray(grades, dtype=float)
        arr = arr[np.isfinite(arr)]
        self.count += int(arr.size)
        self.failures += int((arr < event).sum())


def _safe_rate(num: float, den: float) -> float:
    return float(num / den) if den else np.nan


def _term_number(code: object) -> float:
    try:
        text = str(int(float(code)))
    except (TypeError, ValueError, OverflowError):
        text = str(code)
    if not text:
        return np.nan
    last = text[-1]
    return float(last) if last.isdigit() else np.nan


def _entity_features(
    prefix: str,
    state: EntityState | None,
    current_semester: float,
    config: SuiteConfig,
) -> Dict[str, float]:
    seen = state is not None and state.count > 0
    if not seen:
        return {
            f"eng_{prefix}_seen_before": 0.0,
            f"eng_{prefix}_prior_registration_count": 0.0,
            f"eng_{prefix}_prior_failure_count": 0.0,
            f"eng_{prefix}_prior_failure_rate": np.nan,
            f"eng_{prefix}_prior_mean_grade": np.nan,
            f"eng_{prefix}_prior_semester_count": 0.0,
            f"eng_{prefix}_recent_registration_count": 0.0,
            f"eng_{prefix}_recent_failure_count": 0.0,
            f"eng_{prefix}_recent_failure_rate": np.nan,
            f"eng_{prefix}_recent_mean_grade": np.nan,
            f"eng_{prefix}_grade_trend": np.nan,
            f"eng_{prefix}_failure_rate_volatility": np.nan,
            f"eng_{prefix}_semesters_since_last_seen": np.nan,
            f"eng_{prefix}_semesters_since_last_failure": np.nan,
            f"eng_{prefix}_consecutive_failure_semesters": 0.0,
        }
    recent_count, recent_failures, recent_grade_sum, _ = state.recent(
        config.recent_semesters
    )
    recent_mean = _safe_rate(recent_grade_sum, recent_count)
    recent_fail_rate = _safe_rate(recent_failures, recent_count)
    long_mean = state.mean_grade()
    rates = state.semester_failure_rates()
    return {
        f"eng_{prefix}_seen_before": 1.0,
        f"eng_{prefix}_prior_registration_count": float(state.count),
        f"eng_{prefix}_prior_failure_count": float(state.failures),
        f"eng_{prefix}_prior_failure_rate": state.failure_rate(),
        f"eng_{prefix}_prior_mean_grade": long_mean,
        f"eng_{prefix}_prior_semester_count": float(len(state.semester_stats)),
        f"eng_{prefix}_recent_registration_count": float(recent_count),
        f"eng_{prefix}_recent_failure_count": float(recent_failures),
        f"eng_{prefix}_recent_failure_rate": recent_fail_rate,
        f"eng_{prefix}_recent_mean_grade": recent_mean,
        f"eng_{prefix}_grade_trend": recent_mean - long_mean
        if np.isfinite(recent_mean) and np.isfinite(long_mean)
        else np.nan,
        f"eng_{prefix}_failure_rate_volatility": float(np.nanstd(rates, ddof=0))
        if rates.size >= 2
        else 0.0,
        f"eng_{prefix}_semesters_since_last_seen": float(current_semester - state.last_semester)
        if state.last_semester is not None
        else np.nan,
        f"eng_{prefix}_semesters_since_last_failure": float(
            current_semester - state.last_failure_semester
        )
        if state.last_failure_semester is not None
        else np.nan,
        f"eng_{prefix}_consecutive_failure_semesters": float(
            state.trailing_failure_semesters()
        ),
    }


def _student_course_features(
    state: EntityState | None,
    current_semester: float,
) -> Dict[str, float]:
    seen = state is not None and state.count > 0
    if not seen:
        return {
            "eng_repeat_course_flag": 0.0,
            "eng_same_course_prior_attempts": 0.0,
            "eng_same_course_prior_failure_count": 0.0,
            "eng_same_course_prior_failure_rate": np.nan,
            "eng_same_course_last_grade": np.nan,
            "eng_same_course_mean_grade": np.nan,
            "eng_same_course_best_grade": np.nan,
            "eng_same_course_grade_trend": np.nan,
            "eng_same_course_semesters_since_last_attempt": np.nan,
        }
    last = state.grades[-1] if state.grades else np.nan
    mean = state.mean_grade()
    best = max(state.grades) if state.grades else np.nan
    return {
        "eng_repeat_course_flag": 1.0,
        "eng_same_course_prior_attempts": float(state.count),
        "eng_same_course_prior_failure_count": float(state.failures),
        "eng_same_course_prior_failure_rate": state.failure_rate(),
        "eng_same_course_last_grade": float(last),
        "eng_same_course_mean_grade": mean,
        "eng_same_course_best_grade": float(best),
        "eng_same_course_grade_trend": float(last - mean)
        if np.isfinite(last) and np.isfinite(mean)
        else np.nan,
        "eng_same_course_semesters_since_last_attempt": float(
            current_semester - state.last_semester
        )
        if state.last_semester is not None
        else np.nan,
    }


def _row_features(
    row: pd.Series,
    student_states: Mapping[Hashable, EntityState],
    course_states: Mapping[Hashable, EntityState],
    pair_states: Mapping[Tuple[Hashable, Hashable], EntityState],
    global_state: GlobalState,
    config: SuiteConfig,
) -> Dict[str, float]:
    student = row[config.student_col]
    course = row[config.course_col]
    semester = float(row[config.semester_col])
    s_state = student_states.get(student)
    c_state = course_states.get(course)
    p_state = pair_states.get((student, course))

    out: Dict[str, float] = {}
    out.update(_entity_features("student", s_state, semester, config))
    out.update(_entity_features("course", c_state, semester, config))
    out.update(_student_course_features(p_state, semester))

    global_rate = global_state.rate(config.default_failure_prior)
    course_count = c_state.count if c_state is not None else 0
    course_failures = c_state.failures if c_state is not None else 0
    out["eng_global_prior_failure_rate"] = global_rate
    out["eng_course_smoothed_failure_rate"] = (
        course_failures + config.course_prior_strength * global_rate
    ) / (course_count + config.course_prior_strength)

    student_mean = out["eng_student_prior_mean_grade"]
    student_recent = out["eng_student_recent_mean_grade"]
    course_mean = out["eng_course_prior_mean_grade"]
    student_risk = out["eng_student_prior_failure_rate"]
    course_risk = out["eng_course_smoothed_failure_rate"]
    out["eng_ability_difficulty_gap"] = (
        student_mean - course_mean
        if np.isfinite(student_mean) and np.isfinite(course_mean)
        else np.nan
    )
    out["eng_recent_ability_difficulty_gap"] = (
        student_recent - course_mean
        if np.isfinite(student_recent) and np.isfinite(course_mean)
        else np.nan
    )
    out["eng_student_risk_x_course_risk"] = (
        student_risk * course_risk if np.isfinite(student_risk) else np.nan
    )
    low_gpa = float(np.isfinite(student_recent) and student_recent < 6.0)
    out["eng_low_gpa_x_difficult_course"] = low_gpa * course_risk
    out["eng_new_student_x_difficult_course"] = (
        1.0 - out["eng_student_seen_before"]
    ) * course_risk
    previous_pair_failure = float(
        p_state is not None and p_state.failures > 0
    )
    out["eng_repeat_course_x_previous_failure"] = (
        out["eng_repeat_course_flag"] * previous_pair_failure
    )

    term = _term_number(row.get(config.semester_code_col))
    out["eng_target_term_number"] = term
    out["eng_is_first_main_semester"] = float(term == 1.0)
    out["eng_is_second_main_semester"] = float(term == 2.0)
    out["eng_is_special_term"] = float(np.isfinite(term) and term not in (1.0, 2.0))
    prior_sem_count = out["eng_student_prior_semester_count"]
    out["eng_student_program_stage"] = prior_sem_count
    out["eng_student_long_duration_flag"] = float(
        prior_sem_count > config.long_duration_semesters
    )
    return out


def _emit_features(
    frame: pd.DataFrame,
    student_states: Mapping[Hashable, EntityState],
    course_states: Mapping[Hashable, EntityState],
    pair_states: Mapping[Tuple[Hashable, Hashable], EntityState],
    global_state: GlobalState,
    config: SuiteConfig,
) -> pd.DataFrame:
    rows = [
        _row_features(
            row,
            student_states,
            course_states,
            pair_states,
            global_state,
            config,
        )
        for _, row in frame.iterrows()
    ]
    return pd.DataFrame(rows, index=frame.index, dtype=float)


def _update_states(
    frame: pd.DataFrame,
    student_states: MutableMapping[Hashable, EntityState],
    course_states: MutableMapping[Hashable, EntityState],
    pair_states: MutableMapping[Tuple[Hashable, Hashable], EntityState],
    global_state: GlobalState,
    config: SuiteConfig,
) -> None:
    semester = float(frame[config.semester_col].iloc[0])
    grades = pd.to_numeric(frame[config.target_col], errors="coerce")

    for student, group in frame.assign(_grade=grades).groupby(config.student_col, sort=False):
        state = student_states.setdefault(student, EntityState())
        state.update(semester, group["_grade"].to_numpy(), config.event)
    for course, group in frame.assign(_grade=grades).groupby(config.course_col, sort=False):
        state = course_states.setdefault(course, EntityState())
        state.update(semester, group["_grade"].to_numpy(), config.event)
    temp = frame.assign(_grade=grades)
    for (student, course), group in temp.groupby(
        [config.student_col, config.course_col], sort=False
    ):
        state = pair_states.setdefault((student, course), EntityState())
        state.update(semester, group["_grade"].to_numpy(), config.event)
    global_state.update(grades.to_numpy(), config.event)


def build_leak_safe_historical_features(
    train_df: pd.DataFrame,
    test_df: pd.DataFrame,
    config: SuiteConfig,
) -> Tuple[pd.DataFrame, pd.DataFrame]:
    """Generate historical features without same-semester or future-label access.

    All rows in a training semester are emitted from the historical state that
    existed before that semester. The state is updated only after all rows in
    the semester have received features. Test labels are never accessed.
    """
    train = train_df.copy()
    test = test_df.copy()
    train[config.semester_col] = pd.to_numeric(
        train[config.semester_col], errors="raise"
    )
    test[config.semester_col] = pd.to_numeric(test[config.semester_col], errors="raise")
    train["__original_order"] = np.arange(len(train))

    student_states: Dict[Hashable, EntityState] = {}
    course_states: Dict[Hashable, EntityState] = {}
    pair_states: Dict[Tuple[Hashable, Hashable], EntityState] = {}
    global_state = GlobalState()

    emitted = []
    for _, semester_frame in train.sort_values(
        [config.semester_col, "__original_order"], kind="mergesort"
    ).groupby(config.semester_col, sort=True):
        feats = _emit_features(
            semester_frame,
            student_states,
            course_states,
            pair_states,
            global_state,
            config,
        )
        feats["__original_order"] = semester_frame["__original_order"].to_numpy()
        emitted.append(feats)
        _update_states(
            semester_frame,
            student_states,
            course_states,
            pair_states,
            global_state,
            config,
        )

    train_features = (
        pd.concat(emitted, axis=0)
        .sort_values("__original_order")
        .drop(columns="__original_order")
        .reset_index(drop=True)
    )
    test_features = _emit_features(
        test.reset_index(drop=True),
        student_states,
        course_states,
        pair_states,
        global_state,
        config,
    ).reset_index(drop=True)
    return train_features, test_features
