#!/usr/bin/env python3
# /// script
# dependencies = ["torch", "transformers", "accelerate"]
# ///
"""Proper eval of sakthai-plus models on sakthai-bench-v2.

Uses tokenizer.apply_chat_template with tools= (identical to training rendering).
Env: MODEL, SAMPLE, BATCH, MAX_NEW, DUMP
"""
import os, json, re, time, collections, urllib.request
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

MODEL = os.environ.get("MODEL", "Nanthasit/sakthai-plus-1.5b")
BATCH = int(os.environ.get("BATCH", "1"))
SAMPLE = int(os.environ.get("SAMPLE", "50"))
MAX_NEW = int(os.environ.get("MAX_NEW", "128"))
DUMP = int(os.environ.get("DUMP", "3"))

URL = "https://huggingface.co/datasets/Nanthasit/sakthai-bench-v2/resolve/main/data/test.jsonl"
print(f"Loading {URL} ...", flush=True)
with urllib.request.urlopen(URL) as f:
    TEST = [json.loads(line) for line in f.read().decode().strip().splitlines()]
if SAMPLE:
    import random
    random.seed(42)
    TEST = random.sample(TEST, min(SAMPLE, len(TEST)))
print(f"Loaded {len(TEST)} test rows", flush=True)

def parse_tool_calls(text):
    calls = []
    for m in re.finditer(r'<tool_call>\s*(.*?)\s*</tool_call>', text, re.DOTALL):
        try:
            obj = json.loads(m.group(1))
            args = obj.get("arguments", {})
            if isinstance(args, str):
                try:
                    args = json.loads(args)
                except json.JSONDecodeError:
                    pass
            calls.append({"name": obj.get("name", ""), "arguments": args})
        except json.JSONDecodeError:
            pass
    return calls

def norm_args(a):
    if isinstance(a, str):
        try:
            a = json.loads(a)
        except json.JSONDecodeError:
            return str(a)
    if isinstance(a, dict):
        return {k: norm_args(v) for k, v in sorted(a.items()) if v is not None}
    return a

def norm_call(c):
    return {"name": c.get("name", ""), "arguments": norm_args(c.get("arguments", {}))}

def match_score(gold_calls, pred_calls):
    gs = {json.dumps(norm_call(c), sort_keys=True) for c in gold_calls}
    ps = {json.dumps(norm_call(c), sort_keys=True) for c in pred_calls}
    if not gs and not ps:
        return True, True
    correct = gs == ps
    args_ok = all(any(g["name"] == p["name"] and g["arguments"] == p["arguments"]
                      for p in pred_calls) for g in gold_calls) if pred_calls else False
    return correct, args_ok

device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"Device: {device}", flush=True)

print(f"Loading tokenizer {MODEL} ...", flush=True)
tokenizer = AutoTokenizer.from_pretrained(MODEL)
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "left"

print(f"Loading model {MODEL} ...", flush=True)
model = AutoModelForCausalLM.from_pretrained(
    MODEL,
    torch_dtype=torch.float16,
    device_map="auto" if device == "cuda" else None,
    low_cpu_mem_usage=True,
).to(device)
model.eval()
print("Model loaded", flush=True)

results = collections.defaultdict(lambda: {"sel": [], "args": [], "strict": []})
held_results = collections.defaultdict(lambda: {"sel": [], "args": [], "strict": []})

t0 = time.time()
for i in range(0, len(TEST), BATCH):
    batch = TEST[i:i + BATCH]
    prompts = []
    for row in batch:
        msgs = list(row.get("messages", []))
        while msgs and msgs[-1].get("role") in ("assistant", "tool"):
            msgs.pop()
        prompts.append(tokenizer.apply_chat_template(
            msgs, tools=row.get("tools") or None,
            tokenize=False, add_generation_prompt=True,
        ))

    inputs = tokenizer(prompts, return_tensors="pt", padding=True, truncation=True, max_length=2048).to(device)
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=MAX_NEW,
            do_sample=False,
            pad_token_id=tokenizer.pad_token_id,
        )

    for j, row in enumerate(batch):
        input_len = inputs["input_ids"].shape[1]
        gen = tokenizer.decode(outputs[j][input_len:], skip_special_tokens=True)
        pred_calls = parse_tool_calls(gen)
        gold_calls = row.get("gold_calls", [])
        category = row.get("category", "unknown")
        held = row.get("held_out_tool", False)

        correct, args_ok = match_score(gold_calls, pred_calls)
        target = held_results if held else results
        target[category]["sel"].append(correct)
        target[category]["args"].append(args_ok)
        target[category]["strict"].append(correct and args_ok)

        if DUMP and j < DUMP:
            print(f"\n--- Row {i + j} ({category}) ---", flush=True)
            print(f"GOLD: {gold_calls}", flush=True)
            print(f"PRED: {pred_calls}", flush=True)
            print(f"RAW: {gen[:200]!r}", flush=True)
            print(f"CORRECT: {correct}", flush=True)

    elapsed = time.time() - t0
    print(f"  [{i + len(batch)}/{len(TEST)}] {elapsed:.0f}s elapsed", flush=True)

print("\n" + "=" * 60)
print("RESULTS")
print("=" * 60)
all_sel, all_args, all_strict = [], [], []
for cat in sorted(results):
    r = results[cat]
    n = len(r["sel"])
    sel = sum(r["sel"]) / n * 100 if n else 0
    args = sum(r["args"]) / n * 100 if n else 0
    strict = sum(r["strict"]) / n * 100 if n else 0
    all_sel.extend(r["sel"]); all_args.extend(r["args"]); all_strict.extend(r["strict"])
    print(f"  {cat:20s}  selection={sel:.1f}  arguments={args:.1f}  strict={strict:.1f}  n={n}")

if all_sel:
    n = len(all_sel)
    print(f"\n  {'AVERAGE':20s}  selection={sum(all_sel)/n*100:.1f}  arguments={sum(all_args)/n*100:.1f}  strict={sum(all_strict)/n*100:.1f}  n={n}")

hs, ha, hst = [], [], []
for cat in sorted(held_results):
    r = held_results[cat]
    hs.extend(r["sel"]); ha.extend(r["args"]); hst.extend(r["strict"])
if hs:
    n = len(hs)
    print(f"\n  {'HELD AVG':20s}  selection={sum(hs)/n*100:.1f}  arguments={sum(ha)/n*100:.1f}  strict={sum(hst)/n*100:.1f}  n={n}")

print(f"\nTotal time: {time.time() - t0:.0f}s")