"""
pusula_eval.py — Bilgi erisimi metrikleri ve dayaniklilik karsilastirmasi.

Metrikler pytrec_eval (BEIR/MTEB'in kullandigi) ile birebir dogrulandi:
  nDCG@k dogrusal kazanc (gain = ilgi skoru), Recall@k, MRR@k.
Bir run: {qid: {doc_id: skor}}. Skor esitliginde dokuman kimligine gore azalan siralama (trec_eval kurali).
"""
import math

import numpy as np


def _ranked(doc_scores, k):
    return [d for d, _ in sorted(doc_scores.items(), key=lambda x: (x[1], x[0]), reverse=True)[:k]]


def ndcg_at_k(ranked, rels, k):
    dcg = sum(rels.get(d, 0) / math.log2(i + 2) for i, d in enumerate(ranked[:k]) if rels.get(d, 0) > 0)
    ideal = sorted((r for r in rels.values() if r > 0), reverse=True)[:k]
    idcg = sum(r / math.log2(i + 2) for i, r in enumerate(ideal))
    return dcg / idcg if idcg > 0 else 0.0


def recall_at_k(ranked, rels, k):
    relevant = {d for d, r in rels.items() if r > 0}
    return len(relevant & set(ranked[:k])) / len(relevant) if relevant else 0.0


def mrr_at_k(ranked, rels, k):
    for i, d in enumerate(ranked[:k]):
        if rels.get(d, 0) > 0:
            return 1.0 / (i + 1)
    return 0.0


METRICS = {
    "ndcg@10": lambda r, q: ndcg_at_k(r, q, 10),
    "recall@10": lambda r, q: recall_at_k(r, q, 10),
    "recall@100": lambda r, q: recall_at_k(r, q, 100),
    "mrr@10": lambda r, q: mrr_at_k(r, q, 10),
}


def evaluate(run, qrels, metrics=METRICS):
    """Sorgu basina metrikler: {metrik: {qid: deger}}. Run'da olmayan sorgu 0 alir (sessizce dusmez)."""
    out = {m: {} for m in metrics}
    for qid, rels in qrels.items():
        ranked = _ranked(run.get(qid, {}), 100)
        for m, fn in metrics.items():
            out[m][qid] = fn(ranked, rels)
    return out


def paired_bootstrap(a, b, n_boot=2000, seed=0):
    """Ayni sorgularda iki kosulun ortalama farki (b - a) ve %95 guven araligi."""
    a, b = np.asarray(a, float), np.asarray(b, float)
    diff = b - a
    if len(diff) == 0:
        return float("nan"), (float("nan"), float("nan"))
    rng = np.random.default_rng(seed)
    idx = rng.integers(0, len(diff), size=(n_boot, len(diff)))
    boots = diff[idx].mean(axis=1)
    return float(diff.mean()), (float(np.percentile(boots, 2.5)), float(np.percentile(boots, 97.5)))


def robustness_row(clean_scores, pert_scores, changed_qids, metric="ndcg@10"):
    """Bir bozulma icin: tum sorgularda ve SADECE degisen sorgularda koruma orani + fark CI."""
    qids = sorted(clean_scores[metric])
    c = np.array([clean_scores[metric][q] for q in qids])
    p = np.array([pert_scores[metric][q] for q in qids])
    mask = np.array([q in changed_qids for q in qids])
    d_all, ci_all = paired_bootstrap(c, p)
    d_chg, ci_chg = paired_bootstrap(c[mask], p[mask])
    return {
        "temiz": c.mean(), "bozuk": p.mean(),
        "koruma": p.mean() / c.mean() if c.mean() > 0 else float("nan"),
        "fark": d_all, "fark_ci": ci_all,
        "değişen_oran": mask.mean(),
        "koruma_değişen": p[mask].mean() / c[mask].mean() if mask.any() and c[mask].mean() > 0 else float("nan"),
        "fark_değişen": d_chg, "fark_değişen_ci": ci_chg,
    }