#!/usr/bin/env python3
"""A/B-Test: Hardcore-Adapter gegen v3-Adapter (plain).

bf16, transformers + peft, Greedy, dieselben 50 Woerter in 3 Kategorien. Genauigkeit =
ausgegebene Endzahl == Zeichenlaenge (zusaetzlich: Pointer-Liste zeichengenau).
"""
import os
os.environ["CUDA_VISIBLE_DEVICES"] = "0"

PLATTE = "/home/david/Schreibtisch/Platte"
os.environ.setdefault("HF_HOME", f"{PLATTE}/cache/huggingface")
os.environ.setdefault("HF_HUB_CACHE", f"{PLATTE}/cache/huggingface/hub")

import json
import re
import time
from itertools import groupby

import torch
from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer

BASE = f"{PLATTE}/models/graf_zahl/qwen_healed_merged"
ADAPTERS = {
    "A (hardcore)": f"{PLATTE}/models/graf_zahl/qwen_graf_zahl_hardcore_lora",
    "B (v3)": f"{PLATTE}/models/graf_zahl/qwen_graf_zahl_v3_plain_lora",
}
DATASET = "/mnt/models/graf_zahl/dataset_massive.jsonl"
RESULTS = f"{PLATTE}/models/graf_zahl/ab_test_results_v3.json"
MAX_NEW_TOKENS = 2000

CATS = {
    "1 Normal": ["Apfelkuchen", "Schreibtisch", "Fensterbank", "Gartenzaun", "Blumentopf", "Regenschirm",
                 "Bleistift", "Kühlschrank", "Fahrkarte", "Zahnbürste", "Wörterbuch", "Briefkasten",
                 "Handtuch", "Geburtstag", "Weihnachtsbaum"],
    "2 Doppelt": ["Kaffeemaschine", "Bettdecke", "Wasserball", "Kartoffelsalat", "Teddybär", "Schnellzug",
                  "Sommerkleid", "Wollsocke", "Sonnenblume", "Rollkoffer", "Lippenstift", "Himmelbett",
                  "Schwimmbad", "Hammerschlag", "Mittagessen", "Brillenglas", "Zuckerrübe", "Waffeleisen",
                  "Klassenzimmer", "Tannenzapfen"],
    "3 Dreifach": ["Brennnessel", "Schifffahrt", "Sauerstoffflasche", "Donaudampfschifffahrt", "Betttuch",
                   "Stillleben", "Kaffeeersatz", "Seeelefant", "Balletttänzer", "Schwimmmeister",
                   "Flussschifffahrt", "Nussschale", "Kunststoffflasche", "Schlammmasse", "Fußballliga"],
}


def max_run(w):
    return max(len(list(g)) for _, g in groupby(w.lower()))


def extract(answer):
    pointers = re.findall(r"\[Position (\d+): (.)\]", answer)
    final = re.findall(r"Das sind (\d+)", answer)
    spread = re.search(r"^Spreizung: (.+)$", answer, re.MULTILINE)
    spread = "".join(c.strip() for c in spread.group(1).split(" - ")) if spread else None
    return "".join(c for _, c in pointers), (int(final[-1]) if final else None), spread


def main():
    assert sum(len(v) for v in CATS.values()) == 50
    assert all(max_run(w) == 1 for w in CATS["1 Normal"])
    assert all(max_run(w) == 2 for w in CATS["2 Doppelt"])
    assert all(max_run(w) >= 3 for w in CATS["3 Dreifach"])

    system = json.loads(open(DATASET, encoding="utf-8").readline())["messages"][0]["content"]
    tok = AutoTokenizer.from_pretrained(BASE)
    model = AutoModelForCausalLM.from_pretrained(BASE, dtype=torch.bfloat16, device_map={"": 0})
    first = True
    for name, path in ADAPTERS.items():
        aid = name[0]
        if first:
            model = PeftModel.from_pretrained(model, path, adapter_name=aid)
            first = False
        else:
            model.load_adapter(path, adapter_name=aid)
    model.eval()
    print(f"Modell geladen ({next(model.parameters()).dtype}), Adapter: {list(model.peft_config)}, "
          f"VRAM {torch.cuda.memory_allocated() / 1e9:.1f} GB", flush=True)

    results = []
    t0 = time.time()
    for name in ADAPTERS:
        model.set_adapter(name[0])
        print(f"\n===== Durchlauf {name} =====", flush=True)
        for cat, words in CATS.items():
            for w in words:
                messages = [{"role": "system", "content": system},
                            {"role": "user", "content": f"Wie viele Zeichen hat das Wort '{w}'?"}]
                text = tok.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
                inputs = tok(text, return_tensors="pt", add_special_tokens=False).to("cuda")
                with torch.no_grad():
                    out = model.generate(**inputs, max_new_tokens=MAX_NEW_TOKENS, do_sample=False,
                                         temperature=0.0, top_p=1.0,
                                         eos_token_id=tok.eos_token_id, pad_token_id=tok.pad_token_id)
                new = out[0][inputs["input_ids"].shape[1]:]
                answer = tok.decode(new, skip_special_tokens=True)
                pointers, final, spread = extract(answer)
                rec = {"adapter": name, "kategorie": cat, "wort": w, "soll": len(w), "endzahl": final,
                       "richtig": final == len(w), "pointer_string": pointers,
                       "pointer_exakt": pointers == w, "spreizung": spread,
                       "spreizung_exakt": None if spread is None else spread == w, "tokens": len(new),
                       "tokenisierung": tok.tokenize(w), "antwort": answer}
                results.append(rec)
                print(f"[{name}] {cat:10} {w:22} soll {len(w):2} -> {str(final):>4} "
                      f"{'ok ' if rec['richtig'] else 'FALSCH'}  ({time.time() - t0:.0f}s)", flush=True)
                json.dump(results, open(RESULTS, "w", encoding="utf-8"), ensure_ascii=False)

    print("\n===== AUSWERTUNG =====")
    print(f"{'Kategorie':12} {'n':>3}  " + "  ".join(f"{a:>22}" for a in ADAPTERS))
    for cat in list(CATS) + ["Gesamt"]:
        row = []
        for a in ADAPTERS:
            rs = [r for r in results if r["adapter"] == a and (cat == "Gesamt" or r["kategorie"] == cat)]
            ok = sum(r["richtig"] for r in rs)
            px = sum(r["pointer_exakt"] for r in rs)
            row.append(f"{ok:2}/{len(rs):2} = {ok / len(rs) * 100:5.1f} % (Ptr {px / len(rs) * 100:3.0f} %)")
        n = len(CATS[cat]) if cat in CATS else 50
        print(f"{cat:12} {n:>3}  " + "  ".join(f"{c:>22}" for c in row))
    print("\nSpreizung zeichengenau (nur Adapter mit Spreizungs-Format):")
    for a in ADAPTERS:
        rs = [r for r in results if r["adapter"] == a]
        sp = [r for r in rs if r["spreizung_exakt"] is not None]
        print(f"  {a}: {sum(r['spreizung_exakt'] for r in sp)}/{len(sp)} Antworten mit Spreizung exakt")
    print(f"\nErgebnisse: {RESULTS}")


if __name__ == "__main__":
    main()