#!/usr/bin/env python3
"""Finalize the 600-question PROBE-Bench V2 benchmark from the accepted pool
(approved-questions/bank) + unreviewed NO/GT=0 fill for count/find.

Strategy (agreed with user):
  count : 150 = YES(GT>=1) capped @3/target + NO(GT=0) fill.  Option A =
          per-asked-object cap 3 over yes+no combined.  Maximize distractor
          object diversity (greedy new-folder coverage).
  find  : 150 = same (YES capped, NO fill), Option A combined cap 3.
  compare: 150 = balanced 75 largest + 75 smallest, all-unique triplets,
          greedy max object coverage within each polarity.
  beneath: 150 = all-unique duplets, greedy max object coverage; NOTA left
          natural.

Sources:
  approved-questions/bank            (reviewed YES + beneath + compare)
  rollouts/rollout_vlm_20260901_220948  count_v2  (NO/GT=0 fill, unreviewed OK)
  rollouts/rollout_vlm_20260902_044842  find_v2   (NO fill, unreviewed OK)
  rollouts/rollout_vlm_20260827_231647  qbank     (extra NO fill)

Outputs (renumbered, --from_snapshot-ready, each with bank_manifest.json):
  approved-questions/benchmark_600/     the frozen 600
  approved-questions/leftover_pool/     all remaining accepted questions
Nothing in the sources is modified.
"""
import json, glob, os, shutil, sys, random
from collections import Counter, defaultdict

ROOT="/home/vineetb/Desktop/projects/Agentic_MQA"
BANK=os.path.join(ROOT,"approved-questions/bank")
SRC={"count_v2":os.path.join(ROOT,"rollouts/rollout_vlm_20260901_220948"),
     "find_v2":os.path.join(ROOT,"rollouts/rollout_vlm_20260902_044842"),
     "qbank":os.path.join(ROOT,"rollouts/rollout_vlm_20260827_231647")}
OUT_BENCH=os.path.join(ROOT,"approved-questions/benchmark_600")
OUT_LEFT=os.path.join(ROOT,"approved-questions/leftover_pool")
N=150; CAP=3; SEED=1000000

def qtype(q):
    t=q.get("question_type")
    return {"marked_comparison":"compare","counting":"count",
            "existence":"find","under_object":"beneath"}.get(t,t)

def scene_folders(ep_dir):
    sp=os.path.join(ep_dir,"scene_snapshot","scene_snapshot.json"); s=set()
    if os.path.isfile(sp):
        j=json.load(open(sp))
        for o in (j.get("objects") or []):
            if o.get("folder"): s.add(o["folder"])
    return s

def name_folder_map(ep_dir):
    sp=os.path.join(ep_dir,"scene_snapshot","scene_snapshot.json"); m={}
    if os.path.isfile(sp):
        j=json.load(open(sp))
        for o in (j.get("objects") or []):
            if o.get("name") and o.get("folder"): m[o["name"]]=o["folder"]
    return m

def marg(scene,g): return len(scene-g)

# ── gather candidates ──────────────────────────────────────────────────
# approved bank episodes (all types)
approved=[]   # {abs_dir, ct, polarity, asked_fol, sig, scene, extremum, src_bank, src_ep}
manifest=json.load(open(os.path.join(BANK,"bank_manifest.json")))
src_of={e["ep_dir"]:(e["source_rollout"],e["source_episode"]) for e in manifest["episodes"]}
for rj in sorted(glob.glob(f"{BANK}/ep_*/review.json")):
    ep_dir=os.path.dirname(rj); nm=os.path.basename(ep_dir)
    d=json.load(open(rj)); q=d.get("question") or {}
    ct=qtype(q); scene=scene_folders(ep_dir); fmap=name_folder_map(ep_dir)
    rec={"abs_dir":ep_dir,"ct":ct,"scene":scene,
         "src":("approved",)+src_of.get(nm,("?","?"))}
    if ct=="count":
        rec["polarity"]="no" if str(q.get("gt_answer"))=="0" else "yes"
        rec["asked_fol"]=q.get("target_ref_folder")
        rec["sig"]=rec["asked_fol"]
    elif ct=="find":
        yes=str(q.get("gt_answer_text") or "").lower().startswith("y")
        rec["polarity"]="yes" if yes else "no"
        rec["asked_fol"]=q.get("queried_ref_folder")
        rec["sig"]=rec["asked_fol"]
    elif ct=="beneath":
        rec["polarity"]=None
        rec["sig"]=(fmap.get(q.get("cover_object")), fmap.get(q.get("target_name")))
        rec["asked_fol"]=None
    elif ct=="compare":
        rec["polarity"]=None
        rec["extremum"]=q.get("comparison_extremum")
        ml=q.get("marked_labels") or {}
        rec["sig"]=tuple(sorted(v.get("obj_folder") for v in ml.values() if v.get("obj_folder")))
        rec["asked_fol"]=None
    approved.append(rec)

# unreviewed NO fill (count GT=0, find no) from source rollouts — dedupe by (bank,name)
no_extra={"count":[], "find":[]}
_seen=set()
for bank,rd in SRC.items():
    if not os.path.isdir(rd): continue
    for rj in glob.glob(os.path.join(rd,"ep_*/review.json"))+\
              glob.glob(os.path.join(rd,"worker_*/ep_*/review.json")):
        ep_dir=os.path.dirname(rj); nm=os.path.basename(ep_dir)
        key=(bank,nm)
        if key in _seen: continue
        try:d=json.load(open(rj))
        except:continue
        q=d.get("question") or {}; ct=qtype(q)
        if ct=="count" and str(q.get("gt_answer"))=="0":
            fol=q.get("target_ref_folder")
        elif ct=="find" and str(q.get("gt_answer_text") or "").lower().startswith("n"):
            fol=q.get("queried_ref_folder")
        else: continue
        _seen.add(key)
        no_extra[ct].append({"abs_dir":ep_dir,"ct":ct,"polarity":"no",
                             "asked_fol":fol,"sig":fol,"scene":scene_folders(ep_dir),
                             "src":(bank,bank,nm)})

# ── selection ──────────────────────────────────────────────────────────
g=set()   # shared global folder set (maximize overall diversity)
selection={}   # ct -> list of recs

def cap_select(rows, need, cap, used0=None, chosen0=None):
    global g
    by=defaultdict(list)
    for r in rows:
        if not r.get("sig"): continue
        by[r["sig"]].append(r)
    used=Counter(used0 or {}); sel=[]; chosen=set(chosen0 or ())
    for rnd in range(cap):
        if len(sel)>=need: break
        prog=False
        order=sorted(by, key=lambda k:(-max((marg(e["scene"],g) for e in by[k]
                     if e["abs_dir"] not in chosen),default=-1),str(k)))
        for k in order:
            if len(sel)>=need: break
            if used[k]!=rnd: continue
            pool=[e for e in by[k] if e["abs_dir"] not in chosen]
            if not pool: continue
            pool.sort(key=lambda e:(-marg(e["scene"],g),e["abs_dir"]))
            e=pool[0]; sel.append(e); g|=e["scene"]; used[k]+=1
            chosen.add(e["abs_dir"]); prog=True
        if not prog: break
    return sel, used, chosen

def unique_select(rows, need):
    global g
    sel=[]; chosen=set(); remaining=rows[:]
    while remaining and len(sel)<need:
        remaining.sort(key=lambda e:(-marg(e["scene"],g), e["abs_dir"]))
        e=remaining.pop(0)
        if e["abs_dir"] in chosen: continue
        sel.append(e); chosen.add(e["abs_dir"]); g|=e["scene"]
    return sel

# --- count / find : Option A combined cap 3 (yes first, then no) ---------
for ct in ["count","find"]:
    yes=[r for r in approved if r["ct"]==ct and r["polarity"]=="yes"]
    ysel,used,chosen=cap_select(yes, N, CAP)
    need=N-len(ysel)
    # NO pool = approved-no + unreviewed-no
    no_all=[r for r in approved if r["ct"]==ct and r["polarity"]=="no"] + no_extra[ct]
    nsel,_,_=cap_select(no_all, need, CAP, used0=used, chosen0=chosen)
    selection[ct]=ysel+nsel

# --- compare : balanced 75 largest / 75 smallest, unique triplets --------
cmp_l=[r for r in approved if r["ct"]=="compare" and r.get("extremum")=="largest"]
cmp_s=[r for r in approved if r["ct"]=="compare" and r.get("extremum")=="smallest"]
sel_l=unique_select(cmp_l, 75)
sel_s=unique_select(cmp_s, 75)
selection["compare"]=sel_l+sel_s

# --- beneath : all-unique duplets, greedy coverage -----------------------
ben=[r for r in approved if r["ct"]=="beneath"]
selection["beneath"]=unique_select(ben, N)

# ── report ──────────────────────────────────────────────────────────────
print("="*70)
print("FINAL 600 SELECTION")
print("="*70)
total=0
for ct in ["count","find","beneath","compare"]:
    sel=selection[ct]; total+=len(sel)
    if ct in ("count","find"):
        pol=Counter(r["polarity"] for r in sel)
        objs=Counter(r["asked_fol"] for r in sel if r["asked_fol"])
        reuse=Counter(objs.values())
        print(f"{ct}: {len(sel)}  (yes={pol.get('yes',0)} no={pol.get('no',0)}) "
              f"| {len(objs)} distinct asked-objs, reuse {dict(sorted(reuse.items()))} max {max(objs.values()) if objs else 0}")
    elif ct=="compare":
        ex=Counter(r.get("extremum") for r in sel)
        print(f"{ct}: {len(sel)}  extremum {dict(ex)} | {len(set(r['sig'] for r in sel))} unique triplets")
    else:
        print(f"{ct}: {len(sel)}  | {len(set(r['sig'] for r in sel))} unique duplets")
print(f"TOTAL: {total}")
print(f"OVERALL UNIQUE OBJECT FOLDERS: {len(g)}")

if "--dry-run" in sys.argv:
    print("\n(dry-run: nothing written)")
    sys.exit(0)

# ── materialize ──────────────────────────────────────────────────────────
def _texture_hashes(ep_dir):
    sp=os.path.join(ep_dir,"scene_snapshot","scene_snapshot.json"); hs=set()
    if os.path.isfile(sp):
        s=json.load(open(sp))
        tt=s.get("table_texture") or {}
        h=tt.get("hash") or tt.get("store_hash")
        if h: hs.add(h)
        # also scan any 'texture_hash' fields
        for o in (s.get("objects") or []):
            th=o.get("texture_hash")
            if th: hs.add(th)
    return hs

def _rollout_root_of(ep_dir):
    # ep_dir may be <root>/ep_x or <root>/worker_k/ep_x
    p=os.path.dirname(ep_dir)
    if os.path.basename(p).startswith("worker_"): p=os.path.dirname(p)
    return p

def write_bank(out, recs_by_type, desc):
    if os.path.exists(out): shutil.rmtree(out)
    os.makedirs(out)
    store_out=os.path.join(out,"_texture_store"); copied=set()
    ref_out=os.path.join(out,"_ref_views"); os.makedirs(ref_out, exist_ok=True)
    ref_copied=set()
    man=[]; idx=0
    # deterministic order: type then source
    for ct in ["beneath","compare","count","find"]:
        recs=sorted(recs_by_type.get(ct,[]), key=lambda r:(r["src"], r["abs_dir"]))
        for r in recs:
            dst_name=f"ep_{idx:03d}_{ct}"; idx+=1
            dst=os.path.join(out,dst_name)
            shutil.copytree(r["abs_dir"], dst, symlinks=False)
            # texture store
            root=_rollout_root_of(r["abs_dir"])
            for h in _texture_hashes(r["abs_dir"]):
                if h in copied: continue
                s=os.path.join(root,"_texture_store",h)
                if os.path.isdir(s):
                    os.makedirs(store_out, exist_ok=True)
                    d=os.path.join(store_out,h)
                    if not os.path.isdir(d): shutil.copytree(s,d)
                    copied.add(h)
            # ref_views for the scene objects (plain folder keys)
            for fol in r["scene"]:
                obj_key=fol.replace("/","__")
                if obj_key in ref_copied: continue
                s=os.path.join(root,"_ref_views",obj_key)
                if os.path.isdir(s):
                    d=os.path.join(ref_out,obj_key)
                    if not os.path.isdir(d): shutil.copytree(s,d)
                    ref_copied.add(obj_key)
            # ref_views referenced by review.json (compare marker refs carry a
            # __badge_<hash> suffix NOT present in scene folders — must copy too,
            # else the review website 404s the referred-object guide).
            rj=os.path.join(dst,"review.json")
            _rev=(json.load(open(rj)) if os.path.isfile(rj) else {})
            for _ref in (_rev.get("reference") or []):
                for _im in _ref.get("images",[]):
                    _parts=_im.lstrip("/").split("/")
                    if len(_parts)>=2 and _parts[0]=="_ref_views":
                        obj_key=_parts[1]
                        if obj_key in ref_copied: continue
                        s=os.path.join(root,"_ref_views",obj_key)
                        if os.path.isdir(s):
                            d=os.path.join(ref_out,obj_key)
                            if not os.path.isdir(d): shutil.copytree(s,d)
                            ref_copied.add(obj_key)
            # manifest row
            q=(_rev.get("question") or {})
            man.append({"ep_dir":dst_name,"question_type":ct,
                        "gt_answer":q.get("gt_answer"),
                        "polarity":r.get("polarity"),
                        "extremum":r.get("extremum"),
                        "source_rollout":r["src"][1],"source_episode":r["src"][2]})
    manj={"schema_version":1,"description":desc,"seed":SEED,
          "n_episodes":len(man),
          "by_type":dict(Counter(e["question_type"] for e in man)),
          "episodes":man}
    json.dump(manj, open(os.path.join(out,"bank_manifest.json"),"w"), indent=2)
    return len(man), len(copied), len(ref_copied)

# benchmark 600
nb,tb,rb=write_bank(OUT_BENCH, selection,
    "PROBE-Bench V2 frozen 600 (150/type). count/find: YES capped@3 + NO/GT=0 "
    "fill (Option A). compare: 75 largest/75 smallest, unique triplets. "
    "beneath: unique duplets. Diversity-maximized object coverage.")
print(f"\n\u2713 benchmark_600 written: {nb} eps, {tb} texture-store, {rb} ref-view objs")
print(f"   -> {OUT_BENCH}")

# leftover pool = every accepted episode NOT selected (approved bank only)
chosen_dirs={r["abs_dir"] for ct in selection for r in selection[ct]}
left=defaultdict(list)
for r in approved:
    if r["abs_dir"] in chosen_dirs: continue
    left[r["ct"]].append(r)
nl,tl,rl=write_bank(OUT_LEFT, left,
    "PROBE-Bench V2 leftover accepted pool (NOT in benchmark_600). Reserve for "
    "swapping if collaborators remove questions.")
print(f"\u2713 leftover_pool written: {nl} eps, {tl} texture-store, {rl} ref-view objs")
print(f"   -> {OUT_LEFT}")
by=Counter(e for ct in left for e in [ct]*len(left[ct]))
print(f"   leftover by_type: {dict(by)}")