"""Probe MS-tag probabilities at the decision position (诊断 train-vs-test 全NM 矛盾).

[MS:SM/PM/VM/NM] share the first 3 tokens ('[', 'MS', ':') and diverge ONLY at the 4th
token (SM=9501/PM=8795/VM=11187/NM=37325). We force-feed the decision prompt + "[MS:" and
read the model's probability over those 4 token ids — the model's TRUE belief over memory
states, independent of sampling temperature.

If NM ≈ 51% with others 15-20% (matching the training-PredMS distribution under temp=1.0):
  → no bug. Greedy eval (temp=0) just argmaxes the "NM slightly ahead" distribution into
    100% NM. Fix = sample at eval, or accept it.
If NM ≈ 99%, others ≈ 0:
  → train/test decision distributions genuinely differ (cartridge/prompt OOD) — a real bug.

Usage: python scripts/train/probe_ms_logits.py --lora-dir checkpoints/dapo/Qwen3-8B/step20 --max-users 40
"""

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__))))
os.environ.setdefault("CARTRIDGES_DIR", os.path.join(PROJECT_ROOT, "cartridges-lib"))
os.environ.setdefault("CARTRIDGES_OUTPUT_DIR", os.path.join(PROJECT_ROOT, "checkpoints/cartridge"))

from src.utils import load_json, load_yaml, set_seed, setup_logger

logger = setup_logger(__name__)
MS_TOK = {"SM": 9501, "PM": 8795, "VM": 11187, "NM": 37325}  # 4th token of [MS:XX]


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


def main():
    import torch
    from cartridges.cache import TrainableCache
    from src.model.capability_lora import load_capability_lora
    from src.model.metamem_model import load_metamem_base
    from src.model.prompts import format_decision_prompt
    from src.utils.cartridge_utils import find_cartridge_path

    ap = argparse.ArgumentParser()
    ap.add_argument("--config", default="configs/eval/eval.yaml")
    ap.add_argument("--lora-dir", default="checkpoints/dapo/Qwen3-8B/step20")
    ap.add_argument("--max-users", type=int, default=40)
    ap.add_argument("--no-cartridge", action="store_true")
    args = ap.parse_args()

    cfg = load_yaml(_r(args.config))
    set_seed(42)
    mm, tok = load_metamem_base(
        base_cfg_path=_r(cfg["base_model_config"]), lora_cfg_path=_r(cfg["lora_config"]),
        project_root=PROJECT_ROOT, adapter_names=("policy",), set_trainable=None,
    )
    if os.path.exists(os.path.join(_r(args.lora_dir), "capability_lora.safetensors")):
        load_capability_lora(mm.model, _r(args.lora_dir), adapter_name="policy")
        logger.info(f"Loaded LoRA from {args.lora_dir}")
    mm.set_adapter("policy")
    mm.model.eval()

    dataset = load_json(_r(cfg["dataset"]))
    cartridge_dir = _r(cfg["cartridge_dir"])

    # prefix tokens for "[MS:" (3 tokens) appended after the decision prompt
    ms_prefix = tok.encode("[MS:", add_special_tokens=False)  # [58, 4826, 25]
    device = mm.device

    agg = {k: 0.0 for k in MS_TOK}
    argmax_count = {k: 0 for k in MS_TOK}
    n = 0
    from cartridges.generation import flex_generate  # ensure same model path warm

    for ui, ud in enumerate(dataset):
        if ui >= args.max_users:
            break
        uid = ud["user_id"]
        cpath = find_cartridge_path(cartridge_dir, uid)
        if cpath is None:
            continue
        if args.no_cartridge:
            mm.set_cartridge(None)
        else:
            cache = TrainableCache.from_pretrained(cpath, device="cuda").to("cuda")
            mm.set_cartridge(cache)
        for q in ud["queries"]:
            qdate = (q.get("extra") or {}).get("question_date")
            prompt = format_decision_prompt(q["query"], tok, qdate)
            ids = tok.encode(prompt, add_special_tokens=False) + ms_prefix
            input_ids = torch.tensor([ids], dtype=torch.long, device=device)
            if not args.no_cartridge:
                mm.set_cartridge(cache)
            with torch.no_grad():
                # same call shape as flex_generate (cartridge passed via past_key_values)
                seq_ids = torch.zeros(input_ids.shape[1], dtype=torch.long, device=device)
                position_ids = torch.arange(input_ids.shape[1], device=device)
                out = mm.model(
                    input_ids=input_ids[0], seq_ids=seq_ids, position_ids=position_ids,
                    past_key_values=mm.cache, use_cache=True, mode="generate",
                )
                logits = out.logits[0, -1].float() if out.logits.dim() == 3 else out.logits[-1].float()
                probs = torch.softmax(logits, dim=-1)
                if mm.cache is not None:
                    mm.cache.clear()
            p = {k: probs[v].item() for k, v in MS_TOK.items()}
            # renormalize over the 4 MS tokens (we care about RELATIVE belief)
            z = sum(p.values()) or 1.0
            pr = {k: p[k] / z for k in MS_TOK}
            for k in MS_TOK:
                agg[k] += pr[k]
            argmax_count[max(pr, key=pr.get)] += 1
            n += 1
            if n % 20 == 0:
                logger.info(f"...{n}")

    print(f"\n=== MS belief at decision position (LME-S, {n} queries) ===")
    print("平均概率(在4个MS token上重归一化):")
    for k in ["SM", "PM", "VM", "NM"]:
        print(f"  {k}: {agg[k]/n:.3f}")
    print("argmax(贪婪会选哪个)计数:")
    for k in ["SM", "PM", "VM", "NM"]:
        print(f"  {k}: {argmax_count[k]} ({argmax_count[k]/n:.1%})")


if __name__ == "__main__":
    main()