#!/usr/bin/env python3
"""
PENTABRID - generation-based MCQ evaluator (MedMCQA / MedQA), fixed parser.
===========================================================================
Same HF-generation method and v2 parser as the MedXpert evaluator, so V13 and
base are scored identically and the "answer is" -> "I" trap is gone. Saves the
full answer text per question (re-analysable) and writes a score json.

Run on a single A100 (these sets are small). Cache the dataset on the LOGIN node
first (compute nodes are offline), then run with HF_DATASETS_OFFLINE=1.

SMOKE FIRST (verify the schema parsed correctly before the full run):
    MODEL_DIR=$HOME/pentabrid/runs/V13_27B_merged OUT_DIR=$HOME/pentabrid/runs/V13_mcq \
    python eval_mcq_hf.py --dataset medmcqa --limit 3 --batch-size 1
  -> prints the detected (question, options, gold) for the first few rows. If gold
     letters and option text look right, drop --limit and run for real.

FULL RUNS (examples):
    # MedMCQA, 1000 questions, V13:
    MODEL_DIR=$HOME/pentabrid/runs/V13_27B_merged OUT_DIR=$HOME/pentabrid/runs/V13_mcq \
    python eval_mcq_hf.py --dataset medmcqa --limit 1000 --seed 62
    # MedQA-500 (seed 62), base:
    MODEL_DIR=/home/adnanagha/pentabrid/base_models/Qwen3.6-27B OUT_DIR=$HOME/pentabrid/runs/BASE_mcq \
    python eval_mcq_hf.py --dataset medqa --limit 500 --seed 62

Data source: by default loads the dataset from the HF cache (set the id with --hf
if yours differs). Or point --jsonl at a local file you already downloaded.
"""
import os, re, json, argparse, random
from pathlib import Path
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

ap = argparse.ArgumentParser()
ap.add_argument("--dataset", choices=["medmcqa", "medqa"], help="built-in schema + default HF id/split")
ap.add_argument("--hf", default=None, help="override HF dataset id")
ap.add_argument("--config", default=None, help="HF dataset config name (if any)")
ap.add_argument("--split", default=None, help="override split (medmcqa->validation, medqa->test)")
ap.add_argument("--jsonl", default=None, help="load from a local jsonl instead of HF")
ap.add_argument("--limit", type=int, default=0, help="cap number of questions (0 = all)")
ap.add_argument("--seed", type=int, default=62, help="seed for the subsample shuffle")
ap.add_argument("--batch-size", type=int, default=8)
args = ap.parse_args()

MODEL = os.environ["MODEL_DIR"]
OUTDIR = Path(os.environ.get("OUT_DIR", MODEL)); OUTDIR.mkdir(parents=True, exist_ok=True)
tag = args.dataset or "custom"
OUT = OUTDIR / f"{tag}_results.jsonl"
SCORE = OUTDIR / f"{tag}_score.json"

# ---------------------------------------------------------------------------
# schema registry: (default HF id, default split, row->(question, options{}, gold))
# ---------------------------------------------------------------------------
def _med_mcqa(r):
    opts = {"A": r.get("opa",""), "B": r.get("opb",""), "C": r.get("opc",""), "D": r.get("opd","")}
    cop = r.get("cop", r.get("answer", ""))
    gold = ""
    if isinstance(cop, int): gold = "ABCD"[cop] if 0 <= cop < 4 else ""
    elif isinstance(cop, str):
        s = cop.strip()
        if s.isdigit() and 0 <= int(s) < 4: gold = "ABCD"[int(s)]
        elif s[:1].upper() in "ABCD": gold = s[:1].upper()
    return r.get("question",""), opts, gold

def _med_qa(r):
    q = r.get("question","")
    o = r.get("options")
    if isinstance(o, dict):    options = {k.upper(): v for k, v in o.items()}
    elif isinstance(o, list):  options = {chr(65+i): v for i, v in enumerate(o)}
    else:                      options = {}
    a = r.get("answer_idx", r.get("answer", r.get("answer_letter","")))
    gold = ""
    if isinstance(a, int):                          gold = chr(65+a)
    elif isinstance(a, str) and len(a.strip()) <= 2 and a.strip()[:1].upper() in "ABCDEFGHIJ":
        gold = a.strip()[:1].upper()
    elif isinstance(a, str):                        # answer given as full text -> match option
        na = re.sub(r"\s+"," ",a.lower()).strip()
        for k, v in options.items():
            if re.sub(r"\s+"," ",str(v).lower()).strip() == na: gold = k; break
    return q, options, gold

REGISTRY = {
    "medmcqa": ("openlifescienceai/medmcqa", "validation", _med_mcqa),
    "medqa":   ("GBaker/MedQA-USMLE-4-options", "test",     _med_qa),
}

# ---------------------------------------------------------------------------
# load rows
# ---------------------------------------------------------------------------
if args.jsonl:
    rows = [json.loads(l) for l in open(args.jsonl) if l.strip()]
    extract = REGISTRY[args.dataset][2] if args.dataset else None
    if extract is None:
        raise SystemExit("With --jsonl you must also pass --dataset for the schema (medmcqa/medqa).")
    src = args.jsonl
else:
    if not args.dataset and not args.hf:
        raise SystemExit("Pass --dataset medmcqa|medqa (or --hf <id> with --dataset for schema).")
    hf_id, split, extract = REGISTRY[args.dataset]
    hf_id = args.hf or hf_id
    split = args.split or split
    from datasets import load_dataset
    ds = load_dataset(hf_id, args.config, split=split) if args.config else load_dataset(hf_id, split=split)
    rows = [dict(x) for x in ds]
    src = f"{hf_id}:{split}"
print(f"Loaded {len(rows)} rows from {src}", flush=True)

# reproducible subsample
if args.limit and args.limit > 0 and args.limit < len(rows):
    rnd = random.Random(args.seed); idx = list(range(len(rows))); rnd.shuffle(idx)
    rows = [rows[i] for i in idx[:args.limit]]
    print(f"Subsampled to {len(rows)} (seed {args.seed})", flush=True)

# ---------------------------------------------------------------------------
# prompt + v2 parser (identical to eval_medxpertqa_hf_v2.py)
# ---------------------------------------------------------------------------
def build_prompt(q, options):
    lines = [q, ""]
    for k in sorted(options): lines.append(f"{k}. {options[k]}")
    lines += ["", "Think step by step, then end with exactly: 'Answer: X' where X is the letter."]
    return "\n".join(lines)

_PATS = [
    r"\bfinal\s+answer\b\s*(?:is|:|=|-)?\s*\(?\*{0,2}([A-J])\b",
    r"\bcorrect\s+(?:answer|option|choice)\b\s*(?:is|:|=|-)?\s*\(?\*{0,2}([A-J])\b",
    r"\banswer\s*(?:is|:|=|-)\s*\(?\*{0,2}([A-J])\b",
    r"\bthe answer is\b\s*\(?\*{0,2}([A-J])\b",
    r"\banswer\s+\(?\*{0,2}([A-J])\b",
    r"\b(?:option|choice)\s*(?:is|:|=|-)?\s*\(?\*{0,2}([A-J])\b",
]
def parse_letter(text):
    if not text: return ""
    seg = text.rsplit("</think>", 1)[-1]; seg = seg if seg.strip() else text
    for pat in _PATS:
        m = re.findall(pat, seg, re.IGNORECASE)
        if m: return m[-1].upper()
    m = re.findall(r"\banswer\s*(?:is|:|=|-)?\s*\(?\*{0,2}([A-J])\b", text, re.IGNORECASE)
    if m: return m[-1].upper()
    m = re.findall(r"\*\*\s*([A-J])\s*\*\*|\(\s*([A-J])\s*\)", seg)
    flat=[x for p in m for x in p if x]
    if flat: return flat[-1].upper()
    m = re.findall(r"\b([A-J])\b", seg)
    return m[-1].upper() if m else ""

# parse all rows up front; show a sample so schema errors are caught immediately
parsed = []
for i, r in enumerate(rows):
    q, options, gold = extract(r)
    parsed.append((str(r.get("id", i)), q, options, gold))
print("\n--- schema check (first up to 3 rows) ---", flush=True)
for rid, q, options, gold in parsed[:3]:
    print(f"  id={rid}  gold={gold!r}  #opts={len(options)}  q[:80]={q[:80]!r}", flush=True)
    for k in sorted(options): print(f"      {k}. {str(options[k])[:60]}", flush=True)
bad_gold = sum(1 for _,_,_,g in parsed if not g)
if bad_gold: print(f"  WARNING: {bad_gold}/{len(parsed)} rows have no parseable gold - check the schema/split.", flush=True)
print("--- end schema check ---\n", flush=True)

# ---------------------------------------------------------------------------
# load model
# ---------------------------------------------------------------------------
print(f"Loading model from {MODEL} ...", flush=True)
tok = AutoTokenizer.from_pretrained(MODEL); tok.padding_side = "left"
if tok.pad_token is None: tok.pad_token = tok.eos_token
model = AutoModelForCausalLM.from_pretrained(MODEL, torch_dtype=torch.bfloat16, device_map="cuda").eval()
print("model loaded.", flush=True)

# ---------------------------------------------------------------------------
# batched greedy generation (section-5 return_dict fix)
# ---------------------------------------------------------------------------
B = max(1, args.batch_size); correct = run = 0
with open(OUT, "w") as fout:
    for start in range(0, len(parsed), B):
        batch = parsed[start:start+B]
        msgs = [[{"role":"user","content":build_prompt(q, o)}] for _,q,o,_ in batch]
        enc = tok.apply_chat_template(msgs, add_generation_prompt=True,
                                      return_tensors="pt", return_dict=True, padding=True).to(model.device)
        with torch.no_grad():
            out = model.generate(**enc, max_new_tokens=2048, do_sample=False, pad_token_id=tok.pad_token_id)
        gen = out[:, enc["input_ids"].shape[1]:]
        texts = tok.batch_decode(gen, skip_special_tokens=True)
        for (rid,q,o,gold), text in zip(batch, texts):
            pred = parse_letter(text); ok = bool(pred) and pred == gold
            correct += int(ok); run += 1
            fout.write(json.dumps({"id":rid,"pred":pred,"gold":gold,"correct":ok,"text":text})+"\n")
        fout.flush()
        print(f"  {run}/{len(parsed)} done  acc {100.0*correct/max(1,run):.1f}%", flush=True)

acc = 100.0*correct/max(1,len(parsed))
SCORE.write_text(json.dumps({"dataset":tag,"raw":correct,"total":len(parsed),
                             "accuracy_pct":round(acc,2),"parser":"fixed_v2"}, indent=2))
print(f"\n{tag}  raw={correct}/{len(parsed)}  accuracy={acc:.2f}%\nWrote {SCORE}", flush=True)