"""
arzuhal_retrieval.py — Vatandas sorusu -> kanun maddesi retrieval benchmark'i (Pusula modulleri uzerine).

Kosullar (ayni qid, farkli sorgu metni):
  clean   : gundelik soru (vatandasin kendi cumlesi) — ANA kosul
  resmi   : ayni sorunun hukuki terimlerle hali (madde gorulmeden uretildi); yoksa gundelik kullanilir (degismemis sayilir)
  ascii_full, ascii_partial, upper, typo, colloquial, mobile : Pusula bozulmalari, gundelik soruya uygulanir
Etiket kumeleri: ana = E+K (etiket kontrolunden gecen), kati = yalniz E.
"""
from types import SimpleNamespace

import numpy as np
import pandas as pd

from pusula_eval import METRICS, paired_bootstrap


def doc_text(row):
    head = f"{row['law_title']} madde {row['article']}"
    title = (row.get("title") or "").strip()
    return f"{head} — {title}. {row['text']}" if title else f"{head}. {row['text']}"


def build_corpus(arts):
    """Mulga olmayan tum hedef kanun maddeleri (gecici/ek dahil). Mulga maddeler gercek bir aramada da cikmaz."""
    a = arts[~arts["repealed"]]
    return {r["doc_id"]: doc_text(r) for _, r in a.iterrows()}


def attach_labels(questions, review):
    """review: qid, dogru_mu (E/K/H). Eslesmeyen soru olmamali (eksik degerlendirme sessizce gecmesin)."""
    lab = dict(zip(review["qid"], review["dogru_mu"].str.strip().str.upper()))
    missing = sorted(set(questions["qid"]) - set(lab))
    assert not missing, f"Değerlendirmesi olmayan soru: {missing[:10]} ({len(missing)})"
    bad = {v for v in lab.values()} - {"E", "K", "H"}
    assert not bad, f"Geçersiz etiket: {bad}"
    q = questions.copy()
    q["etiket"] = q["qid"].map(lab)
    return q


def build_conditions(q, perturbations, perturb_fn, seed=0):
    """-> queries {kosul: {qid: metin}}, changed {kosul: set(qid)}, qrels. 'clean' = gundelik."""
    clean = dict(zip(q["qid"], q["gundelik"]))
    resmi = {qid: (r if isinstance(r, str) and r.strip() else clean[qid]) for qid, r in zip(q["qid"], q["resmi"])}
    queries = {"clean": clean, "resmi": resmi}
    for p in perturbations:
        if p != "clean":
            queries[p] = {qid: perturb_fn(t, qid, p, seed=seed) for qid, t in clean.items()}
    changed = {c: {qid for qid, t in qs.items() if t != clean[qid]} for c, qs in queries.items() if c != "clean"}
    qrels = {qid: {doc: 1} for qid, doc in zip(q["qid"], q["doc_id"])}
    return queries, changed, qrels


def as_sets(corpus, qrels, name="arzuhal"):
    """pusula_dense.benchmark_fingerprint'in bekledigi bicim."""
    return {name: SimpleNamespace(corpus=corpus, qrels=qrels)}


def law_hit_at_1(ranked, rels):
    """Ilk sonuc dogru KANUNDAN mi (madde yanlis olsa bile)? Model en azindan hukuk alanini bulabiliyor mu."""
    if not ranked:
        return 0.0
    gold_law = next(iter(rels)).split(":")[0]
    return float(ranked[0].split(":")[0] == gold_law)


ARZ_METRICS = {**METRICS, "kanun@1": law_hit_at_1}


def mean_over(pq_metric, qids):
    return float(np.mean([pq_metric[q] for q in qids])) if qids else float("nan")


def retention(pq, cond, changed, qids, metric):
    """Kosulun DEGISTIRDIGI sorgularda: bozuk/temiz ortalama orani (Pusula ile ayni tanim)."""
    sel = [q for q in qids if q in changed[cond]]
    if not sel:
        return float("nan"), 0
    c = mean_over(pq["clean"][metric], sel)
    return (mean_over(pq[cond][metric], sel) / c if c > 0 else float("nan")), len(sel)


def leaderboard(results, conditions, changed, subsets, metric="ndcg@10", rank_by="clean", n_boot=2000, seed=0):
    """results: {short: {"per_query": {kosul: {metrik: {qid: deger}}}, "spec": {...}}}
    subsets: {"ana": [qid...], "kati": [qid...]}. Siralama ana kumede rank_by kosuluna gore.
    Komsu modeller eslestirilmis bootstrap ile; %95 GA sifiri kapsiyorsa ayni grup."""
    main = subsets["ana"]
    rows = []
    for short, r in results.items():
        pq = r["per_query"]
        row = {"model": short, "params_m": r["spec"].get("params_m")}
        for c in ["clean"] + [c for c in conditions if c != "clean"]:
            row[c] = mean_over(pq[c][metric], main)
        for c in conditions:
            if c != "clean":
                row[f"koruma_{c}"], _ = retention(pq, c, changed, main, metric)
        for name, qids in subsets.items():
            if name != "ana":
                row[f"clean_{name}"] = mean_over(pq["clean"][metric], qids)
        row["kanun@1"] = mean_over(pq["clean"]["kanun@1"], main)
        row["recall@10"] = mean_over(pq["clean"]["recall@10"], main)
        rows.append(row)
    lb = pd.DataFrame(rows).sort_values(rank_by, ascending=False).reset_index(drop=True)
    group, groups, sig = 1, [], []
    for i in range(len(lb)):
        if i > 0:
            a = [results[lb.model[i - 1]]["per_query"][rank_by][metric][q] for q in main]
            b = [results[lb.model[i]]["per_query"][rank_by][metric][q] for q in main]
            _, ci = paired_bootstrap(b, a, n_boot=n_boot, seed=seed)   # a - b (ust - alt)
            s = ci[0] > 0
            sig.append(s)
            if s:
                group += 1
        groups.append(group)
    lb.insert(1, "grup", groups)
    lb["rank"] = range(1, len(lb) + 1)
    if "clean_kati" in lb:
        lb["rank_kati"] = lb["clean_kati"].rank(ascending=False, method="min").astype(int)
    return lb


def per_law(results, q, metric="ndcg@10", qids=None, cond="clean"):
    """Model x kanun tablosu (ana kume). Kanun adi varsa ad, yoksa numara."""
    by = "law_title" if "law_title" in q else "law"
    qids = set(qids or q["qid"])
    sub = q[q["qid"].isin(qids)]
    out = {}
    for short, r in results.items():
        m = r["per_query"][cond][metric]
        out[short] = {law: float(np.mean([m[x] for x in g["qid"]])) for law, g in sub.groupby(by)}
    return pd.DataFrame(out).T