"""
arzuhal_llm.py — LLM cevaplarindaki kanun atiflarinin denetimi (RAG'li / RAG'siz).

Her cevap icin: kac atif var, kaci gercek madde, kaci uydurma/mulga/eski kanun, dogru maddeye (sorunun kaynagi) atif var mi.
Uydurma orani YALNIZ korpustaki kanunlara yapilan atiflar uzerinden hesaplanir (korpusta olmayan kanun ≠ uydurma).
"""
import re

import numpy as np
import pandas as pd

from arzuhal_cite import audit, VERIFIABLE, unrecognized_law_mentions

SYSTEM_PROMPT = ("Sen Türk hukuku konusunda bilgili bir asistansın. Vatandaşın sorusunu kısa ve anlaşılır biçimde cevapla. "
                 "Cevabında dayandığın kanun maddelerini mutlaka 'Kanun adı m. madde numarası' biçiminde belirt "
                 "(ör. 'Türk Borçlar Kanunu m. 344'). En fazla 150 kelime yaz.")
RAG_SUFFIX = ("\n\nAşağıdaki kanun maddeleri soruyla ilgili olabilir. Cevabını bunlara dayandır; ilgisizse kullanma.\n\n{context}")
CONTEXT_CHARS = 900


def format_context(arts_rows, max_chars=CONTEXT_CHARS):
    parts = []
    for r in arts_rows:
        text = r["text"] if len(r["text"]) <= max_chars else r["text"][:max_chars].rsplit(" ", 1)[0] + " …"
        title = f" — {r['title']}" if r.get("title") else ""
        parts.append(f"[{r['law_title']} m. {r['article']}{title}]\n{text}")
    return "\n\n".join(parts)


def build_messages(question, context=None):
    user = question if context is None else question + RAG_SUFFIX.format(context=context)
    return [{"role": "system", "content": SYSTEM_PROMPT}, {"role": "user", "content": user}]


def clean_answer(raw):
    """<think> bloklarini (kapanmamis olani da) at."""
    s = re.sub(r"<think>.*?</think>", "", raw or "", flags=re.S)
    s = re.sub(r"<think>.*", "", s, flags=re.S)
    return s.strip()


def audit_answer(answer, extractor, gold_doc, name_map=None):
    """-> tek cevabin atif ozeti. gold_doc: '6098:344'.
    name_map: {kanun adi: kanun no | 'UYDURMA' | 'BELIRSIZ'} — elle gozden gecirilmis ad tablosu (arzuhal_names).
    Kanun no'lu adlar extractor'a extra_aliases ile verilmelidir; burada yalniz UYDURMA/BELIRSIZ sayilir."""
    gold_law, gold_art = gold_doc.split(":", 1)
    text = clean_answer(answer)
    rep = audit(text, extractor)
    names = unrecognized_law_mentions(text, extractor)
    nm = name_map or {}
    v = rep["verdicts"]
    by = lambda s: [x for x in v if x.status == s]
    cites = [(str(x.citation["law"]), x.citation["article"]) for x in v]
    return {
        "n_atif": rep["n"], "kanunsuz": rep["orphans"],
        **{f"n_{s}": len(by(s)) for s in ["var", "mulga_madde", "uydurma_madde", "eski_kanun", "bilinmeyen_kanun"]},
        "n_dogrulanabilir": sum(x.status in VERIFIABLE for x in v),
        "fikra_yanlis": sum(x.paragraph_ok is False for x in v),
        "alt_bolum": sum(x.note == "alt_bolum" for x in v),
        "dogru_madde": any(c == (gold_law, gold_art) for c in cites),
        "dogru_kanun": any(c[0] == gold_law for c in cites),
        "uydurmalar": "; ".join(x.citation["surface"] for x in by("uydurma_madde"))[:300],
        "eskiler": "; ".join(x.citation["surface"] for x in by("eski_kanun"))[:200],
        "taninmayan_kanunlar": " | ".join(names),
        "n_taninmayan": len(names),
        "n_uydurma_kanun": sum(nm.get(n) == "UYDURMA" for n in names),
        "n_belirsiz_kanun": sum(nm.get(n) == "BELIRSIZ" for n in names),
        "n_eslemesiz_kanun": sum(n not in nm for n in names),
        "uydurma_kanunlar": " | ".join(n for n in names if nm.get(n) == "UYDURMA"),
    }


def _boot_ci(num, den, n_boot=2000, seed=0):
    """Oran = sum(num)/sum(den), cevap duzeyinde yeniden ornekleme."""
    num, den = np.asarray(num, float), np.asarray(den, float)
    if den.sum() == 0:
        return float("nan"), (float("nan"), float("nan"))
    rng = np.random.default_rng(seed)
    idx = rng.integers(0, len(num), size=(n_boot, len(num)))
    d = den[idx].sum(1)
    boots = np.where(d > 0, num[idx].sum(1) / np.maximum(d, 1), np.nan)
    return float(num.sum() / den.sum()), (float(np.nanpercentile(boots, 2.5)), float(np.nanpercentile(boots, 97.5)))


def summarize(rec, n_boot=2000, seed=0):
    """rec: audit_answer kayitlari + 'model', 'kosul'. -> model x kosul tablosu (oranlar + %95 GA)."""
    rows = []
    for (m, c), g in rec.groupby(["model", "kosul"], sort=False):
        has_ver = (g["n_dogrulanabilir"] > 0).astype(float)
        has_fab = (g["n_uydurma_madde"] > 0).astype(float)
        r = {"model": m, "kosul": c, "cevap": len(g),
             "atifli_cevap": float((g["n_atif"] > 0).mean()),
             "ort_atif": float(g["n_atif"].mean())}
        r["uydurma_atif"], r["uydurma_atif_ci"] = _boot_ci(g["n_uydurma_madde"], g["n_dogrulanabilir"], n_boot, seed)
        r["mulga_atif"], _ = _boot_ci(g["n_mulga_madde"], g["n_dogrulanabilir"], n_boot, seed)
        r["uydurmali_cevap"], r["uydurmali_cevap_ci"] = _boot_ci(has_fab, has_ver, n_boot, seed)
        r["eski_kanunlu_cevap"] = float((g["n_eski_kanun"] > 0).mean())
        r["dogru_madde"], r["dogru_madde_ci"] = _boot_ci(g["dogru_madde"].astype(float), np.ones(len(g)), n_boot, seed)
        r["dogru_kanun"] = float(g["dogru_kanun"].mean())
        # Gercek ama ilgisiz madde: en az bir 'var' atfi olan cevaplarin kacinda dogru madde YOK
        has_var = (g["n_var"] > 0).astype(float)
        r["ilgisiz_gercek_madde"], r["ilgisiz_gercek_madde_ci"] = _boot_ci(has_var * (~g["dogru_madde"]).astype(float), has_var, n_boot, seed)
        r["kanunsuz_atifli_cevap"] = float((g["kanunsuz"] > 0).mean())
        r["taninmayan_kanunlu_cevap"] = float((g["n_taninmayan"] > 0).mean())
        r["uydurma_kanunlu_cevap"], r["uydurma_kanunlu_cevap_ci"] = _boot_ci((g["n_uydurma_kanun"] > 0).astype(float), np.ones(len(g)), n_boot, seed)
        r["belirsiz_kanunlu_cevap"] = float((g["n_belirsiz_kanun"] > 0).mean())
        r["eslemesiz_ad"] = int(g["n_eslemesiz_kanun"].sum())
        # Herhangi bir uydurma: olmayan madde YA DA (elle dogrulanmis) olmayan kanun adi — tum cevaplar icinde
        bad = ((g["n_uydurma_madde"] > 0) | (g["n_uydurma_kanun"] > 0)).astype(float)
        r["uydurmali_cevap_tum"], r["uydurmali_cevap_tum_ci"] = _boot_ci(bad, np.ones(len(g)), n_boot, seed)
        r["alt_bolum"] = int(g["alt_bolum"].sum())
        r["fikra_yanlis"] = int(g["fikra_yanlis"].sum())
        rows.append(r)
    return pd.DataFrame(rows)


def stratified_sample(q, n, seed=0, by="law"):
    """Kanun payina orantili orneklem (her kanundan en az 1)."""
    rng = np.random.default_rng(seed)
    share = q[by].value_counts(normalize=True)
    k = (share * n).round().astype(int).clip(lower=1)
    parts = []
    for law, g in q.groupby(by):
        parts.append(g.iloc[rng.permutation(len(g))[:min(len(g), k[law])]])
    return pd.concat(parts).sort_values("qid").reset_index(drop=True)