"""Per-scenario rank rule (the same rule as Case 1), pairwise win rates, Kendall tau and goal bootstrap. Sim2Sim.

Times: array T[policy, goal, trial] in seconds, failure = HORIZON (40 s), so failures rank last and tie.
Rank rule: per (goal, trial) fractional ranks by time (1 = fastest, ties share the mean rank).
Policy score = mean rank, first over the trials of a goal, then over goals (equal goal weight).
Order = ascending mean rank. Win rate P(p beats q) = mean of 1[T_p < T_q] + 0.5 * 1[T_p == T_q].
Bootstrap resamples goals (stratified by goal range), keeps all trials of a goal, and is paired across
methods (the same goal indices for ROM methods and Chrono).
"""
import numpy as np
from scipy.stats import rankdata

from common import HORIZON_S


def bounded(times, success):
    t = np.where(success, times, HORIZON_S)
    return np.minimum(np.nan_to_num(t, nan=HORIZON_S), HORIZON_S)


def per_goal_ranks(T):
    """T[p, g, k] -> per-goal mean rank R[p, g] (fractional ranks within each (g, k))."""
    P, G, K = T.shape
    r = rankdata(T.reshape(P, -1), axis=0, method='average').reshape(P, G, K)
    return r.mean(2)


def per_goal_wins(T):
    """W[p, q, g] = mean over trials of P(T_p < T_q) with ties 0.5."""
    lt = (T[:, None] < T[None, :]).astype(np.float64)
    eq = (T[:, None] == T[None, :]).astype(np.float64)
    return (lt + 0.5 * eq).mean(3)


def kendall_tau_b(a, b):
    """Kendall tau-b between score vectors a[..., n] and b[..., n] (lower score = better; only sign matters)."""
    i, j = np.triu_indices(a.shape[-1], 1)
    sa = np.sign(a[..., i] - a[..., j])
    sb = np.sign(b[..., i] - b[..., j])
    n0 = len(i)
    n1 = (sa == 0).sum(-1)
    n2 = (sb == 0).sum(-1)
    den = np.sqrt((n0 - n1) * (n0 - n2).astype(np.float64))
    with np.errstate(invalid='ignore', divide='ignore'):
        return np.where(den > 0, (sa * sb).sum(-1) / den, np.nan)


def spearman(a, b):
    ra = rankdata(a, axis=-1)
    rb = rankdata(b, axis=-1)
    ra = ra - ra.mean(-1, keepdims=True)
    rb = rb - rb.mean(-1, keepdims=True)
    with np.errstate(invalid='ignore', divide='ignore'):
        return (ra * rb).sum(-1) / np.sqrt((ra ** 2).sum(-1) * (rb ** 2).sum(-1))


def boot_indices(strata, B, seed):
    """strata: array of stratum labels per goal. Returns (B, G) resampled goal indices, stratified."""
    rng = np.random.default_rng(seed)
    strata = np.asarray(strata)
    cols = []
    for s in np.unique(strata):
        idx = np.flatnonzero(strata == s)
        cols.append(idx[rng.integers(0, len(idx), (B, len(idx)))])
    return np.concatenate(cols, 1)


def ci(x, lo=2.5, hi=97.5):
    x = np.asarray(x, dtype=np.float64)
    x = x[np.isfinite(x)]
    return [float(np.percentile(x, lo)), float(np.percentile(x, hi))] if len(x) else [None, None]


def summarize_method(T, success, policies, goal_range, boot=None):
    """Success by range, mean rank, order, resolved pairs. T and success are [p, g, k]."""
    R = per_goal_ranks(T)
    mr = R.mean(1)
    order = [policies[i] for i in np.argsort(mr, kind='stable')]
    out = dict(mean_rank={p: float(mr[i]) for i, p in enumerate(policies)}, order=order)
    gr = np.asarray(goal_range)
    out['success_rate'] = {rng: {p: float(success[i][gr == rng].mean()) for i, p in enumerate(policies)}
                           for rng in sorted(set(gr))}
    out['success_rate']['all'] = {p: float(success[i].mean()) for i, p in enumerate(policies)}
    # mean time over goals (and trials) where every policy succeeds
    allok = success.all(0)
    out['common_success_units'] = int(allok.sum())
    out['mean_time_common_success'] = {p: (float(T[i][allok].mean()) if allok.any() else None) for i, p in enumerate(policies)}
    if boot is not None:
        W = per_goal_wins(T)
        w = W.mean(2)
        wb = W[:, :, boot].mean(3)  # [p, q, B]
        pairs = []
        for a in range(len(policies)):
            for b in range(a + 1, len(policies)):
                lo, hi = ci(wb[a, b])
                pairs.append(dict(a=policies[a], b=policies[b], win_a=float(w[a, b]), ci95=[lo, hi],
                                  resolved=bool(lo > 0.5 or hi < 0.5)))
        out['pairs'] = pairs
        out['resolved_pairs'] = int(sum(p['resolved'] for p in pairs))
        mrb = R[:, boot].mean(2).T  # [B, p]
        out['mean_rank_ci95'] = {p: ci(mrb[:, i]) for i, p in enumerate(policies)}
    return out


def compare_to_truth(methods, truth, boot):
    """methods: dict name -> per-goal mean ranks R[p, g]; truth: R[p, g] (Chrono). Paired goal bootstrap."""
    t_mr = truth.mean(1)
    t_b = truth[:, boot].mean(2).T
    res = {}
    taus_b = {}
    for name, R in methods.items():
        mr = R.mean(1)
        rb = R[:, boot].mean(2).T
        tb = kendall_tau_b(rb, t_b)
        taus_b[name] = tb
        res[name] = dict(kendall_tau_b=float(kendall_tau_b(mr, t_mr)), kendall_ci95=ci(tb),
                         spearman=float(spearman(mr, t_mr)), spearman_ci95=ci(spearman(rb, t_b)))
    return res, taus_b


def pair_agreement(R_method, R_base, R_truth, policies):
    """Pairs where method and base disagree on order: how many does each get right relative to truth."""
    a, b, t = R_method.mean(1), R_base.mean(1), R_truth.mean(1)
    i, j = np.triu_indices(len(policies), 1)
    sm, sb, st = np.sign(a[i] - a[j]), np.sign(b[i] - b[j]), np.sign(t[i] - t[j])
    disc = (sm != sb)
    return dict(pairs=int(len(i)), method_correct=int((sm == st).sum()), base_correct=int((sb == st).sum()),
                discordant=int(disc.sum()), discordant_method_correct=int((disc & (sm == st)).sum()),
                discordant_base_correct=int((disc & (sb == st)).sum()))