import itertools
import numpy as np
import pandas as pd
from common import RES, SEED, hom, axes, centre

TARGET = "YPL270W"
MC_REPLICATES = 10
MC_SMALL = 10_000
MC_LARGE = 10_000_000
CHUNK = 500_000

Z = hom()
ag, ox, os_, ref = axes(Z.columns)
Zc = centre(Z)
s = np.concatenate([np.where(ox)[0], np.where(os_)[0]])
v = Zc.loc[TARGET].values[s]
lab = ox[s].astype(int)
n1, n = int(lab.sum()), len(lab)
obs = abs(v[lab == 1].mean() - v[lab == 0].mean())
tot = v.sum()


def stat_from_idx(idx):
    a = v[idx].sum(axis=-1)
    return np.abs(a / n1 - (tot - a) / (n - n1))


combos = np.array(list(itertools.combinations(range(n), n1)))
exact_stats = stat_from_idx(combos)
k_exact = int((exact_stats >= obs - 1e-12).sum())
p_exact = k_exact / len(combos)

rng = np.random.default_rng(SEED)


def mc(B):
    hits, done = 0, 0
    while done < B:
        b = min(CHUNK, B - done)
        idx = np.argsort(rng.random((b, n)), axis=1)[:, :n1]
        hits += int((stat_from_idx(idx) >= obs - 1e-12).sum())
        done += b
    return (hits + 1) / (B + 1)


small = [mc(MC_SMALL) for _ in range(MC_REPLICATES)]
large = [mc(MC_LARGE) for _ in range(MC_REPLICATES)]

agents = list(dict.fromkeys(ag[s]))
blocks = [np.where(ag[s] == a)[0] for a in agents]
n_ox_agents = len({a for a in agents if ox[s][ag[s] == a][0]})
balanced = []
for chosen in itertools.combinations(range(len(agents)), n_ox_agents):
    m = np.zeros(n, bool)
    for c in chosen:
        m[blocks[c]] = True
    balanced.append(abs(v[m].mean() - v[~m].mean()))
balanced = np.array(balanced)
k_bal = int((balanced >= obs - 1e-12).sum())
anyp = []
for assign in itertools.product((0, 1), repeat=len(agents)):
    if len(set(assign)) < 2:
        continue
    m = np.concatenate([[assign[i]] * len(blocks[i]) for i in range(len(agents))])
    order = np.concatenate(blocks)
    vv = v[order]
    anyp.append(abs(vv[m == 1].mean() - vv[m == 0].mean()))
anyp = np.array(anyp)
k_any = int((anyp >= obs - 1e-12).sum())

out = pd.DataFrame([
    ("condition-level, exact enumeration", len(combos), k_exact, p_exact, np.nan, np.nan),
    (f"condition-level, Monte Carlo {MC_SMALL:,} x {MC_REPLICATES}", MC_SMALL, np.nan, np.mean(small), min(small), max(small)),
    (f"condition-level, Monte Carlo {MC_LARGE:,} x {MC_REPLICATES}", MC_LARGE, np.nan, np.mean(large), min(large), max(large)),
    ("agent-level, exact, design-preserving (3 vs 2 agents)", len(balanced), k_bal, k_bal / len(balanced), np.nan, np.nan),
    ("agent-level, exact, all bipartitions of 5 agents", len(anyp), k_any, k_any / len(anyp), np.nan, np.nan)],
    columns=["procedure", "assignments_or_B", "k_extreme", "p", "p_min_replicate", "p_max_replicate"])
out.to_csv(RES / "permutation_mdl2.csv", index=False)
pd.DataFrame({"permutations": [MC_SMALL] * MC_REPLICATES + [MC_LARGE] * MC_REPLICATES,
              "replicate": list(range(1, MC_REPLICATES + 1)) * 2, "p": small + large}).to_csv(
    RES / "permutation_mdl2_replicates.csv", index=False)