#!/usr/bin/env python3
"""Frisches v3-Testset (42 Aufgaben, nie im Training): Hardcore-Adapter gegen v3-Adapter, bf16, Greedy, GPU 0."""
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

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

BASE = f"{PLATTE}/models/graf_zahl/qwen_healed_merged"
# Name -> (Adapter, max_new_tokens). Hardcore bekommt das alte Limit (2500), v3 genug fuer 80 Zeichen.
ADAPTERS = {
    "A (hardcore)": (f"{PLATTE}/models/graf_zahl/qwen_graf_zahl_hardcore_lora", 2500),
    "B (v3)": (f"{PLATTE}/models/graf_zahl/qwen_graf_zahl_v3_plain_lora", 4500),
}
HELD = f"{PLATTE}/models/graf_zahl/v3/heldout_v3.json"
RESULTS = f"{PLATTE}/models/graf_zahl/v3/heldout_results_v3.json"
DATASET = "/mnt/models/graf_zahl/dataset_massive.jsonl"
SPACE = "␣"


def analyse(s, answer):
    pointers = re.findall(r"\[Position (\d+): (.)\]", answer)
    chars = "".join((" " if c == SPACE else c) for _, c in pointers)
    final = re.findall(r"Das sind (\d+)", answer)
    safety = re.findall(r"Zur Sicherheit nachgezählt:\s*(\d+)", answer)
    return {"endzahl": int(final[-1]) if final else None, "sicherheitszahl": int(safety[-1]) if safety else None,
            "pointer_exakt": chars == s, "letzte_position": int(pointers[-1][0]) if pointers else 0}


def main():
    held = json.load(open(HELD, encoding="utf-8"))
    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():
        if first:
            model = PeftModel.from_pretrained(model, path, adapter_name=name[0]); first = False
        else:
            model.load_adapter(path, adapter_name=name[0])
    model.eval()
    print(f"{len(held)} Aufgaben, Adapter {list(ADAPTERS)}", flush=True)

    results, t0 = [], time.time()
    for name, (_, max_new) in ADAPTERS.items():
        model.set_adapter(name[0])
        for h in held:
            s = h["text"]
            messages = [{"role": "system", "content": system}, {"role": "user", "content": h["prompt"]}]
            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, 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)
            a = analyse(s, answer)
            rec = {"adapter": name, "kategorie": h["kategorie"], "text": s, "laenge": len(s), "prompt": h["prompt"],
                   "tokens": len(new), "abgebrochen": int(new[-1]) != tok.eos_token_id, "richtig": a["endzahl"] == len(s),
                   "think_richtig": a["sicherheitszahl"] == len(s), "antwort": answer, **a}
            results.append(rec)
            print(f"[{name}] {h['kategorie'][:22]:22} len {len(s):2} -> {str(a['endzahl']):>4} "
                  f"{'ABGEBR.' if rec['abgebrochen'] else ('ok' if rec['richtig'] else 'FALSCH'):8} ({len(new)} Tok, {time.time() - t0:.0f}s)", flush=True)
            json.dump(results, open(RESULTS, "w", encoding="utf-8"), ensure_ascii=False)

    print("\n===== AUSWERTUNG (streng 'Das sind N' / Think-Zahl) =====")
    cats = list(dict.fromkeys(h["kategorie"] for h in held))
    print(f"{'Kategorie':26} {'n':>3} " + " ".join(f"{a:>20}" for a in ADAPTERS))
    for cat in cats + ["Gesamt"]:
        row = []
        for a in ADAPTERS:
            rs = [r for r in results if r["adapter"] == a and (cat == "Gesamt" or r["kategorie"] == cat)]
            row.append(f"{sum(r['richtig'] for r in rs):>3}/{len(rs):<3} / {sum(r['think_richtig'] for r in rs):>3}/{len(rs):<3}")
        n = len([h for h in held if cat == "Gesamt" or h["kategorie"] == cat])
        print(f"{cat:26} {n:>3} " + " ".join(f"{c:>20}" for c in row))
    print(f"\nErgebnisse: {RESULTS}")


if __name__ == "__main__":
    main()