#!/usr/bin/env python3
"""
Generation side-by-sides on held-out val prompts: base google/gemma-4-31B vs each
character's dedicated LoRA (r=32) vs the all-speaker ensemble LoRA (r=64).

One GPU, ONE base load. PEFT multi-adapter: PeftModel.from_pretrained with the
ensemble, then load_adapter() x10; set_adapter() swaps, disable_adapter() context
gives the raw base. Reuses the trainer's exact load_model/load_tokenizer chain
(train_ensemble_31b.py must sit next to this file's staged copy at /work/).

For each of the 10 characters: first 4 val records whose prompt has >= 3 context
lines; sample (temperature 0.8, top_p 0.9, max_new_tokens 120, stop at first
newline), seed deterministic per (context, config). Results appended (flushed
per record) to /work/eval_results/samples.jsonl as
    {char, ctx_tail, gold, base, dedicated, ensemble}

Run inside nvcr.io/nvidia/pytorch:26.05-py3 with transformers==5.5.0 + peft:
    python /work/gen_samples.py
"""
import json
import os
import sys
import zlib

sys.path.insert(0, "/work")
from train_ensemble_31b import load_model, load_tokenizer  # noqa: E402

MODEL = "google/gemma-4-31B"
SLUGS = ["spongebob", "patrick", "squidward", "mr_krabs", "plankton",
         "sandy", "mrs_puff", "karen", "gary", "pearl"]
ENSEMBLE_DIR = "/work/adapters/_ensemble/final"
ADAPTER_DIR = "/work/adapters/{slug}/final"
DATA_DIR = "/work/dataset"
OUT_PATH = "/work/eval_results/samples.jsonl"
N_PER_CHAR = 4
MIN_CTX_LINES = 3

GEN_ARGS = dict(do_sample=True, temperature=0.8, top_p=0.9, max_new_tokens=120)


def pick_records(slug):
    """First N val records whose prompt carries >= MIN_CTX_LINES context lines.
    The prompt's last \n-piece is the bare '<Character>:' cue, not context."""
    out = []
    with open(f"{DATA_DIR}/{slug}/val.jsonl") as f:
        for ln in f:
            r = json.loads(ln)
            if len(r["prompt"].split("\n")[:-1]) >= MIN_CTX_LINES:
                out.append(r)
                if len(out) == N_PER_CHAR:
                    break
    return out


def seed_for(prompt, config):
    """Deterministic per (context, config) so reruns reproduce exactly."""
    return zlib.crc32(f"{prompt}\x00{config}".encode()) & 0x7FFFFFFF


def main():
    import peft
    import torch
    from peft import PeftModel
    from transformers import StoppingCriteria, StoppingCriteriaList

    print(f"peft {peft.__version__}", flush=True)

    tok = load_tokenizer(MODEL)
    model = load_model(MODEL)
    model.config.get_text_config().use_cache = True  # generation wants the KV cache

    model = PeftModel.from_pretrained(model, ENSEMBLE_DIR, adapter_name="_ensemble")
    # the task plan leans on these three APIs — fail loudly if this peft lacks them
    for api in ("load_adapter", "set_adapter", "disable_adapter"):
        assert hasattr(model, api), f"installed peft {peft.__version__} lacks PeftModel.{api}"
    for slug in SLUGS:
        model.load_adapter(ADAPTER_DIR.format(slug=slug), adapter_name=slug)
        print(f"loaded adapter: {slug}", flush=True)
    model.to("cuda").eval()

    class StopOnNewline(StoppingCriteria):
        """Stop as soon as the generated text (decoded, batch=1) contains \n.
        Decoding the suffix each step is cheap at <=120 tokens and immune to the
        many tokenizations a newline can hide in (e.g. merged punctuation+\n)."""

        def __init__(self, prompt_len):
            self.prompt_len = prompt_len

        def __call__(self, input_ids, scores, **kw):
            return "\n" in tok.decode(input_ids[0, self.prompt_len:],
                                      skip_special_tokens=True)

    # gemma4's training forward refuses to run without mm_token_type_ids (the
    # collator injects zeros). Probe whether generate() needs it too, once.
    def probe_mm_mode():
        enc = tok("Hello", return_tensors="pt").to("cuda")
        for mode in ("plain", "mm_zeros"):
            kw = dict(**enc, max_new_tokens=2, do_sample=False,
                      pad_token_id=tok.pad_token_id)
            if mode == "mm_zeros":
                kw["mm_token_type_ids"] = torch.zeros_like(enc["input_ids"])
            try:
                with torch.inference_mode():
                    model.generate(**kw)
                print(f"generate() convention: {mode}", flush=True)
                return mode
            except Exception as e:
                print(f"probe {mode} failed: {type(e).__name__}: {e}", flush=True)
        raise RuntimeError("generate() works neither with nor without mm_token_type_ids")

    mm_mode = probe_mm_mode()

    def generate(prompt, config):
        enc = tok(prompt, add_special_tokens=True, return_tensors="pt").to("cuda")
        n = enc["input_ids"].shape[1]
        kw = dict(**enc, **GEN_ARGS,
                  stopping_criteria=StoppingCriteriaList([StopOnNewline(n)]),
                  pad_token_id=tok.pad_token_id)
        if mm_mode == "mm_zeros":
            kw["mm_token_type_ids"] = torch.zeros_like(enc["input_ids"])
        seed = seed_for(prompt, config)
        torch.manual_seed(seed)
        torch.cuda.manual_seed_all(seed)
        with torch.inference_mode():
            out = model.generate(**kw)
        text = tok.decode(out[0, n:], skip_special_tokens=True)
        return text.split("\n")[0].strip()  # post-trim: keep only the first line

    os.makedirs(os.path.dirname(OUT_PATH), exist_ok=True)
    n_done = 0
    with open(OUT_PATH, "w") as out:
        for slug in SLUGS:
            recs = pick_records(slug)
            print(f"\n=== {slug}: {len(recs)} prompts ===", flush=True)
            for i, r in enumerate(recs):
                prompt = r["prompt"]
                row = {
                    "char": slug,
                    "ctx_tail": prompt.split("\n")[:-1][-2:],
                    "gold": r["completion"].strip(),
                }
                with model.disable_adapter():
                    row["base"] = generate(prompt, "base")
                model.set_adapter(slug)
                row["dedicated"] = generate(prompt, "dedicated")
                model.set_adapter("_ensemble")
                row["ensemble"] = generate(prompt, "ensemble")
                out.write(json.dumps(row, ensure_ascii=False) + "\n")
                out.flush()
                n_done += 1
                print(f"  [{n_done}] {slug}#{i}  gold={row['gold'][:50]!r}\n"
                      f"        base={row['base'][:50]!r}\n"
                      f"   dedicated={row['dedicated'][:50]!r}\n"
                      f"    ensemble={row['ensemble'][:50]!r}", flush=True)

    print(f"\nALL DONE: {n_done} records -> {OUT_PATH}", flush=True)


if __name__ == "__main__":
    main()