"""Shared paths, schema helpers and the vLLM option-letter log-prob client for the
full-item-pool screening run (exp/analysis/pool/TASK.md).

Layout
  exp/results/pool/                      small tabular outputs (csv/md) + parquet/duckdb
      pool_items_base.parquet            pool_schema.py   (all items, TASK schema)
      step0_kept.parquet                 step0_screen.py  (dedup verdict per item)
      screen_counts_full.csv             step0_screen.py
      step1/<bench>[.p<j>].jsonl         step1_blind.py   (one row per item, append-only)
      step2/<bench>[.p<j>].jsonl         step2_single_frame.py
      step3/<bench>[.p<j>].jsonl         step3_v32_2b.py
      pool_items.parquet, pool.duckdb, pool_summary.md, run_accounting.csv  (assemble/accounting)
  bench_exp/work/pool_items_cache/       per-bench enumeration cache (jsonl) for the 88
                                         benchmarks without a T3 full-text export
  bench_exp/work/pool_embeddings/        bge-large-en-v1.5 cache per bench (ids.json + .npy),
                                         same layout as exp/data/embeddings/text
  bench_exp/work/pool_frames/<video_id>/ frame_<k>.jpg (448 px long side) + frames.json

Item id = the pipeline qid (f"{bench}_{pool_index}", or the stage_b adapter qid for
MVBench / LVBench / VideoMMMU). video_id = normalized content_hash, or
"k:" + sha1(video_key)[:16] while the video is not yet normalized.
"""
import fcntl
import hashlib
import json
import math
import os
import random
import re
import sys
import time

HERE = os.path.dirname(os.path.abspath(__file__))           # exp/analysis/pool
EXP = os.path.abspath(os.path.join(HERE, "..", ".."))        # exp
REPO = os.path.dirname(EXP)
PIPE = os.path.join(EXP, "pipeline")
for p in (PIPE, os.path.join(EXP, "t3")):
    if p not in sys.path:
        sys.path.insert(0, p)
os.environ.setdefault("FINEBENCH_ROUTE", "yt")   # FineBench samples were drawn with the YouTube route

# Off-cluster runs (exp/analysis/pool/REMOTE_README.md, HF dataset GMLRVigil/BenchCheck-Pool): POOL_BASE
# replaces the cluster data root (the store / manifest / caches under it are optional for steps 1-3),
# POOL_FRAMES_DIR points at the unpacked frame cache, POOL_RESULTS_ROOT at the items + step outputs.
BASE = os.environ.get("POOL_BASE") or "/vast/projects/jgu32/lab/enxin/bench_exp"
STORE = f"{BASE}/store"
WORK = f"{BASE}/work"
NORMALIZED = f"{STORE}/normalized"
MANIFEST_JSONL = f"{BASE}/logs/manifest.jsonl"
T3_FULL = f"{BASE}/t3_export_n1_fulltext/full"
ITEMS_CACHE = f"{WORK}/pool_items_cache"
EMB_DIR = f"{WORK}/pool_embeddings"
FRAMES_DIR = os.environ.get("POOL_FRAMES_DIR") or f"{WORK}/pool_frames"
LOG_DIR = f"{BASE}/logs"

RESULTS = os.environ.get("POOL_RESULTS_ROOT") or os.path.join(EXP, "results", "pool")   # override for smoke tests
BASE_PARQUET = os.path.join(RESULTS, "pool_items_base.parquet")
SCHEMA_MANIFEST = os.path.join(RESULTS, "pool_schema_manifest.csv")
STEP0_KEPT = os.path.join(RESULTS, "step0_kept.parquet")
STEP0_REMOVED = os.path.join(RESULTS, "step0_removed.jsonl")
SCREEN_CSV = os.path.join(RESULTS, "screen_counts_full.csv")
POOL_PARQUET = os.path.join(RESULTS, "pool_items.parquet")
POOL_DUCKDB = os.path.join(RESULTS, "pool.duckdb")
POOL_SUMMARY_MD = os.path.join(RESULTS, "pool_summary.md")
POOL_SUMMARY_CSV = os.path.join(RESULTS, "pool_summary.csv")
ACCOUNTING_CSV = os.path.join(RESULTS, "run_accounting.csv")

VB_CSV = os.path.join(EXP, "video_benchmarks.csv")
REGISTRY_CSV = os.path.join(REPO, "meta", "benchmark_registry.csv")
SAMPLE_DIRS = [os.path.join(EXP, "data", "samples"), os.path.join(EXP, "data", "samples_n1")]

HF_HUB = "/vast/projects/jgu32/lab/enxin/cache/hf/hub"
MODELS = {
    # step -> (served model name, snapshot dir)
    "8b": ("Qwen/Qwen3-VL-8B-Instruct",
           f"{HF_HUB}/models--Qwen--Qwen3-VL-8B-Instruct/snapshots/0c351dd01ed87e9c1b53cbc748cba10e6187ff3b"),
    "2b": ("Qwen/Qwen3-VL-2B-Instruct",
           f"{HF_HUB}/models--Qwen--Qwen3-VL-2B-Instruct/snapshots/89644892e4d85e24eaac8bacfd4f463576704203"),
}
BGE_SNAPSHOT = f"{HF_HUB}/models--BAAI--bge-large-en-v1.5/snapshots/d4aa6901d3a41ba39fb536a557fa166f842b0e09"

STEPS = {1: "blind", 2: "single_frame", 3: "v32_2b"}
STEP_MODEL = {1: "8b", 2: "8b", 3: "2b"}
STEP_DIR = {k: os.path.join(RESULTS, f"step{k}") for k in STEPS}

SEED = 42
N_PERM = 4
LOG2 = math.log(2.0)
LP_FLOOR = math.log(1e-6)          # letter absent from the top-20 log-probs
TOP_LOGPROBS = 20
MAX_OPTIONS = 26                   # letters A..Z; more options -> format=open
LETTERS = [chr(65 + i) for i in range(MAX_OPTIONS)]
FRAME_LONG_SIDE = 448
N_FRAMES_V32 = 32
MID_POS = 16                       # stage_p1_runner v_1: grid32[16]
JPEG_QUALITY = 85
MAX_ERRORS_PER_ITEM = 3            # error rows before an item is treated as permanently failed

# one prompt skeleton for all three steps (intro strings reused from stage_p1_runner)
PROMPT = "{intro}\n\nQuestion: {q}\nOptions:\n{opts}\nAnswer with the option letter only."
ASSISTANT_PREFIX = "Answer:"      # continue_final_message -> the next token is the letter
_TOKEN_LETTER = re.compile(r"^\s*[\(\[]?([A-Z])[\)\]\.:]?\s*$")


def log(msg, tag="pool"):
    print(f"[{tag}] {time.strftime('%H:%M:%S')} {msg}", file=sys.stderr, flush=True)


def ensure_dirs():
    for d in (RESULTS, ITEMS_CACHE, EMB_DIR, FRAMES_DIR, LOG_DIR, *STEP_DIR.values()):
        os.makedirs(d, exist_ok=True)


# ------------------------------------------------------------------ benches
def bench_list():
    """Stems of exp/data/samples/*.jsonl + exp/data/samples_n1/*.jsonl (139 onboarded)."""
    import glob
    names = set()
    for d in SAMPLE_DIRS:
        for p in glob.glob(os.path.join(d, "*.jsonl")):
            if os.path.exists(p):
                names.add(os.path.basename(p)[:-6])
    return sorted(names)


def sample_path(bench):
    for d in SAMPLE_DIRS:
        p = os.path.join(d, f"{bench}.jsonl")
        if os.path.exists(p):
            return p
    return None


def read_jsonl(path):
    out = []
    with open(path, encoding="utf-8") as f:
        for line in f:
            if line.strip():
                try:
                    out.append(json.loads(line))
                except json.JSONDecodeError:
                    continue   # torn final line of a killed writer
    return out


def key_of(ref):
    return f"{ref['repo']}::{ref.get('zip_path', '')}::{ref['member']}"


def manifest_hashes():
    """video_key -> content_hash for logs/manifest.jsonl status=done rows (last wins)."""
    m = {}
    if not os.path.exists(MANIFEST_JSONL):
        return m
    with open(MANIFEST_JSONL, encoding="utf-8") as f:
        for line in f:
            try:
                r = json.loads(line)
            except Exception:
                continue
            if r.get("status") == "done" and r.get("content_hash") and "::" in str(r.get("key", "")):
                m[r["key"]] = r["content_hash"]
    return m


def key_video_id(key):
    return "k:" + hashlib.sha1(key.encode("utf-8")).hexdigest()[:16]


def normalized_path(h):
    return f"{NORMALIZED}/{h}/video.mp4"


def meta_of(h):
    try:
        return json.load(open(f"{NORMALIZED}/{h}/meta.json"))
    except Exception:
        return None


# ------------------------------------------------------------------ options
_SEQ_PREFIX = re.compile(r"^\s*[\(\[]?([A-Za-z])[\)\]\.:]\s*(.*)$", re.S)


def strip_sequential_prefix(opts):
    """['A. x', 'B. y'] -> (['x', 'y'], True) when every option carries the letter of
    its position (A, B, C, ...); otherwise the list is returned unchanged."""
    texts = []
    for i, o in enumerate(opts):
        m = _SEQ_PREFIX.match(str(o))
        if not m or m.group(1).upper() != chr(65 + i):
            return [str(o) for o in opts], False
        texts.append(m.group(2).strip())
    return texts, True


def render_options(texts):
    return "\n".join(f"{LETTERS[i]}. {t}" for i, t in enumerate(texts))


def item_text(question, options):
    """Text embedded for the near-duplicate check: question + options."""
    q = " ".join(str(question or "").split())
    if isinstance(options, list) and options:
        return q + "\n" + "\n".join(str(o) for o in options)
    return q


def permutations_for(item_id, k, n_perm=N_PERM, seed=SEED):
    """TASK.md step 1: n_perm option shuffles, seed 42, per item. perm[j] = original
    option index shown at position j."""
    rng = random.Random(f"{seed}|{item_id}")
    return [rng.sample(range(k), k) for _ in range(n_perm)]


# ------------------------------------------------------------------ log-probs
def letter_logprobs(top_logprobs, k):
    """top_logprobs: list of {token, logprob} for the first generated position.
    -> (lp list over the k presented letters, missing letters, matched variants).
    Tokenization variants ('A', ' A', '(A', 'A.') are merged by log-sum-exp."""
    acc = {}
    variants = {}
    for e in top_logprobs or []:
        m = _TOKEN_LETTER.match(e.get("token") or "")
        if not m:
            continue
        L = m.group(1)
        if L not in acc:
            acc[L] = e["logprob"]
        else:
            a, b = acc[L], e["logprob"]
            acc[L] = max(a, b) + math.log1p(math.exp(-abs(a - b)))
        variants.setdefault(L, []).append(e.get("token"))
    lp, missing = [], []
    for i in range(k):
        L = LETTERS[i]
        if L in acc:
            lp.append(float(acc[L]))
        else:
            lp.append(LP_FLOOR)
            missing.append(L)
    return lp, missing, variants


def margin_of(lp, correct_pos):
    others = [v for i, v in enumerate(lp) if i != correct_pos]
    return lp[correct_pos] - (sum(others) / len(others) if others else 0.0)


def argmax_pos(lp):
    best = max(lp)
    return lp.index(best)


class ContextTooLong(Exception):
    pass


def logprob_request(endpoint, model, prompt, images_b64=None, timeout=(10, 600)):
    """One forward: max_tokens=1, logprobs=true, top_logprobs=20; the assistant turn is
    prefilled with ASSISTANT_PREFIX (continue_final_message) so the next token is the
    letter. -> dict(top=[{token, logprob}], top1_token, prompt_tokens, latency_s)."""
    import requests
    content = [{"type": "image_url", "image_url": {"url": "data:image/jpeg;base64," + b}}
               for b in (images_b64 or [])]
    content.append({"type": "text", "text": prompt})
    body = {"model": model, "temperature": 0.0, "max_tokens": 1,
            "logprobs": True, "top_logprobs": TOP_LOGPROBS,
            "messages": [{"role": "user", "content": content},
                         {"role": "assistant", "content": ASSISTANT_PREFIX}],
            "continue_final_message": True, "add_generation_prompt": False}
    t0 = time.time()
    r = requests.post(f"{endpoint}/chat/completions", json=body, timeout=timeout)
    if r.status_code == 400 and ("maximum" in r.text or "longer than" in r.text
                                 or "context length" in r.text):
        raise ContextTooLong(r.text[:200])
    r.raise_for_status()
    d = r.json()
    ch = d["choices"][0]
    lpc = (ch.get("logprobs") or {}).get("content") or []
    if not lpc:
        raise RuntimeError("no logprobs in response")
    top = [{"token": e.get("token"), "logprob": e.get("logprob")} for e in (lpc[0].get("top_logprobs") or [])]
    return dict(top=top, top1_token=lpc[0].get("token"),
                prompt_tokens=(d.get("usage") or {}).get("prompt_tokens", 0),
                latency_s=round(time.time() - t0, 4))


# ------------------------------------------------------------------ result files
def bench_files(step, bench):
    """All jsonl files of a benchmark under step<k>/ (part files included)."""
    d = STEP_DIR[step]
    if not os.path.isdir(d):
        return []
    out = []
    for f in os.listdir(d):
        if f == f"{bench}.jsonl" or (f.startswith(f"{bench}.p") and f.endswith(".jsonl")
                                     and f[len(bench) + 2:-6].isdigit()):
            out.append(os.path.join(d, f))
    return sorted(out)


def unit_file(step, bench, part, n_parts):
    return os.path.join(STEP_DIR[step], f"{bench}.jsonl" if n_parts == 1 else f"{bench}.p{part}.jsonl")


def load_step_rows(step, benches=None):
    """item_id -> last successful row; plus item_id -> error count.
    Rows with status != ok are errors (never counted as done)."""
    ok, errs = {}, {}
    d = STEP_DIR[step]
    if not os.path.isdir(d):
        return ok, errs
    files = []
    for f in sorted(os.listdir(d)):
        if not f.endswith(".jsonl"):
            continue
        if benches is not None:
            b = f[:-6]
            if "." in b and b.rsplit(".", 1)[1][1:].isdigit() and b.rsplit(".", 1)[1].startswith("p"):
                b = b.rsplit(".", 1)[0]
            if b not in benches:
                continue
        files.append(os.path.join(d, f))
    for p in files:
        for r in read_jsonl(p):
            iid = r.get("item_id")
            if iid is None:
                continue
            if r.get("status", "ok") == "ok":
                ok[iid] = r
            else:
                errs[iid] = errs.get(iid, 0) + 1
    return ok, errs


def append_rows(path, rows):
    """Append json rows under an exclusive flock (several array tasks may touch a file
    across re-runs; the lock keeps rows whole)."""
    os.makedirs(os.path.dirname(path), exist_ok=True)
    data = "".join(json.dumps(r, ensure_ascii=False, default=str) + "\n" for r in rows)
    with open(path, "a", encoding="utf-8") as f:
        fcntl.flock(f, fcntl.LOCK_EX)
        try:
            f.write(data)
            f.flush()
        finally:
            fcntl.flock(f, fcntl.LOCK_UN)


# ------------------------------------------------------------------ sharding
def plan_units(work, max_unit=20000):
    """work: list of (bench, [item_ids sorted]) -> units [(bench, part, n_parts, ids)].
    Big benchmarks are split into parts of <= max_unit items (deterministic by sorted
    item_id) so one array task never owns more than max_unit items of one file."""
    units = []
    for bench, ids in work:
        ids = sorted(ids)
        n_parts = max(1, math.ceil(len(ids) / max_unit)) if ids else 1
        size = math.ceil(len(ids) / n_parts) if ids else 0
        for part in range(n_parts):
            units.append((bench, part, n_parts, ids[part * size:(part + 1) * size]))
    return units


def assign_units(units, n_tasks, task_id, weight=lambda u: len(u[3])):
    """Deterministic LPT (largest first to the least loaded task)."""
    loads = [0.0] * n_tasks
    mine = []
    for u in sorted(units, key=lambda u: (-weight(u), u[0], u[1])):
        t = min(range(n_tasks), key=lambda i: (loads[i], i))
        loads[t] += weight(u)
        if t == task_id:
            mine.append(u)
    return mine, loads


def slurm_task():
    """(task_id, n_tasks) from the Slurm array environment; (0, 1) outside Slurm."""
    tid = int(os.environ.get("SLURM_ARRAY_TASK_ID", 0))
    n = os.environ.get("SLURM_ARRAY_TASK_COUNT")
    if n is None:
        lo, hi = os.environ.get("SLURM_ARRAY_TASK_MIN"), os.environ.get("SLURM_ARRAY_TASK_MAX")
        n = int(hi) - int(lo) + 1 if lo is not None and hi is not None else 1
        if lo is not None:
            tid -= int(lo)
    return tid, int(n)