"""SMOKE A — verify the PEFT+FlexQwen3 architecture is sound (biggest risk point).

Loads FlexQwen3 (original tokenizer), injects LoRA via inject_adapter_in_model,
wraps in MetaMemModel, loads u0001's cartridge, runs a forward + flex_generate.
Pass = no TypeError from PEFT, generation produces tokens, pseudo-token strings can
be emitted under the original tokenizer.

Requires a GPU.

Usage:
    python scripts/train/smoke_a_model.py --user-id u0001
"""

import argparse
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"))

import torch

from src.model.metamem_model import load_metamem_base
from src.model.prompts import format_decision_prompt
from src.model.tokenizer_utils import extract_control_strings
from src.utils.cartridge_utils import find_cartridge_path


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--user-id", default="u0001")
    ap.add_argument("--cartridge-dir", default="checkpoints/cartridge/Qwen3-8B")
    args = ap.parse_args()

    cartridge_dir = os.path.join(PROJECT_ROOT, args.cartridge_dir)

    print("[A] Loading MetaMem base (FlexQwen3 + injected LoRA)...")
    mm, tok = load_metamem_base(adapter_names=("policy",), set_trainable="policy")
    print("[A] Loaded. Model class:", mm.model.__class__.__name__)

    from cartridges.cache import TrainableCache

    cpath = find_cartridge_path(cartridge_dir, args.user_id)
    assert cpath is not None, f"No cartridge for {args.user_id} under {cartridge_dir}"
    print(f"[A] Cartridge: {cpath}")
    cache = TrainableCache.from_pretrained(cpath, device="cuda").to("cuda")
    mm.set_cartridge(cache)
    print(f"[A] cartridge tokens: {cache.num_cartridge_tokens()}")

    # Forward pass on a short decision prompt
    prompt = format_decision_prompt("What do you remember about me?", tok)
    ids = tok.encode(prompt, add_special_tokens=False)
    input_ids = torch.tensor(ids, device="cuda")
    seq_ids = torch.zeros_like(input_ids)
    position_ids = torch.arange(len(input_ids), device="cuda")

    with torch.no_grad():
        out = mm.forward(input_ids, seq_ids, position_ids, mode="train")
    print("[A] forward OK. logits shape:", tuple(out.logits.shape))
    mm.clear_cache()

    # flex_generate
    from cartridges.generation import flex_generate

    gen = flex_generate(
        model=mm.model,
        tokenizer=tok,
        input_ids=input_ids,
        seq_ids=seq_ids,
        position_ids=position_ids,
        cache=cache,
        max_new_tokens=64,
        temperature=1.0,
    )
    gen_ids = list(gen.values())[0]
    text = tok.decode(gen_ids)
    print("[A] generated text:", repr(text[:300]))

    # Confirm pseudo-token strings tokenize/detokenize cleanly under original vocab
    sample = "[MS:PM] [ACT:REWRITE] some query [EOQ]"
    rt = tok.decode(tok.encode(sample, add_special_tokens=False))
    parsed = extract_control_strings(rt)
    print("[A] roundtrip pseudo-token:", repr(rt))
    print("[A] parsed:", parsed)
    assert parsed["valid"], "pseudo-token parse failed"

    print("\n[A] SMOKE A PASSED ✅")


if __name__ == "__main__":
    main()