from __future__ import annotations

from typing import Iterable

import numpy as np
import pandas as pd

from .config import SuiteConfig


def binary_auc(values: np.ndarray | pd.Series, y: np.ndarray | pd.Series) -> float:
    x = pd.to_numeric(pd.Series(values), errors="coerce")
    target = pd.to_numeric(pd.Series(y), errors="coerce")
    valid = x.notna() & target.notna()
    x = x[valid].reset_index(drop=True)
    target = target[valid].astype(int).reset_index(drop=True)
    n_pos = int((target == 1).sum())
    n_neg = int((target == 0).sum())
    if n_pos == 0 or n_neg == 0:
        return float("nan")
    ranks = x.rank(method="average").to_numpy(dtype=float)
    rank_sum_pos = float(ranks[target.to_numpy() == 1].sum())
    u = rank_sum_pos - n_pos * (n_pos + 1) / 2.0
    return float(u / (n_pos * n_neg))


def _numeric_frame(X: pd.DataFrame) -> pd.DataFrame:
    return X.apply(pd.to_numeric, errors="coerce").replace([np.inf, -np.inf], np.nan)


def score_temporal_stability(
    X: pd.DataFrame,
    y_binary: np.ndarray | pd.Series,
    semesters: np.ndarray | pd.Series,
    config: SuiteConfig,
) -> pd.DataFrame:
    Xn = _numeric_frame(X)
    y = np.asarray(y_binary, dtype=int)
    sem = pd.to_numeric(pd.Series(semesters), errors="coerce").to_numpy()
    unique_semesters = [s for s in sorted(pd.unique(sem[~pd.isna(sem)]))]
    rows = []
    for feature in Xn.columns:
        values = Xn[feature]
        aucs: list[float] = []
        strengths: list[float] = []
        directions: list[int] = []
        observed_rates: list[float] = []
        nonconstant = 0
        for semester in unique_semesters:
            mask = sem == semester
            xs = values[mask]
            ys = y[mask]
            observed = xs.notna().to_numpy()
            observed_rates.append(float(observed.mean()) if len(observed) else 0.0)
            if observed.sum() == 0:
                continue
            observed_values = xs.to_numpy(dtype=float)[observed]
            observed_y = ys[observed]
            if np.unique(observed_values).size > 1:
                nonconstant += 1
            if (
                int((observed_y == 1).sum()) < config.stability_min_class_count
                or int((observed_y == 0).sum()) < config.stability_min_class_count
                or np.unique(observed_values).size <= 1
            ):
                continue
            auc = binary_auc(observed_values, observed_y)
            if not np.isfinite(auc):
                continue
            aucs.append(float(auc))
            strength = abs(float(auc) - 0.5)
            strengths.append(strength)
            if strength > 1e-12:
                directions.append(1 if auc > 0.5 else -1)
        valid_semesters = len(aucs)
        median_strength = float(np.median(strengths)) if strengths else 0.0
        if directions:
            direction_consistency = max(directions.count(1), directions.count(-1)) / len(directions)
            dominant_direction = 1 if directions.count(1) >= directions.count(-1) else -1
        else:
            direction_consistency = 0.0
            dominant_direction = 0
        observed_rate = float(values.notna().mean())
        nonconstant_rate = nonconstant / max(len(unique_semesters), 1)
        missing_rate_std = float(np.std([1.0 - r for r in observed_rates])) if observed_rates else 0.0
        priority_score = (
            median_strength
            + 0.05 * direction_consistency
            + 0.02 * nonconstant_rate
            - 0.02 * missing_rate_std
        )
        protected = feature in config.protected_features and values.notna().any()
        selected = protected or (
            observed_rate >= config.stability_min_observed_rate
            and nonconstant_rate >= config.stability_min_nonconstant_semester_rate
            and valid_semesters >= config.stability_min_valid_semesters
            and median_strength >= config.stability_min_median_strength
            and direction_consistency >= config.stability_min_direction_consistency
        )
        rows.append(
            {
                "feature": feature,
                "observed_rate": observed_rate,
                "nonconstant_semester_rate": nonconstant_rate,
                "valid_semesters": valid_semesters,
                "median_strength": median_strength,
                "mean_auc": float(np.mean(aucs)) if aucs else float("nan"),
                "worst_strength": float(np.min(strengths)) if strengths else 0.0,
                "direction_consistency": direction_consistency,
                "dominant_direction": dominant_direction,
                "missing_rate_std": missing_rate_std,
                "priority_score": priority_score,
                "protected": bool(protected),
                "selected": bool(selected),
            }
        )
    return pd.DataFrame(rows)


def select_temporally_stable_features(
    X: pd.DataFrame,
    y_binary: np.ndarray | pd.Series,
    semesters: np.ndarray | pd.Series,
    config: SuiteConfig,
) -> tuple[list[str], pd.DataFrame]:
    report = score_temporal_stability(X, y_binary, semesters, config)
    selected_set = set(report.loc[report["selected"], "feature"].tolist())
    selected = [c for c in X.columns if c in selected_set]
    return selected, report
