"""Prediction sensitivity and observed-history descriptions; no causal attribution."""
from __future__ import annotations
import numpy as np
import pandas as pd
from scipy.stats import rankdata
from s34_metrics import cell_metrics, budget_alerts
from s34_model import IPMVCL
from s34_training import predict_model
from s34_views import VIEWS


def history_strata(part, p):
    rows = []
    definitions = [
        ("hist_semester_count", "cached_history_ge3", lambda x: x >= 3),
        ("hist_semester_count", "cached_history_lt3", lambda x: x < 3),
        ("student_gpa_history_missing_flag", "recorded_gpa_missing_flag", lambda x: x > .5),
        ("student_gpa_history_missing_flag", "recorded_gpa_available_flag", lambda x: x <= .5),
        ("hist_same_course_attempts", "cached_prior_attempt_positive", lambda x: x > 0),
        ("hist_same_course_attempts", "cached_attempt_zero_not_verified_no_attempt", lambda x: x == 0),
    ]
    for feature, label, rule in definitions:
        if feature not in part.names:
            rows.append(dict(stratum=label, source_feature=feature, status="UNAVAILABLE_FEATURE"))
            continue
        x = part.X[:, part.names.index(feature)]
        mask = np.isfinite(x) & rule(x)
        if not mask.any():
            rows.append(dict(stratum=label, source_feature=feature, status="EMPTY"))
            continue
        rows.append(dict(stratum=label, source_feature=feature,
                         status="OBSERVED_CACHE_FEATURE_ONLY", **cell_metrics(part.y[mask], p[mask])))
    return rows


def diagnose(result, target):
    model, pp = result["model"], result["preprocessor"]
    if not isinstance(model, IPMVCL):
        return dict(interactions=[], views=[], history=history_strata(target, result["probabilities"]))
    X = pp.transform(target.X)
    base, detail = predict_model(model, X, return_details=True)
    view_rows, interventions = [], []
    manifest = result["manifest"]
    for v in VIEWS:
        if v not in detail:
            continue
        raw = [target.names.index(n) for n in manifest[v]]
        norms = np.linalg.norm(detail[v], axis=1)
        input_norm = np.linalg.norm(X[:, model.views[v]], axis=1)
        corr = float(np.corrcoef(input_norm, norms)[0, 1]) if input_norm.std() > 0 and norms.std() > 0 else np.nan
        view_rows.append(dict(view=v, original_features=len(raw), transformed_channels=len(model.views[v]),
            observed_features_mean=float(np.isfinite(target.X[:, raw]).sum(axis=1).mean()),
            cache_missing_fraction=float((~np.isfinite(target.X[:, raw])).mean()),
            embedding_norm_mean=float(norms.mean()), embedding_norm_sd=float(norms.std()),
            embedding_variance=float(detail[v].var(axis=0).mean()), input_norm_correlation=corr,
            interpretation="DESCRIPTIVE_NOT_UTILITY"))
    if model.arm in ("A2", "P1", "A3"):
        specifications = [
            ("zero_SC", dict(zero_interactions=("sc",))),
            ("zero_HC", dict(zero_interactions=("hc",))),
            ("zero_SC_HC", dict(zero_interactions=("sc", "hc"))),
        ] + [(f"zero_{v}_specialized_branch", dict(zero_views=(v,))) for v in VIEWS]
        for name, arguments in specifications:
            p = predict_model(model, X, **arguments)
            delta = p-base
            interventions.append(dict(intervention=name, **cell_metrics(target.y, p),
                delta_ap=cell_metrics(target.y, p)["ap"]-cell_metrics(target.y, base)["ap"],
                mean_abs_dp=float(np.abs(delta).mean()), median_abs_dp=float(np.median(np.abs(delta))),
                p90_abs_dp=float(np.quantile(np.abs(delta), .9)), p99_abs_dp=float(np.quantile(np.abs(delta), .99)),
                max_abs_dp=float(np.max(np.abs(delta))), mean_signed_dp=float(delta.mean()),
                sc_norm_mean=float(np.linalg.norm(detail["sc"], axis=1).mean()),
                hc_norm_mean=float(np.linalg.norm(detail["hc"], axis=1).mean()),
                interpretation="SENSITIVITY_JOINT_LAYERNORM_FULL_PATH_REMAINS_NOT_CAUSAL"))
    return dict(interactions=interventions, views=view_rows,
                history=history_strata(target, base))


def rescue_harm(new, base, new_thresholds=None, base_thresholds=None):
    key = ["row_index", "student_id", "course_id", "target_semester", "y"]
    a, b = new.sort_values("row_index"), base.sort_values("row_index")
    if not a[key].reset_index(drop=True).equals(b[key].reset_index(drop=True)):
        raise ValueError("Rescue/harm comparison failed exact target identity alignment")
    y, pa, pb = a.y.to_numpy(), a.p.to_numpy(), b.p.to_numpy()
    positive = y == 1
    improvement = rankdata(-pb, method="average")-rankdata(-pa, method="average")
    rank = dict(policy="whole_cell_positive_ranks", positive_support=int(positive.sum()),
                positive_rank_improved=int(np.sum(improvement[positive] > 0)),
                positive_rank_worsened=int(np.sum(improvement[positive] < 0)),
                positive_rank_tied=int(np.sum(improvement[positive] == 0)),
                mean_positive_rank_improvement=float(improvement[positive].mean()) if positive.any() else np.nan,
                median_positive_rank_improvement=float(np.median(improvement[positive])) if positive.any() else np.nan)
    rows = [rank]
    policies = [(f"budget_{fraction:.2f}",
                 budget_alerts(pa, a.row_index, fraction), budget_alerts(pb, b.row_index, fraction))
                for fraction in (.1, .15, .2, .25)]
    for beta in (1, 2):
        ta = (new_thresholds or {}).get(beta)
        tb = (base_thresholds or {}).get(beta)
        if ta is not None and tb is not None and np.isfinite(ta) and np.isfinite(tb):
            policies.append((f"frozen_recipe_beta{beta}", pa >= ta, pb >= tb))
    for policy, aa, ab in policies:
        rows.append(dict(policy=policy, positive_support=int(positive.sum()),
            failures_rescued=int(np.sum(positive & aa & ~ab)),
            failures_harmed=int(np.sum(positive & ~aa & ab)),
            negatives_entering_alerts=int(np.sum(~positive & aa & ~ab)),
            negatives_leaving_alerts=int(np.sum(~positive & ~aa & ab)),
            newly_correct=int(np.sum((positive == aa) & (positive != ab))),
            newly_wrong=int(np.sum((positive != aa) & (positive == ab)))))
    return rows
