"""
JustGRPO reproduction script (single-GPU, no distributed).
Adapted from the official JustGRPO repo (eval.py, generate.py, grader.py, parser.py).

Claims addressed:
  C1: JustGRPO 89.1% on GSM8K (gen_length=256, steps=256, block_length=32)
  C2: Retains parallel decoding + improves reasoning on math (MATH-500) and code (HumanEval/MBPP)
  C3: Arbitrary order (AO) limits reasoning potential vs AR order (Pass@k / solution coverage)

Run on a single GPU (no torchrun needed). Supports --max_examples for budget control.
Results saved as JSON to --output.
"""
import os
import sys
import re
import ast
import json
import gzip
import argparse
import time
import random
from pathlib import Path

import torch
import torch.nn.functional as F
from tqdm import tqdm
from datasets import load_dataset
from transformers import AutoModel, AutoTokenizer

# Make the JustGRPO package importable
HERE = Path(__file__).resolve().parent
sys.path.insert(0, str(HERE / "JustGRPO"))

from utils.generate import generate, add_gumbel_noise, get_num_transfer_tokens
from utils.grader import math_equal
from utils.parser import extract_answer, parse_ground_truth
from data.math import extract_answer_gsm8k, collate_fn_gsm8k, collate_fn_math

DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
MASK_ID = 126336


# ---------------- LoRA merge (from eval.py) ----------------
def merge_lora(model, adapter_dir):
    from safetensors.torch import load_file
    with open(os.path.join(adapter_dir, "adapter_config.json")) as f:
        cfg = json.load(f)
    scaling = cfg["lora_alpha"] / cfg["r"]
    state = load_file(os.path.join(adapter_dir, "adapter_model.safetensors"))
    for key in [k for k in state if ".lora_A." in k]:
        target = key.split(".lora_A.")[0].removeprefix("base_model.model.")
        weight = model.get_submodule(target).weight
        delta = (state[key.replace(".lora_A.", ".lora_B.")].float() @ state[key].float()) * scaling
        weight.data += delta.to(weight.dtype)


def load_model(ckpt_path, base_path="GSAI-ML/LLaDA-8B-Instruct"):
    tokenizer = AutoTokenizer.from_pretrained(base_path, trust_remote_code=True)
    if os.path.exists(os.path.join(ckpt_path, "adapter_config.json")):
        model = AutoModel.from_pretrained(base_path, trust_remote_code=True, torch_dtype=torch.bfloat16)
        merge_lora(model, ckpt_path)
    else:
        model = AutoModel.from_pretrained(ckpt_path, trust_remote_code=True, torch_dtype=torch.bfloat16)
    model.eval().requires_grad_(False).to(DEVICE)
    return model, tokenizer


# ---------------- Math eval (GSM8K / MATH-500) ----------------
def eval_math(model, tokenizer, task, gen_length, steps, block_length, max_examples, temperature=0.0, seed=113):
    if task == "gsm8k":
        ds = load_dataset("gsm8k", "main", split="test")
        collate_fn = collate_fn_gsm8k
        problems = [ex["question"] for ex in ds]
        answers = [ex["answer"] for ex in ds]
        extract_gt = extract_answer_gsm8k
    else:
        ds = load_dataset("ankner/math-500", split="test")
        instruct = r"(Please put the final answer in \boxed{} tag, i.e. $\boxed{answer here}$)"
        problems = [ex["problem"] + instruct for ex in ds]
        answers = [ex["solution"] for ex in ds]
        extract_gt = lambda a: extract_answer(a)

    n = len(problems)
    if max_examples and max_examples < n:
        # deterministic subset
        rng = random.Random(seed)
        idx = rng.sample(range(n), max_examples)
        problems = [problems[i] for i in idx]
        answers = [answers[i] for i in idx]

    correct = 0
    total = 0
    t0 = time.time()
    details = []
    for i in tqdm(range(len(problems)), desc=f"eval {task}", disable=True):
        p = problems[i]
        msgs = [[{"role": "user", "content": p}]]
        prompt_text = tokenizer.apply_chat_template(msgs, add_generation_prompt=True, tokenize=False)
        prompt_ids = tokenizer(prompt_text, return_tensors="pt")["input_ids"].to(DEVICE)
        gen_ids = generate(model=model, prompt=prompt_ids, steps=steps, gen_length=gen_length,
                           block_length=block_length, temperature=temperature)
        resp = tokenizer.batch_decode(gen_ids[:, prompt_ids.shape[1]:], skip_special_tokens=True)[0]
        gt = extract_gt(answers[i])
        pred = extract_answer(resp) if task != "gsm8k" else extract_answer(resp)
        ok = math_equal(gt, pred, timeout=(task != "gsm8k"))
        correct += int(ok)
        total += 1
        if (i + 1) % 10 == 0:
            elapsed = time.time() - t0
            print(f"  [{task}] {i+1}/{len(problems)} acc={correct/total*100:.2f}% elapsed={elapsed:.0f}s", flush=True)
        if i < 5:
            details.append({"idx": i, "correct": bool(ok), "gt": str(gt)[:80], "pred": str(pred)[:80]})

    acc = correct / total
    elapsed = time.time() - t0
    print(f"\n{task} Accuracy: {correct}/{total} = {acc*100:.2f}%  ({elapsed:.0f}s)", flush=True)
    summary = {"task": task, "accuracy": acc, "correct": correct, "total": total,
            "gen_length": gen_length, "steps": steps, "block_length": block_length,
            "temperature": temperature, "elapsed_s": elapsed, "details": details}
    print(f"RESULT_MARKER {task}: {json.dumps(summary)}", flush=True)
    return summary


# ---------------- Code eval (HumanEval / MBPP) ----------------
def _format_humaneval(problems):
    formatted = {}
    for tid, p in problems.items():
        formatted[tid] = dict(p)
        formatted[tid]["prompt"] = (
            "You are an expert Python programmer. Your task is to complete the "
            f"implementation of a function named `{p['entry_point']}`.\n\n"
            f"Here is the function to complete:\n```python\n{p['prompt'].rstrip()}\n```\n"
        )
    return formatted


def _format_mbpp_prompt(ex):
    func_name = ex["test_list"][0].split(" ")[1].split("(")[0]
    tests_str = "\n".join(f"    {t}" for t in ex["test_list"])
    try:
        tree = ast.parse(ex["test_list"][0].strip())
        n_args = 0
        for node in ast.walk(tree):
            if isinstance(node, ast.Call) and getattr(node.func, "id", "") == func_name:
                n_args = len(node.args)
                break
    except Exception:
        n_args = 2
    params = ", ".join(f"input_param_{i + 1}" for i in range(n_args))
    return (
        "You are an expert Python programmer. Your task is to complete the "
        f"implementation of a function named `{func_name}`.\n\n"
        f"** TARGET FUNCTION **\n{ex['text']}\n\n"
        "** UNIT TESTS **\n"
        f"Your code should pass unit tests like:\n{tests_str}\n\n"
        "Here is the function to complete:\n"
        f"```python\ndef {func_name}({params}):\n"
        f"    \"\"\"{ex['text']}\n    \"\"\"\n```\n"
    )


def _load_code_tasks(task, max_examples):
    from utils.code_exec import read_problems, stream_jsonl
    if task == "humaneval":
        probs = _format_humaneval(read_problems(str(HERE / "JustGRPO/datasets/HumanEval.jsonl.gz")))
        items = list(probs.items())
    else:
        examples = list(stream_jsonl(str(HERE / "JustGRPO/datasets/mbpp.jsonl")))
        probs = {ex["task_id"]: {"task_id": ex["task_id"], "prompt": _format_mbpp_prompt(ex)}
                 for ex in examples[10:510]}
        items = list(probs.items())
    if max_examples and max_examples < len(items):
        items = items[:max_examples]
    return probs, items


def eval_code(model, tokenizer, task, gen_length, steps, block_length, max_examples):
    from utils.code_exec import write_jsonl, evaluate_functional_correctness, stream_jsonl
    probs, items = _load_code_tasks(task, max_examples)
    samples = []
    t0 = time.time()
    for tid, _ in tqdm(items, desc=f"eval {task}"):
        prompt = probs[tid]["prompt"]
        msgs = [[{"role": "user", "content": prompt}]]
        prompt_text = tokenizer.apply_chat_template(msgs, add_generation_prompt=True, tokenize=False)
        prompt_ids = tokenizer(prompt_text, return_tensors="pt")["input_ids"].to(DEVICE)
        gen_ids = generate(model=model, prompt=prompt_ids, steps=steps, gen_length=gen_length,
                           block_length=block_length, temperature=0.0)
        completion = tokenizer.batch_decode(gen_ids[:, prompt_ids.shape[1]:], skip_special_tokens=True)[0]
        row = {"task_id": tid, "completion": completion}
        if task == "mbpp":
            row["prompt"] = prompt
        samples.append(row)

    out_dir = HERE / "code_results"
    out_dir.mkdir(exist_ok=True)
    merged_path = str(out_dir / f"{task}_samples.jsonl")
    write_jsonl(merged_path, samples)
    problem_file = str(HERE / "JustGRPO/datasets/HumanEval.jsonl.gz") if task == "humaneval" \
        else str(HERE / "JustGRPO/datasets/mbpp_test.jsonl")
    result = evaluate_functional_correctness(
        input_file=merged_path, problem_file=problem_file,
        is_mbpp=(task == "mbpp"), n_workers=8, timeout=3.0, k=(1,),
    )
    elapsed = time.time() - t0
    print(f"\n{task}: {result}  ({elapsed:.0f}s)")
    return {"task": task, "metrics": result, "pass@1": result.get("pass@1"),
            "elapsed_s": elapsed, "n_samples": len(samples)}


# ---------------- C3: Pass@k (AR vs AO) ----------------
def eval_pass_at_k(model, tokenizer, task, gen_length, steps, n_problems, k, temperature, seed=113):
    """Compare AR order (block_length=1) vs Arbitrary Order (block_length=gen_length)."""
    if task == "gsm8k":
        ds = load_dataset("gsm8k", "main", split="test")
        problems = [ex["question"] for ex in ds]
        answers = [ex["answer"] for ex in ds]
        extract_gt = extract_answer_gsm8k
        use_timeout = False
    else:
        ds = load_dataset("ankner/math-500", split="test")
        instruct = r"(Please put the final answer in \boxed{} tag, i.e. $\boxed{answer here}$)"
        problems = [ex["problem"] + instruct for ex in ds]
        answers = [ex["solution"] for ex in ds]
        extract_gt = lambda a: extract_answer(a)
        use_timeout = True

    rng = random.Random(seed)
    idx = rng.sample(range(len(problems)), min(n_problems, len(problems)))
    problems = [problems[i] for i in idx]
    answers = [answers[i] for i in idx]

    modes = {
        "AR": {"block_length": 1, "steps": gen_length},        # strictly left-to-right (1 token/step)
        "AO": {"block_length": gen_length, "steps": steps},     # arbitrary order (full parallel, low-conf remasking)
    }

    results = {}
    per_problem = {}  # mode -> list of 0/1 per problem
    for mode_name, cfg in modes.items():
        t0 = time.time()
        solved_list = []  # per problem: 1 if any of k samples correct
        n_correct_samples = 0
        n_total_samples = 0
        for i in range(len(problems)):
            p = problems[i]
            gt = extract_gt(answers[i])
            msgs = [[{"role": "user", "content": p}]]
            prompt_text = tokenizer.apply_chat_template(msgs, add_generation_prompt=True, tokenize=False)
            prompt_ids = tokenizer(prompt_text, return_tensors="pt")["input_ids"].to(DEVICE)
            # generate k samples (temperature>0 for diversity)
            prompt_batch = prompt_ids.repeat(k, 1)
            gen_ids = generate(model=model, prompt=prompt_batch, steps=cfg["steps"],
                               gen_length=gen_length, block_length=cfg["block_length"],
                               temperature=temperature)
            resps = tokenizer.batch_decode(gen_ids[:, prompt_ids.shape[1]:], skip_special_tokens=True)
            solved = False
            for resp in resps:
                pred = extract_answer(resp)
                ok = math_equal(gt, pred, timeout=use_timeout)
                n_total_samples += 1
                if ok:
                    n_correct_samples += 1
                    solved = True
            solved_list.append(int(solved))
            if (i + 1) % 5 == 0:
                print(f"  [Pass@k {mode_name}] {i+1}/{len(problems)} pass@{k}={sum(solved_list)/len(solved_list)*100:.1f}% elapsed={time.time()-t0:.0f}s", flush=True)
        pass_k_acc = sum(solved_list) / len(solved_list)
        sample_acc = n_correct_samples / max(n_total_samples, 1)
        elapsed = time.time() - t0
        results[mode_name] = {
            "pass@k": pass_k_acc, "k": k, "n_problems": len(problems),
            "sample_accuracy": sample_acc, "n_correct_samples": n_correct_samples,
            "n_total_samples": n_total_samples, "block_length": cfg["block_length"],
            "steps": cfg["steps"], "temperature": temperature, "elapsed_s": elapsed,
            "solved_list": solved_list,
        }
        per_problem[mode_name] = solved_list
        print(f"\n[{mode_name}] Pass@{k} = {pass_k_acc*100:.2f}%  sample_acc={sample_acc*100:.2f}%  ({elapsed:.0f}s)", flush=True)

    # solution coverage overlap: problems solved by AR not AO, and vice versa
    ar_s = set(i for i, v in enumerate(per_problem["AR"]) if v)
    ao_s = set(i for i, v in enumerate(per_problem["AO"]) if v)
    coverage = {
        "ar_only_count": len(ar_s - ao_s),
        "ao_only_count": len(ao_s - ar_s),
        "both_count": len(ar_s & ao_s),
        "neither_count": len(set(range(len(per_problem["AR"]))) - ar_s - ao_s),
        "ar_only_pct": len(ar_s - ao_s) / max(len(ar_s), 1) * 100,
        "ao_only_pct": len(ao_s - ar_s) / max(len(ao_s), 1) * 100,
    }
    results["coverage_overlap"] = coverage
    print(f"Coverage: AR-only={coverage['ar_only_count']} AO-only={coverage['ao_only_count']} both={coverage['both_count']} ({coverage['ar_only_pct']:.1f}% of AR solutions not in AO)", flush=True)
    print(f"RESULT_MARKER pass_at_k: {json.dumps(results)}", flush=True)
    return results


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--claim", type=str, required=True, choices=["c1", "c2", "c3", "all"])
    parser.add_argument("--ckpt_path", type=str, default="nzl-thu/LLaDA-Instruct-JustGRPO-GSM8K")
    parser.add_argument("--math500_ckpt", type=str, default="nzl-thu/LLaDA-Instruct-JustGRPO-Math500")
    parser.add_argument("--code_ckpt", type=str, default="nzl-thu/LLaDA-Instruct-JustGRPO-Code")
    parser.add_argument("--base_ckpt", type=str, default="GSAI-ML/LLaDA-8B-Instruct")
    parser.add_argument("--gen_length", type=int, default=256)
    parser.add_argument("--steps", type=int, default=256)
    parser.add_argument("--block_length", type=int, default=32)
    parser.add_argument("--max_examples", type=int, default=0, help="0 = full set")
    parser.add_argument("--k", type=int, default=4, help="Pass@k samples")
    parser.add_argument("--n_problems", type=int, default=30, help="problems for Pass@k")
    parser.add_argument("--temperature", type=float, default=0.7, help="temp for Pass@k sampling")
    parser.add_argument("--output", type=str, default="results")
    args = parser.parse_args()

    os.makedirs(args.output, exist_ok=True)
    torch.manual_seed(113)
    print(f"Device: {DEVICE} | claim={args.claim}", flush=True)

    if args.claim in ("c1", "all"):
        print("\n===== C1: GSM8K eval (JustGRPO) =====", flush=True)
        model, tokenizer = load_model(args.ckpt_path, base_path=args.base_ckpt)
        res = eval_math(model, tokenizer, "gsm8k", args.gen_length, args.steps,
                        args.block_length, args.max_examples or 0)
        with open(os.path.join(args.output, "c1_gsm8k.json"), "w") as f:
            json.dump(res, f, indent=2)
        # also AR mode (block_length=1) on a smaller subset for C2 parallel-decoding comparison
        if args.claim == "all" or args.claim == "c1":
            n_ar = 100
            print("\n===== C2a: GSM8K AR mode (block_length=1) for parallel-decoding check =====", flush=True)
            res_ar = eval_math(model, tokenizer, "gsm8k", args.gen_length, args.gen_length,
                               1, n_ar, temperature=0.0)
            with open(os.path.join(args.output, "c2_gsm8k_ar.json"), "w") as f:
                json.dump(res_ar, f, indent=2)
        del model
        torch.cuda.empty_cache()

    if args.claim in ("c2", "all"):
        n_math = min(args.max_examples or 150, 100)
        print(f"\n===== C2b: MATH-500 eval ({n_math} ex, JustGRPO-Math500) =====", flush=True)
        try:
            model, tokenizer = load_model(args.math500_ckpt, base_path=args.base_ckpt)
            res = eval_math(model, tokenizer, "math500", args.gen_length, args.steps,
                            args.block_length, n_math)
            with open(os.path.join(args.output, "c2_math500.json"), "w") as f:
                json.dump(res, f, indent=2)
            del model
            torch.cuda.empty_cache()
        except Exception as e:
            print(f"MATH-500 eval failed: {e}", flush=True)

        n_code = 80
        print(f"\n===== C2c: HumanEval eval ({n_code} ex, JustGRPO-Code) =====", flush=True)
        try:
            model, tokenizer = load_model(args.code_ckpt, base_path=args.base_ckpt)
            res = eval_code(model, tokenizer, "humaneval", args.gen_length, args.steps,
                            args.block_length, n_code)
            with open(os.path.join(args.output, "c2_humaneval.json"), "w") as f:
                json.dump(res, f, indent=2)
            del model
            torch.cuda.empty_cache()
        except Exception as e:
            print(f"HumanEval eval failed: {e}", flush=True)

    if args.claim in ("c3", "all"):
        print("\n===== C3: Pass@k AR vs AO (base LLaDA-Instruct) =====", flush=True)
        model, tokenizer = load_model(args.base_ckpt, base_path=args.base_ckpt)
        res = eval_pass_at_k(model, tokenizer, "gsm8k", args.gen_length, args.steps,
                              args.n_problems, args.k, args.temperature)
        with open(os.path.join(args.output, "c3_pass_at_k.json"), "w") as f:
            json.dump(res, f, indent=2)
        del model
        torch.cuda.empty_cache()

    # Best-effort upload of results to HF dataset repo for persistence
    try:
        from huggingface_hub import HfApi
        api = HfApi()
        repo_id = "feliksier/justgrpo-repro-results"
        api.create_repo(repo_id, repo_type="dataset", exist_ok=True, private=False)
        api.upload_folder(folder_path=args.output, repo_id=repo_id, repo_type="dataset")
        print(f"Uploaded results to hf://datasets/{repo_id}", flush=True)
    except Exception as e:
        print(f"Upload failed (non-fatal): {e}", flush=True)
    print("\n===== DONE =====", flush=True)


if __name__ == "__main__":
    main()