"""Step 10a: Precompute BGE-M3 top-10 window base_rank for DAPO anchors.

For each query that has an ms_label file (MAJORITY + AMBIGUOUS merged), build the user's
BGE-M3 user-turn-only index and compute get_rank(original_query, gold_evidence_ids)
within the top-10 window (-1 if outside). Export anchors.jsonl with oracle_label,
cartridge_path, gold_evidence_ids, gold_aliases, base_rank (+ full_rank diag).
oracle_label is a passive diagnostic field only — DAPO does NOT train on it (the sampler
is uniform and label-agnostic; the reward is purely outcome-driven).

Requires GPU + FlagEmbedding (BGE-M3).

Usage:
    python scripts/train/10a_precompute_base_rank.py
"""

import argparse
import json
import os
import sys

sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

from src.retrieval.bge_m3_retriever import BGEM3Retriever
from src.utils import load_json, load_yaml, setup_logger
from src.utils.cartridge_utils import find_cartridge_path

logger = setup_logger(__name__)


def _r(p):
    return p if os.path.isabs(p) else os.path.join(PROJECT_ROOT, p)


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--dataset", default="data/processed/metamem/dataset.json")
    ap.add_argument("--ms-dir", default="data/labeled/ms_labels/Qwen3-8B")
    ap.add_argument("--cartridge-dir", default="checkpoints/cartridge/Qwen3-8B")
    ap.add_argument("--retrieval-config", default="configs/retrieval/bge_m3.yaml")
    ap.add_argument("--out", default="data/train/rl/anchors.jsonl")
    ap.add_argument("--include-query-ids", default=None,
                    help="JSON list of query_ids to KEEP (e.g. splits/rl_ids.json). "
                         "Omit to use all labeled queries (legacy behavior).")
    args = ap.parse_args()

    dataset = load_json(_r(args.dataset))
    ms_dir = _r(args.ms_dir)
    cartridge_dir = _r(args.cartridge_dir)
    rcfg = load_yaml(_r(args.retrieval_config))
    out_path = _r(args.out)
    os.makedirs(os.path.dirname(out_path), exist_ok=True)

    include_ids = None
    if args.include_query_ids:
        include_ids = set(load_json(_r(args.include_query_ids)))
        logger.info(f"Filtering to {len(include_ids)} query_ids from {args.include_query_ids}")

    retriever = BGEM3Retriever(rcfg)

    anchors = []
    n_total = 0
    n_no_cart = 0
    for ud in dataset:
        uid = ud["user_id"]
        # skip users with no in-filter queries BEFORE the costly index build
        if include_ids is not None and not any(q["id"] in include_ids for q in ud["queries"]):
            continue
        cpath = find_cartridge_path(cartridge_dir, uid)
        if cpath is None:
            n_no_cart += 1
            continue
        # build user index once
        retriever.build_user_index(uid, ud["user_sessions"])
        for q in ud["queries"]:
            qid = q["id"]
            if include_ids is not None and qid not in include_ids:
                continue
            n_total += 1
            ms_path = os.path.join(ms_dir, uid, f"{qid}_label.json")
            if not os.path.exists(ms_path):
                continue
            ms = load_json(ms_path)
            oracle = ms["ms_label"]
            evidence_list = q.get("evidence_session_ids", [])  # preserve source order
            evidence = set(evidence_list)
            base_rank = retriever.get_rank(uid, q["query"], evidence, window=retriever.default_top_k)
            full_rank = retriever.full_rank(uid, q["query"], evidence)
            extra = q.get("extra") or {}
            qdate = extra.get("question_date") or extra.get("unified_date")
            anchors.append({
                "user_id": uid,
                "query_id": qid,
                "query": q["query"],
                "gold_answer": q["answer"],
                "gold_aliases": [q["answer"]],
                "gold_evidence_ids": list(evidence_list),
                "oracle_label": oracle,
                "cartridge_path": cpath,
                "base_rank": base_rank,
                "full_rank": full_rank,
                "question_date": qdate,
            })

    with open(out_path, "w", encoding="utf-8") as f:
        for a in anchors:
            f.write(json.dumps(a, ensure_ascii=False) + "\n")

    from collections import Counter
    by_ms = Counter(a["oracle_label"] for a in anchors)
    in_window = sum(1 for a in anchors if a["base_rank"] != -1)
    logger.info(f"Exported {len(anchors)} anchors → {out_path}")
    logger.info(f"  by oracle MS: {dict(by_ms)}")
    logger.info(f"  base_rank in top-10 window: {in_window}/{len(anchors)}")
    logger.info(f"  total queries seen {n_total}, users w/o cartridge {n_no_cart}")


if __name__ == "__main__":
    main()