#!/usr/bin/env python3
"""Unsloth SFT on Kaggle T4 for SKT-ST-X-10B-MoE.

Unsloth's 4-bit loading is memory-efficient (fixes the CUDA OOM that plain
transformers + bitsandbytes hits on a 14.5GB T4).

Data: /root/baap-data/shard_*.jsonl.gz  ({"messages": [...]} format)
Model: /root/model (WORKINGPLACE/SKT-ST-X-10B-MoE)

Usage (Kaggle):
    python unsloth_train.py --data /root/baap-data --model /root/model \
        --out /root/skt-sft --steps 2000
"""
import argparse, glob, os, sys, time

SKT_TEMPLATE = (
    "{% for message in messages %}"
    "{% if message['role'] == 'system' %}{% if message['content'] %}"
    "{{'### System:\\n' + message['content'] + '\\n'}}{% endif %}"
    "{% elif message['role'] == 'user' %}{{'### User:\\n' + message['content'] + '\\n'}}"
    "{% elif message['role'] == 'assistant' %}"
    "{{'### Assistant:\\n' + message['content'] + eos_token + '\\n'}}"
    "{% endif %}{% if loop.last and add_generation_prompt %}{{ '### Assistant:\\n' }}"
    "{% endif %}{% endfor %}"
)


def parse_args():
    p = argparse.ArgumentParser()
    p.add_argument("--model", default="/root/model")
    p.add_argument("--data", default="/root/baap-data")
    p.add_argument("--out", default="/root/skt-sft")
    p.add_argument("--steps", type=int, default=2000)
    p.add_argument("--batch", type=int, default=4)
    p.add_argument("--accum", type=int, default=2)
    p.add_argument("--lr", type=float, default=2e-4)
    p.add_argument("--max-len", type=int, default=2048)
    p.add_argument("--lora-r", type=int, default=64)
    p.add_argument("--lora-alpha", type=int, default=128)
    p.add_argument("--lora-experts", action="store_true")
    p.add_argument("--warmup", type=int, default=100)
    p.add_argument("--save-steps", type=int, default=500)
    p.add_argument("--seed", type=int, default=42)
    p.add_argument("--limit", type=int, default=0)
    p.add_argument("--resume", action="store_true")
    return p.parse_args()


def main():
    args = parse_args()

    from unsloth import FastLanguageModel
    from unsloth.chat_templates import train_on_responses_only
    from trl import SFTConfig, SFTTrainer
    from datasets import load_dataset

    print("[1/4] loading %s (Unsloth 4-bit)" % args.model, flush=True)
    model, tok = FastLanguageModel.from_pretrained(
        model_name=args.model,
        max_seq_length=args.max_len,
        load_in_4bit=True,
        dtype=None,                     # auto (T4 -> fp16)
    )
    if getattr(tok, "chat_template", None) is None:
        tok.chat_template = SKT_TEMPLATE
    if tok.pad_token is None:
        tok.pad_token = tok.eos_token
    print("[1/4] model loaded", flush=True)

    targets = ["q_proj", "k_proj", "v_proj", "o_proj"]
    if args.lora_experts:
        targets += ["w1", "w2", "w3"]
    model = FastLanguageModel.get_peft_model(
        model, r=args.lora_r, target_modules=targets, lora_alpha=args.lora_alpha,
        lora_dropout=0.05, bias="none", use_gradient_checkpointing="unsloth",
        random_state=args.seed,
    )
    model.print_trainable_parameters()

    print("[2/4] loading dataset", flush=True)
    # robust: if the given path is missing, search common locations
    candidates = [args.data]
    if not os.path.exists(args.data):
        candidates += ["/root/baap-ds/data", "/root/baap-data",
                       "/root/baap-ds", "/root/data", "/root"]
    shards = []
    for c in candidates:
        if os.path.isdir(c):
            found = sorted(glob.glob(os.path.join(c, "**", "*.jsonl.gz"),
                                    recursive=True))
            if found:
                shards = found
                print("[2/4] found %d shards in %s" % (len(shards), c), flush=True)
                break
        elif os.path.isfile(c):
            shards = [c]
            break
    if not shards:
        sys.exit("no *.jsonl.gz found (tried: %s)" % ", ".join(candidates))
    ds = load_dataset("json", data_files=shards, split="train")
    if args.limit:
        ds = ds.select(range(args.limit))
    if "text" not in ds.column_names:
        ds = ds.map(lambda ex: {"text": tok.apply_chat_template(
            ex["messages"], tokenize=False)}, batched=False)
    print("[2/4] %s rows" % f"{len(ds):,}", flush=True)

    # T4 has no bf16 -> fp16
    import torch
    use_bf16 = torch.cuda.is_available() and torch.cuda.is_bf16_supported()
    print("[3/4] training %d steps | batch %d x accum %d | len %d | %s"
          % (args.steps, args.batch, args.accum, args.max_len,
             "bf16" if use_bf16 else "fp16"), flush=True)

    trainer = SFTTrainer(
        model=model, tokenizer=tok, train_dataset=ds,
        dataset_text_field="text", max_seq_length=args.max_len, packing=False,
        args=SFTConfig(
            output_dir=args.out, max_steps=args.steps,
            per_device_train_batch_size=args.batch,
            gradient_accumulation_steps=args.accum,
            learning_rate=args.lr, lr_scheduler_type="cosine",
            warmup_steps=args.warmup, weight_decay=0.0,
            logging_steps=10, save_steps=args.save_steps,
            save_total_limit=2, save_only_model=True,
            bf16=use_bf16, fp16=(not use_bf16),
            optim="adamw_8bit", seed=args.seed, report_to=[],
        ),
    )
    # loss only on the assistant turn
    trainer = train_on_responses_only(
        trainer, instruction_part="### User:\n", response_part="### Assistant:\n")

    t0 = time.time()
    trainer.train(resume_from_checkpoint=args.resume or None)
    print("[4/4] done in %.0fs (%.2fh)" % (time.time() - t0,
                                           (time.time() - t0) / 3600), flush=True)
    model.save_pretrained(args.out)
    tok.save_pretrained(args.out)
    print("[4/4] LoRA adapter -> %s" % args.out, flush=True)
    print("[4/4] merge 16-bit with: model.save_pretrained_merged('%s-merged', tokenizer=tok)" % args.out,
          flush=True)


if __name__ == "__main__":
    main()