#!/usr/bin/env python3
"""Generalisierungs-Test (Out-of-Distribution) fuer den Hardcore-Adapter, bf16, Greedy, GPU 0.

A: Zufall und Sonderzeichen | B: Ueberlaenge (> 45 Zeichen) | C: Code | D: abweichende Prompts.
Richtig = 'Das sind N' == Laenge des Strings. Zusaetzlich: Pointer-Liste, Spreizung, Abbruch am Tokenlimit.
"""
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 random
import re
import string
import time

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

BASE = f"{PLATTE}/models/graf_zahl/qwen_healed_merged"
ADAPTER = 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/generalization_results_v3.json"
MAX_NEW_TOKENS = 4500


def rnd(n, seed, alphabet):
    rng = random.Random(seed)
    return "".join(rng.choice(alphabet) for _ in range(n))


ALNUM = string.ascii_letters + string.digits
LETTERS = string.ascii_letters
SYM = string.ascii_letters + string.digits + "!#$%&*+-=?_"

STRING_Q = "Wie viele Zeichen hat der String '{s}'?"
WORD_Q = "Wie viele Zeichen hat das Wort '{s}'?"

TESTS = []
for s in ["aB3!x_9P", "---===+++", "3C:5A:B4:9F:12:E7", "Xk9#mL2$pQ7", "@@@###$$$%%%", "192.168.100.254", "Ünïcödé-Tëst"]:
    TESTS.append(("A Zufall/Sonderzeichen", s, STRING_Q.format(s=s)))
for s, q in [(rnd(55, 1, ALNUM), STRING_Q),
             ("Rindfleischetikettierungsüberwachungsaufgabenübertragungsgesetz", WORD_Q),
             ("Donaudampfschifffahrtsgesellschaftskapitänsmütze", WORD_Q),
             (rnd(60, 2, LETTERS), STRING_Q),
             ("Kraftfahrzeughaftpflichtversicherungsprämienberechnungsstelle", WORD_Q),
             (rnd(72, 3, SYM), STRING_Q),
             (rnd(80, 4, ALNUM), STRING_Q)]:
    assert len(s) > 45
    TESTS.append(("B Ueberlaenge", s, q.format(s=s)))
for s in ["def count(x): return len(x)", 'print("Hello, World!")', "for i in range(10):", "SELECT * FROM users;",
          '<div class="box">Hi</div>', "arr[i] = arr[j] + 1;"]:
    TESTS.append(("C Code", s, STRING_Q.format(s=s)))
for s, q in [("Apfelbaum", "Hey Graf, wie lang ist eigentlich das Wort 'Apfelbaum'?"),
             ("Kühlschrank", "Zähl mal bitte 'Kühlschrank' durch"),
             ("Zuckerwatte", "Ich brauche die Anzahl der Buchstaben von: Zuckerwatte"),
             ("Wassermelone", "Wieviele Zeichen? 'Wassermelone'"),
             ("Schifffahrtskapitän", "Kannst du mir sagen, aus wie vielen Buchstaben 'Schifffahrtskapitän' besteht?"),
             ("Kaffeetasse", "How many characters are in the word 'Kaffeetasse'?"),
             ("Bettlaken", "Länge von Bettlaken?"),
             ("Mississippi", "Mein Sohn fragt mich, wie viele Buchstaben das Wort 'Mississippi' hat. Kannst du helfen?")]:
    TESTS.append(("D Prompt-Abweichung", s, q))


def analyse(s, answer):
    pointers = re.findall(r"\[Position (\d+): (.)\]", answer)
    chars = "".join((" " if c == "\u2423" 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)
    spread = re.search(r"^Spreizung: (.*)$", answer, re.MULTILINE)
    return {
        "endzahl": int(final[-1]) if final else None,
        "sicherheitszahl": int(safety[-1]) if safety else None,
        "pointer_string": chars,
        "pointer_exakt": chars == s,
        "spreizung_exakt": None if not spread else spread.group(1) == " - ".join("\u2423" if c == " " else c for c in s),
        "letzte_position": int(pointers[-1][0]) if pointers else 0,
        "hat_think_block": "</think>" in answer,
        "ah_ah_ah": answer.count("Ah ah ah"),
    }


def main():
    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})
    model = PeftModel.from_pretrained(model, ADAPTER)
    model.eval()
    print(f"Modell geladen ({next(model.parameters()).dtype}), {len(TESTS)} Tests, max_new_tokens={MAX_NEW_TOKENS}", flush=True)

    results, t0 = [], time.time()
    for kat, s, prompt in TESTS:
        messages = [{"role": "system", "content": system}, {"role": "user", "content": 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_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]:]
        truncated = int(new[-1]) != tok.eos_token_id
        answer = tok.decode(new, skip_special_tokens=True)
        a = analyse(s, answer)
        rec = {"kategorie": kat, "text": s, "laenge": len(s), "prompt": prompt, "tokens": len(new),
               "abgebrochen": truncated, "richtig": a["endzahl"] == len(s), "antwort": answer, **a}
        results.append(rec)
        flag = "ABGEBROCHEN" if truncated else ("ok " if rec["richtig"] else "FALSCH")
        print(f"[{kat:22}] len {len(s):2} -> {str(a['endzahl']):>4} {flag:11} Ptr {'ok' if a['pointer_exakt'] else 'X '} "
              f"({len(new)} Tok, {time.time() - t0:.0f}s)  {s[:40]!r}", flush=True)
        json.dump(results, open(RESULTS, "w", encoding="utf-8"), ensure_ascii=False)

    print("\n===== AUSWERTUNG =====")
    print(f"{'Kategorie':24} {'n':>2} {'richtig':>9} {'Pointer':>9} {'Spreizung':>10} {'abgebr.':>8}")
    for kat in dict.fromkeys(r["kategorie"] for r in results):
        rs = [r for r in results if r["kategorie"] == kat]
        sp = [r for r in rs if r["spreizung_exakt"] is not None]
        print(f"{kat:24} {len(rs):>2} {sum(r['richtig'] for r in rs):>4}/{len(rs):<4} {sum(r['pointer_exakt'] for r in rs):>4}/{len(rs):<4} "
              f"{sum(bool(r['spreizung_exakt']) for r in sp):>4}/{len(sp):<5} {sum(r['abgebrochen'] for r in rs):>5}")
    print(f"{'Gesamt':24} {len(results):>2} {sum(r['richtig'] for r in results):>4}/{len(results):<4}")
    print(f"\nErgebnisse: {RESULTS}")


if __name__ == "__main__":
    main()