#!/usr/bin/env python3
"""LoRA fine-tune of Qwen 3.5 on Viperclaw examples (see vc_sft.py), plain transformers + peft.

Only the agent's turns in each example are trained on. The language-model head is applied to those positions only,
so long conversations fit in memory. Adapters are saved as training goes and the run resumes from the newest one.

usage: train_lora.py --examples ex.jsonl --model Qwen/Qwen3.5-9B --out DIR [--epochs 2] [--max-steps 0] [--lr 1e-4]
                     [--rank 32] [--accum 8] [--max-tokens 16384] [--save-every 25] [--merge-to DIR] [--limit 0]
"""
import argparse
import glob
import json
import math
import os
import random
import re
import shutil
import sys
import time

import torch

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from vc_sft import render  # noqa: E402

p = argparse.ArgumentParser()
p.add_argument("--examples", required=True)
p.add_argument("--model", required=True)
p.add_argument("--out", required=True)
p.add_argument("--epochs", type=float, default=2.0)
p.add_argument("--max-steps", type=int, default=0)
p.add_argument("--lr", type=float, default=1e-4)
p.add_argument("--rank", type=int, default=32)
p.add_argument("--accum", type=int, default=8)
p.add_argument("--max-tokens", type=int, default=16384)
p.add_argument("--save-every", type=int, default=25)
p.add_argument("--merge-to", default="")
p.add_argument("--limit", type=int, default=0)
p.add_argument("--seed", type=int, default=3407)
a = p.parse_args()

from peft import LoraConfig, PeftModel, get_peft_model  # noqa: E402
from transformers import AutoModelForImageTextToText, AutoTokenizer  # noqa: E402

cuda = torch.cuda.is_available()
dev = "cuda" if cuda else "cpu"
dtype = torch.bfloat16 if cuda else torch.float32
os.makedirs(a.out, exist_ok=True)
tok = AutoTokenizer.from_pretrained(a.model)

# ---------------------------------------------------------------- data
rows = [json.loads(line) for line in open(a.examples)]
random.Random(a.seed).shuffle(rows)
if a.limit:
    rows = rows[:a.limit]
data, too_long = [], 0
for e in rows:
    r = render(e, tok, a.max_tokens)
    if r is None:
        too_long += 1
        continue
    data.append((torch.tensor(r["input_ids"]), torch.tensor(r["labels"])))
total_tokens = sum(len(x) for x, _ in data)
steps_per_epoch = math.ceil(len(data) / a.accum)
total_steps = a.max_steps or math.ceil(steps_per_epoch * a.epochs)
print("DATA: %d examples (%d too long) | %.1fM tokens per epoch | %d trained-on tokens per example on average | %d optimizer steps planned" % (
    len(data), too_long, total_tokens / 1e6, sum(int((y != -100).sum()) for _, y in data) / max(1, len(data)), total_steps), flush=True)
if not data:
    raise SystemExit("TRAIN FAILED: no usable examples")

# ---------------------------------------------------------------- model
t0 = time.time()
model = AutoModelForImageTextToText.from_pretrained(a.model, dtype=dtype)
model.to(dev)
targets = r".*language_model.*\.(q_proj|k_proj|v_proj|o_proj|in_proj_qkv|in_proj_z|out_proj|gate_proj|up_proj|down_proj)"
done = sorted(glob.glob(os.path.join(a.out, "checkpoint-*")), key=lambda d: int(re.search(r"(\d+)$", d).group(1)))
done = [d for d in done if os.path.isfile(os.path.join(d, "adapter_model.safetensors")) and os.path.isfile(os.path.join(d, "state.json"))]
start_step = 0
if done:
    model = PeftModel.from_pretrained(model, done[-1], is_trainable=True)
    start_step = json.load(open(os.path.join(done[-1], "state.json")))["step"]
    print("RESUMING from", done[-1], "at step", start_step, flush=True)
else:
    model = get_peft_model(model, LoraConfig(r=a.rank, lora_alpha=a.rank, lora_dropout=0.0, bias="none", target_modules=targets))
core = model.get_base_model()
core.gradient_checkpointing_enable()
core.enable_input_require_grads()
params = [q for q in model.parameters() if q.requires_grad]
print("MODEL: loaded in %ds on %s | trainable %.1fM of %.0fM parameters" % (
    time.time() - t0, dev, sum(q.numel() for q in params) / 1e6, sum(q.numel() for q in model.parameters()) / 1e6), flush=True)
opt = torch.optim.AdamW(params, lr=a.lr, weight_decay=0.01)
warmup = max(1, min(10, total_steps // 10))


def lr_at(step):
    if step < warmup:
        return a.lr * (step + 1) / warmup
    return a.lr * 0.5 * (1 + math.cos(math.pi * (step - warmup) / max(1, total_steps - warmup)))


def loss_on(ids, labels):
    """Cross-entropy on the labelled positions only: the vocabulary head never sees the rest of the sequence."""
    ids, labels = ids.to(dev), labels.to(dev)
    hidden = core.model(input_ids=ids[None]).last_hidden_state[0]
    pos = (labels[1:] != -100).nonzero().squeeze(-1)            # position i predicts token i + 1
    logits = core.lm_head(hidden[pos]).float()
    return torch.nn.functional.cross_entropy(logits, labels[1:][pos])


def save(step, name=None):
    d = os.path.join(a.out, name or "checkpoint-%d" % step)
    tmp = d + ".tmp"
    shutil.rmtree(tmp, ignore_errors=True)
    model.save_pretrained(tmp)
    json.dump({"step": step, "examples": len(data), "accum": a.accum}, open(os.path.join(tmp, "state.json"), "w"))
    shutil.rmtree(d, ignore_errors=True)
    os.replace(tmp, d)
    for old in sorted(glob.glob(os.path.join(a.out, "checkpoint-*")), key=lambda x: int(re.search(r"(\d+)$", x).group(1)))[:-2]:
        shutil.rmtree(old, ignore_errors=True)


# ---------------------------------------------------------------- train
model.train()
order = []
while len(order) < total_steps * a.accum:
    epoch = list(range(len(data)))
    random.Random(a.seed + len(order)).shuffle(epoch)
    order += epoch
t_start, seen_tokens, running = time.time(), 0, []
for step in range(start_step, total_steps):
    for g in opt.param_groups:
        g["lr"] = lr_at(step)
    step_loss = 0.0
    for k in range(a.accum):
        ids, labels = data[order[step * a.accum + k]]
        with torch.autocast(dev, dtype=torch.bfloat16, enabled=cuda):
            loss = loss_on(ids, labels) / a.accum
        loss.backward()
        step_loss += loss.item()
        seen_tokens += len(ids)
    torch.nn.utils.clip_grad_norm_(params, 1.0)
    opt.step()
    opt.zero_grad(set_to_none=True)
    running = (running + [step_loss])[-10:]
    elapsed = time.time() - t_start
    per_step = elapsed / (step - start_step + 1)
    if step < start_step + 3 or (step + 1) % 5 == 0 or step + 1 == total_steps:
        mem = " | GPU peak %.1f GB" % (torch.cuda.max_memory_allocated() / 2**30) if cuda else ""
        print("step %d/%d | loss %.4f (last 10: %.4f) | %.0f tokens/s | %.0fs per step | about %d min left%s" % (
            step + 1, total_steps, step_loss, sum(running) / len(running), seen_tokens / elapsed, per_step,
            per_step * (total_steps - step - 1) / 60, mem), flush=True)
    if (step + 1) % a.save_every == 0 and step + 1 < total_steps:
        save(step + 1)
save(total_steps, "final")
print("ADAPTER SAVED:", os.path.join(a.out, "final"), flush=True)

# ---------------------------------------------------------------- one sample answer, then the merged model for serving
model.eval()
e = rows[0]
prompt = tok.apply_chat_template(e["messages"][:e["chain_start"]], tools=e["tools"], tokenize=False, add_generation_prompt=True)
with torch.no_grad(), torch.autocast(dev, dtype=torch.bfloat16, enabled=cuda):
    enc = tok(prompt, return_tensors="pt", add_special_tokens=False).to(dev)
    out = model.generate(**enc, max_new_tokens=160 if cuda else 24, do_sample=False)
print("SAMPLE ANSWER after training:\n" + tok.decode(out[0][enc["input_ids"].shape[1]:]), flush=True)
if a.merge_to:
    merged = model.merge_and_unload()
    merged.save_pretrained(a.merge_to, safe_serialization=True)
    tok.save_pretrained(a.merge_to)
    src = a.model if os.path.isdir(a.model) else None
    if src is None:
        from huggingface_hub import snapshot_download
        src = snapshot_download(a.model, allow_patterns=["*.json", "*.jinja", "*.txt"])
    for f in os.listdir(src):                       # processor and template files the server expects next to the weights
        if f.endswith((".json", ".jinja", ".txt")) and not os.path.exists(os.path.join(a.merge_to, f)):
            shutil.copy(os.path.join(src, f), os.path.join(a.merge_to, f))
    print("MERGED MODEL SAVED:", a.merge_to, flush=True)
print("TRAIN DONE", flush=True)