"""
pusula_board.py — Sonuc dosyalarindan yayinlanabilir leaderboard uretir (metin icermez: yalnizca skorlar ve ID'ler).

Siralama: mobil sorgularda mutlak basari. Komsu iki modelin farki VERI SETI DENGELI eslestirilmis bootstrap ile
test edilir; %95 guven araligi sifiri kapsiyorsa iki model ayni gruptadir (yapay siralama iddia edilmez).
"""
import numpy as np

from pusula_eval import robustness_row

LEXICAL_PREFIX = "bm25"


def balanced_paired_diff(a_by_ds, b_by_ds, n_boot=2000, seed=0):
    """Her veri seti esit agirlikli: fark = mean_d(mean(a_d - b_d)). Bootstrap her sette ayri ornekler."""
    rng = np.random.default_rng(seed)
    boots, point = np.zeros(n_boot), 0.0
    for a, b in zip(a_by_ds, b_by_ds):
        d = np.asarray(a, float) - np.asarray(b, float)
        point += d.mean()
        boots += d[rng.integers(0, len(d), size=(n_boot, len(d)))].mean(axis=1)
    k = len(a_by_ds)
    return point / k, (float(np.percentile(boots / k, 2.5)), float(np.percentile(boots / k, 97.5)))


def _vec(pq, ds, pert, metric, qids):
    return np.array([pq[ds][pert][metric][q] for q in qids])


def build_board(results, datasets, changed, perts, metric="ndcg@10", rank_pert="mobile",
                families=None, n_boot=2000, seed=0, holdout=()):
    """results: load_results() ciktisi. datasets: {ad: {"queries": [qid,...], ...meta}}.
    holdout: veri seti bazinda hesaplanip gosterilen ama ORTALAMAYA, SIRALAMAYA ve GRUPLARA girmeyen setler
    (or. egitim verisiyle ortusen msmarco-tr)."""
    families = families or {}
    qids = {d: sorted(datasets[d]["queries"]) for d in datasets}
    agg = [d for d in datasets if d not in set(holdout)]
    assert agg, "En az bir veri seti siralamaya girmeli"
    models = []
    for short, r in results.items():
        pq, spec = r["per_query"], r["spec"]
        fam = families.get(short) or ("Sözcüksel" if short.startswith(LEXICAL_PREFIX) else "Diğer")
        entry = {"short": short, "model_id": spec["model_id"], "params_m": spec.get("params_m") or None,
                 "revision": spec.get("revision"), "family": fam, "prompts": r.get("prompts"),
                 "dtype": r.get("dtype"), "by_dataset": {}}
        for d in datasets:
            clean_d = float(_vec(pq, d, "clean", metric, qids[d]).mean())
            row = {"clean": clean_d}
            for p in perts:
                rr = robustness_row(pq[d]["clean"], pq[d][p], changed[d][p], metric)
                row[p] = {"score": float(rr["bozuk"]),
                          "retention": None if np.isnan(rr["koruma_değişen"]) else float(rr["koruma_değişen"]),
                          "changed_frac": float(rr["değişen_oran"]),
                          "diff_ci": [float(x) for x in rr["fark_değişen_ci"]] if rr["değişen_oran"] > 0 else None}
            entry["by_dataset"][d] = row
        entry["clean"] = float(np.mean([entry["by_dataset"][d]["clean"] for d in agg]))
        entry["by_pert"] = {}
        for p in perts:
            rets = [entry["by_dataset"][d][p]["retention"] for d in agg if entry["by_dataset"][d][p]["retention"] is not None]
            entry["by_pert"][p] = {"score": float(np.mean([entry["by_dataset"][d][p]["score"] for d in agg])),
                                   "retention": float(np.mean(rets)) if rets else None}
        vals = [v["retention"] for v in entry["by_pert"].values() if v["retention"] is not None]
        entry["avg_retention"] = float(np.mean(vals)) if vals else None
        entry["rank_score"] = entry["by_pert"][rank_pert]["score"]
        models.append(entry)

    models.sort(key=lambda m: -m["rank_score"])
    group = 1
    for i, m in enumerate(models):
        m["rank"] = i + 1
        if i > 0:
            prev = models[i - 1]
            diff, ci = balanced_paired_diff(
                [_vec(results[prev["short"]]["per_query"], d, rank_pert, metric, qids[d]) for d in agg],
                [_vec(results[m["short"]]["per_query"], d, rank_pert, metric, qids[d]) for d in agg],
                n_boot=n_boot, seed=seed)
            prev["vs_next"] = {"diff": diff, "ci": list(ci), "significant": ci[0] > 0}
            if ci[0] > 0:
                group += 1
        m["group"] = group
    clean_rank = {m["short"]: i + 1 for i, m in enumerate(sorted(models, key=lambda m: -m["clean"]))}
    for m in models:
        m["clean_rank"] = clean_rank[m["short"]]
    return models


def findings(models, perts):
    """Kahraman alanindaki cumleler icin veriden turetilen bulgular (sabit metin yok)."""
    dense = [m for m in models if m["family"] != "Sözcüksel"]
    out = {}
    # Hic degisen sorgusu olmayan bozulmalarda retention None'dir; bu bozulmalar bulgulara girmez (bos min() hatasi olmaz)
    scored = lambda p: [m for m in dense if m["by_pert"][p]["retention"] is not None]
    if dense:
        pairs = [(m, p) for p in perts for m in scored(p)]
        if pairs:
            worst = min(pairs, key=lambda x: x[0]["by_pert"][x[1]]["retention"])
            out["worst_drop"] = {"model": worst[0]["short"], "pert": worst[1],
                                 "retention": worst[0]["by_pert"][worst[1]]["retention"]}
        best_clean = min(dense, key=lambda m: m["clean_rank"])
        out["clean_winner"] = {"model": best_clean["short"], "clean_rank": best_clean["clean_rank"], "mobile_rank": best_clean["rank"]}
        out["mobile_winner"] = {"model": models[0]["short"], "clean_rank": models[0]["clean_rank"], "group": models[0]["group"],
                                "tied_with": [m["short"] for m in models[1:] if m["group"] == models[0]["group"]]}
        out["most_fragile"] = {p: min(scored(p), key=lambda m: m["by_pert"][p]["retention"])["short"] for p in perts if scored(p)}
        out["most_robust"] = {p: max(scored(p), key=lambda m: m["by_pert"][p]["retention"])["short"] for p in perts if scored(p)}
    lex = {m["short"]: m for m in models if m["family"] == "Sözcüksel"}
    if "bm25" in lex and "bm25-fold" in lex and "ascii_full" in perts:
        out["fold_effect"] = {"before": lex["bm25"]["by_pert"]["ascii_full"]["retention"],
                              "after": lex["bm25-fold"]["by_pert"]["ascii_full"]["retention"]}
    return out


def export_payload(models, perts, labels, descriptions, datasets_meta, fingerprint, dataset_repo,
                   example_text, example_outputs, failed, metric="ndcg@10", failed_notes=None, holdout=None):
    """Space ve dataset reposuna gidecek tek JSON. Benchmark metni ICERMEZ (ornek cumle bize ait).
    holdout: {veri_seti: neden} — siralamaya girmeyen setler; datasets_meta'ya in_ranking/holdout_reason eklenir."""
    failed_notes, holdout = failed_notes or {}, holdout or {}
    datasets_meta = [{**d, "in_ranking": d["name"] not in holdout, "holdout_reason": holdout.get(d["name"])}
                     for d in datasets_meta]
    fails = []
    for f in failed:
        reason = failed_notes.get(f["short"]) or (f.get("error") or "bilinmeyen hata").splitlines()[0][:160]
        fails.append({"short": f["short"], "model_id": f["model_id"], "reason": reason})
    return {
        "meta": {"fingerprint": fingerprint, "metric": metric, "dataset_repo": dataset_repo,
                 "perturbations": [{"name": p, "label": labels.get(p, p), "description": descriptions.get(p, "")} for p in perts],
                 "datasets": datasets_meta, "failed": fails,
                 "example": {"text": example_text, "outputs": example_outputs}},
        "models": models,
        "findings": findings(models, perts),
    }