"""Step 9: Run SFT for the shared Capability LoRA.

Single GPU:
    python scripts/train/09_run_sft.py
    python scripts/train/09_run_sft.py --config configs/train/sft.yaml
    # smoke (2 users):
    python scripts/train/09_run_sft.py --max-users 2 --phase-a-epochs 1 --phase-b-epochs 1

8-GPU data parallel (TensorBoard auto-detected via $TENSORBOARD_LOG_PATH):
    torchrun --standalone --nproc_per_node=8 scripts/train/09_run_sft.py
    # or use the launcher: bash scripts/train/run_sft_8gpu.sh
"""

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

from src.train.sft.sft_trainer import SFTTrainer
from src.utils import cleanup_distributed, load_yaml, set_seed, setup_distributed, setup_logger

logger = setup_logger(__name__)


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--config", default="configs/train/sft.yaml")
    ap.add_argument("--max-users", type=int, default=None, help="limit users (smoke)")
    ap.add_argument("--phase-a-epochs", type=int, default=None)
    ap.add_argument("--phase-b-epochs", type=int, default=None)
    ap.add_argument("--phase-c-epochs", type=int, default=None,
                    help="answer-supervision epochs (0=off, default from config)")
    ap.add_argument("--answer-samples-path", type=str, default=None,
                    help="08c output (default: sibling samples_with_answer.jsonl)")
    ap.add_argument("--output-dir", type=str, default=None)
    ap.add_argument("--monitor", action="store_true", help="run MS-acc monitor before/after")
    args = ap.parse_args()

    cfg_path = args.config if os.path.isabs(args.config) else os.path.join(PROJECT_ROOT, args.config)
    cfg = load_yaml(cfg_path)
    if args.phase_a_epochs is not None:
        cfg["phase_a_epochs"] = args.phase_a_epochs
    if args.phase_b_epochs is not None:
        cfg["phase_b_epochs"] = args.phase_b_epochs
    if args.phase_c_epochs is not None:
        cfg["phase_c_epochs"] = args.phase_c_epochs
    if args.answer_samples_path is not None:
        cfg["answer_samples_path"] = args.answer_samples_path
    if args.output_dir is not None:
        cfg["output_dir"] = args.output_dir

    # init distributed FIRST (no-op when not under torchrun) so trainer sees rank/world
    dist_ctx = setup_distributed()
    set_seed(cfg.get("seed", 42))
    if dist_ctx["is_distributed"]:
        logger.info(f"Distributed: rank {dist_ctx['rank']}/{dist_ctx['world_size']} "
                    f"local_rank={dist_ctx['local_rank']}")

    try:
        trainer = SFTTrainer(cfg, PROJECT_ROOT)

        if args.max_users is not None:
            # smoke: limit to the first N users PRESENT ON THIS RANK's shard
            shard_users = sorted({trainer.dataset.samples[i]["user_id"] for i in trainer.local_indices})
            keep = set(shard_users[: args.max_users])
            trainer.local_indices = [
                i for i in trainer.local_indices if trainer.dataset.samples[i]["user_id"] in keep
            ]
            logger.info(f"[smoke] rank limited to {len(keep)} users, {len(trainer.local_indices)} samples")

        if args.monitor:
            logger.info("Monitor BEFORE training:")
            trainer.monitor_ms_acc(cfg.get("monitor_sample_size", 64), global_step=0, tag="monitor_before")

        trainer.run()

        if args.monitor:
            logger.info("Monitor AFTER training:")
            trainer.monitor_ms_acc(cfg.get("monitor_sample_size", 64), global_step=0, tag="monitor_after")
        trainer.close()
    finally:
        cleanup_distributed()


if __name__ == "__main__":
    main()