import itertools
import numpy as np
import pandas as pd
from scipy import stats
from common import RES, EXT, SEED, read_matrix, abc

N_PERM = 100_000
N_SETS = 10_000
N_BOOT = 5000
MIN_SHARED = 50
FILES = ("SGA_NxN.txt", "SGA_ExN.txt", "SGA_ExE.txt", "SGA_DAmP.txt")
rng = np.random.default_rng(SEED)

A = abc().set_index("gene")
I = pd.read_csv(RES / "abc_identity.csv", index_col=0)
RBH = {frozenset(p) for p in pd.read_csv(RES / "abc_paralog_pairs.csv")[["gene1", "gene2"]].itertuples(index=False)}
SAME = {frozenset((a, b)) for a, b in itertools.combinations(A.index, 2) if A.subfamily[a] == A.subfamily[b]}

Z = read_matrix("hom.z_result_nm.pub")
genes = [g for g in A.index if A.systematic[g] in Z.index and Z.loc[A.systematic[g]].notna().sum() >= MIN_SHARED]
X = Z.loc[[A.systematic[g] for g in genes]]
n = len(genes)
R = np.full((n, n), np.nan)
for i, j in itertools.combinations(range(n), 2):
    m = X.iloc[i].notna() & X.iloc[j].notna()
    R[i, j] = R[j, i] = stats.pearsonr(X.iloc[i][m], X.iloc[j][m]).statistic
Fz = np.arctanh(R)
Id = I.loc[genes, genes].values
S = pd.read_csv(RES / "abc_struct_sim.csv")
Tm = pd.DataFrame(np.nan, index=genes, columns=genes)
for g1, g2, tm in S[["gene1", "gene2", "tmscore"]].itertuples(index=False):
    if g1 in genes and g2 in genes:
        Tm.loc[g1, g2] = Tm.loc[g2, g1] = tm
Tm = Tm.values
iu = np.triu_indices(n, 1)
par = np.array([frozenset((genes[i], genes[j])) in RBH for i, j in zip(*iu)])
same = np.array([frozenset((genes[i], genes[j])) in SAME for i, j in zip(*iu)])


def mantel_stat(F):
    return stats.spearmanr(Id[iu], F[iu]).statistic


def diff_stat(F, mask):
    f = F[iu]
    return f[mask].mean() - f[~mask].mean()


def tm_stat(F):
    return stats.spearmanr(Tm[iu], F[iu]).statistic


obs = {"mantel_rho": mantel_stat(Fz), "paralog_minus_other_z": diff_stat(Fz, par), "same_minus_diff_subfamily_z": diff_stat(Fz, same),
       "mantel_rho_tmscore": tm_stat(Fz)}
null = {k: np.empty(N_PERM) for k in obs}
for b in range(N_PERM):
    p = rng.permutation(n)
    Fp = Fz[np.ix_(p, p)]
    null["mantel_rho"][b] = mantel_stat(Fp)
    null["paralog_minus_other_z"][b] = diff_stat(Fp, par)
    null["same_minus_diff_subfamily_z"][b] = diff_stat(Fp, same)
    null["mantel_rho_tmscore"][b] = tm_stat(Fp)
pvals = {"mantel_rho": (np.sum(np.abs(null["mantel_rho"]) >= abs(obs["mantel_rho"])) + 1) / (N_PERM + 1),
         "paralog_minus_other_z": (np.sum(null["paralog_minus_other_z"] >= obs["paralog_minus_other_z"]) + 1) / (N_PERM + 1),
         "same_minus_diff_subfamily_z": (np.sum(null["same_minus_diff_subfamily_z"] >= obs["same_minus_diff_subfamily_z"]) + 1) / (N_PERM + 1),
         "mantel_rho_tmscore": (np.sum(np.abs(null["mantel_rho_tmscore"]) >= abs(obs["mantel_rho_tmscore"])) + 1) / (N_PERM + 1)}
boot = {k: [] for k in obs}
for _ in range(N_BOOT):
    s = rng.integers(0, n, n)
    ii, jj = np.triu_indices(n, 1)
    keep = s[ii] != s[jj]
    a, c = s[ii][keep], s[jj][keep]
    f, idv = Fz[a, c], Id[a, c]
    pr = np.array([frozenset((genes[x], genes[y])) in RBH for x, y in zip(a, c)])
    sm = np.array([frozenset((genes[x], genes[y])) in SAME for x, y in zip(a, c)])
    boot["mantel_rho"].append(stats.spearmanr(idv, f).statistic)
    boot["mantel_rho_tmscore"].append(stats.spearmanr(Tm[a, c], f).statistic)
    if pr.any():
        boot["paralog_minus_other_z"].append(f[pr].mean() - f[~pr].mean())
    boot["same_minus_diff_subfamily_z"].append(f[sm].mean() - f[~sm].mean())
prof = pd.DataFrame([(k, obs[k], *np.percentile(boot[k], [2.5, 97.5]), pvals[k], n, int(par.sum()), int(same.sum()))
                     for k in obs], columns=["statistic", "value", "ci_low", "ci_high", "p_gene_label_permutation",
                                             "transporters", "paralog_pairs", "same_subfamily_pairs"])
prof.to_csv(RES / "abc_profile_dependence.csv", index=False)
pd.DataFrame({k: v[:10000] for k, v in null.items()}).round(5).to_csv(RES / "abc_profile_null.csv", index=False)

D = EXT / "costanzo2016"
cache = D / "eps_dense.npz"
if not cache.exists():
    names, ess = {}, set()
    parts = []
    for f in FILES:
        for ch in pd.read_csv(D / f, sep="\t", usecols=[0, 2, 5], chunksize=2_000_000):
            ch.columns = ["q", "a", "eps"]
            for col in ("q", "a"):
                tag = ch[col].str.split("_").str[1].fillna("")
                ess.update(ch[col][tag.str.contains("tsq|tsa|damp", case=False)].str.split("_").str[0].unique())
            q, a = ch.q.str.split("_").str[0], ch.a.str.split("_").str[0]
            keep = q != a
            parts.append((q[keep].values, a[keep].values, ch.eps[keep].values.astype(np.float64)))
    allg = sorted(set(np.concatenate([p[0] for p in parts])) | set(np.concatenate([p[1] for p in parts])))
    ix = {g: i for i, g in enumerate(allg)}
    G = len(allg)
    S = np.zeros((G, G))
    C = np.zeros((G, G), dtype=np.int32)
    for q, a, e in parts:
        qi = np.fromiter((ix[x] for x in q), int, len(q))
        ai = np.fromiter((ix[x] for x in a), int, len(a))
        ok = ~np.isnan(e)
        np.add.at(S, (qi[ok], ai[ok]), e[ok])
        np.add.at(C, (qi[ok], ai[ok]), 1)
    S, C = S + S.T, C + C.T
    with np.errstate(invalid="ignore"):
        M = (S / C).astype(np.float32)
    np.savez_compressed(cache, M=M, genes=np.array(allg), essential=np.array(sorted(ess)))
dat = np.load(cache, allow_pickle=True)
M, allg, ess = dat["M"], list(dat["genes"]), set(dat["essential"])
ix = {g: i for i, g in enumerate(allg)}
meas = ~np.isnan(M)
coverage = meas.sum(axis=1)
degree = np.nansum(M < -0.08, axis=1)
essential = np.array([g in ess for g in allg])

abc_sys = [A.systematic[g] for g in A.index if A.systematic[g] in ix]
abc_name = {A.systematic[g]: g for g in A.index}
abc_i = np.array([ix[s] for s in abc_sys])


def within_mean(idx):
    sub = M[np.ix_(idx, idx)]
    iu2 = np.triu_indices(len(idx), 1)
    v = sub[iu2]
    return np.nanmean(v), int(np.sum(~np.isnan(v)))


RBH_PAIRS = sorted(tuple(sorted(p)) for p in RBH)
par_pairs = [(abc_sys.index(A.systematic[a]), abc_sys.index(A.systematic[b])) for a, b in RBH_PAIRS
             if A.systematic[a] in ix and A.systematic[b] in ix]


def pair_mean(idx):
    v = [M[idx[i], idx[j]] for i, j in par_pairs]
    v = [x for x in v if not np.isnan(x)]
    return np.mean(v) if v else np.nan, len(v)


obs_all, n_all = within_mean(abc_i)
obs_par, n_par = pair_mean(abc_i)
lc = np.log10(coverage + 1)
bins_c = np.digitize(lc, np.quantile(lc[coverage > 0], np.linspace(0, 1, 11)[1:-1]))
bins_d = np.digitize(degree, np.quantile(degree[coverage > 0], np.linspace(0, 1, 6)[1:-1]))
pool_mask = (coverage > 0) & ~np.isin(np.arange(len(allg)), abc_i)
candidates = {}
for g in abc_i:
    m = pool_mask & (essential == essential[g]) & (bins_c == bins_c[g]) & (bins_d == bins_d[g])
    if m.sum() < 20:
        m = pool_mask & (essential == essential[g]) & (np.abs(bins_c - bins_c[g]) <= 1) & (np.abs(bins_d - bins_d[g]) <= 1)
    candidates[g] = np.where(m)[0]
null_all, null_par, null_unm = [], [], []
pool_idx = np.where(pool_mask)[0]
for _ in range(N_SETS):
    idx = np.array([rng.choice(candidates[g]) for g in abc_i])
    if len(set(idx)) < len(idx):
        continue
    null_all.append(within_mean(idx)[0])
    null_par.append(pair_mean(idx)[0])
    null_unm.append(within_mean(rng.choice(pool_idx, len(abc_i), replace=False))[0])
null_all, null_par, null_unm = map(np.array, (null_all, null_par, null_unm))
gi = pd.DataFrame([
    ("ABC-ABC pairs, degree/coverage/essentiality-matched random gene sets", obs_all, n_all, np.nanmean(null_all),
     *np.nanpercentile(null_all, [2.5, 97.5]), (np.sum(null_all <= obs_all) + 1) / (len(null_all) + 1)),
    ("ABC-ABC pairs, unmatched random gene sets", obs_all, n_all, np.nanmean(null_unm),
     *np.nanpercentile(null_unm, [2.5, 97.5]), (np.sum(null_unm <= obs_all) + 1) / (len(null_unm) + 1)),
    ("reciprocal-best paralog pairs, matched random gene sets", obs_par, n_par, np.nanmean(null_par),
     *np.nanpercentile(null_par, [2.5, 97.5]), (np.sum(null_par <= obs_par) + 1) / (np.sum(~np.isnan(null_par)) + 1))],
    columns=["test", "observed_mean_eps", "pairs_measured", "null_mean", "null_2.5", "null_97.5", "p_one_sided_negative"])
gi.to_csv(RES / "abc_gi_matched_sets.csv", index=False)
pd.DataFrame({"matched_all_pairs": null_all, "unmatched_all_pairs": null_unm[:len(null_all)],
              "matched_paralog_pairs": null_par}).round(6).to_csv(RES / "abc_gi_null.csv", index=False)
pe = []
for a, b in RBH_PAIRS:
    sa, sb = A.systematic[a], A.systematic[b]
    pe.append((a, b, M[ix[sa], ix[sb]] if sa in ix and sb in ix else np.nan))
for a, b in (("PDR5", "SNQ2"), ("PDR5", "YOR1"), ("SNQ2", "YOR1")):
    pe.append((a, b, M[ix[A.systematic[a]], ix[A.systematic[b]]]))
pd.DataFrame(pe, columns=["gene1", "gene2", "eps"]).assign(
    relation=["paralogue"] * len(RBH) + ["co-regulated multidrug pump"] * 3).to_csv(RES / "abc_pair_eps.csv", index=False)
props = pd.DataFrame({"gene": [abc_name[s] for s in abc_sys], "coverage": coverage[abc_i], "negative_degree": degree[abc_i],
                      "essential": essential[abc_i], "genome_median_coverage": np.median(coverage[pool_mask]),
                      "genome_median_degree": np.median(degree[pool_mask])})
props.to_csv(RES / "abc_gi_properties.csv", index=False)

pd.set_option("display.width", 220)