"""Train a citation-ranking student: Qwen3-Reranker + LoRA, pairwise logistic loss within each group.

    python code/train_student.py --labels jev_labels.jsonl --base Qwen/Qwen3-Reranker-4B \
        --out runs/student_4b --seed 42
    python code/train_student.py --base Qwen/Qwen3-Reranker-4B --zero-shot --out runs/qwen4b_zs

--labels is the output of label_jev.py (target = jev / 5) or any JSONL with the fields of
benchmark/training_groups.jsonl plus a numeric "target". The script trains on the "natural" groups
(add --include-mixed for the cross-query groups), saves the adapter, and writes predictions on
benchmark/passages.jsonl in the format read by code/reproduce_tables.py. About two hours for the
4B on one RTX 3090."""
import argparse
import json
import os
import random
from collections import defaultdict

import torch

ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
PREFIX = ("<|im_start|>system\nJudge whether the Document meets the requirements based on the Query "
          "and the Instruct provided. Note that the answer can only be \"yes\" or \"no\".<|im_end|>\n"
          "<|im_start|>user\n")
SUFFIX = "<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\n"
INSTRUCT = ("Given a user query, judge whether this passage would be cited by a generative answer "
            "engine (Perplexity, ChatGPT Search, Gemini) writing an answer to the query")


def encode(tok, pairs, max_len, device):
    # Truncate the document before assembling, so the yes/no position is never cut off.
    texts = []
    for q, d in pairs:
        ids = tok(d, add_special_tokens=False).input_ids
        if len(ids) > max_len - 160:
            d = tok.decode(ids[:max_len - 160])
        texts.append(PREFIX + f"<Instruct>: {INSTRUCT}\n<Query>: {q}\n<Document>: {d}" + SUFFIX)
    return tok(texts, padding=True, return_tensors="pt").to(device)


def logodds(model, enc, yes, no):
    last = model(**enc).logits[:, -1, :]
    return last[:, yes] - last[:, no]


def load_groups(path, include_mixed, subset, seed):
    rows = [json.loads(l) for l in open(path)]
    rows = [r for r in rows if include_mixed or r["kind"] == "natural"]
    for r in rows:
        r.setdefault("target", r["jev"] / 5.0)
    if subset < 1.0:
        qs = sorted({r["query"] for r in rows})
        keep = set(random.Random(seed).sample(qs, round(len(qs) * subset)))
        rows = [r for r in rows if r["query"] in keep]
    groups = defaultdict(list)
    for r in rows:
        groups[r["group"]].append(r)
    return [g for g in groups.values() if len(g) >= 2]


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--base", default="Qwen/Qwen3-Reranker-4B")
    ap.add_argument("--labels")
    ap.add_argument("--out", required=True)
    ap.add_argument("--zero-shot", action="store_true")
    ap.add_argument("--include-mixed", action="store_true")
    ap.add_argument("--subset", type=float, default=1.0, help="share of training queries kept")
    ap.add_argument("--epochs", type=int, default=4)
    ap.add_argument("--lr", type=float, default=1e-4)
    ap.add_argument("--max-len", type=int, default=1024)
    ap.add_argument("--min-diff", type=float, default=0.05, help="pairs with a smaller target gap are skipped")
    ap.add_argument("--seed", type=int, default=42)
    args = ap.parse_args()
    random.seed(args.seed)
    torch.manual_seed(args.seed)
    os.makedirs(args.out, exist_ok=True)
    device = "cuda" if torch.cuda.is_available() else "cpu"
    from transformers import AutoModelForCausalLM, AutoTokenizer
    tok = AutoTokenizer.from_pretrained(args.base, padding_side="left")
    model = AutoModelForCausalLM.from_pretrained(args.base, torch_dtype=torch.bfloat16).to(device)
    yes, no = tok.convert_tokens_to_ids("yes"), tok.convert_tokens_to_ids("no")

    if not args.zero_shot:
        from peft import LoraConfig, get_peft_model
        model.gradient_checkpointing_enable()
        model.enable_input_require_grads()
        model = get_peft_model(model, LoraConfig(
            r=16, lora_alpha=32, lora_dropout=0.05, bias="none", task_type="CAUSAL_LM",
            target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]))
        groups = load_groups(args.labels, args.include_mixed, args.subset, args.seed)
        params = [p for p in model.parameters() if p.requires_grad]
        optim = torch.optim.AdamW(params, lr=args.lr)
        total = len(groups) * args.epochs
        sched = torch.optim.lr_scheduler.LambdaLR(optim, lambda s: max(0.0, 1.0 - s / total))
        for ep in range(args.epochs):
            model.train()
            order = list(range(len(groups)))
            random.Random(args.seed + ep).shuffle(order)
            for gi in order:
                g = groups[gi]
                lo = logodds(model, encode(tok, [(r["query"], r["text"]) for r in g], args.max_len, device),
                             yes, no).float()
                t = torch.tensor([r["target"] for r in g], device=device)
                diff = t[:, None] - t[None, :]
                mask = diff > args.min_diff
                if not mask.any():
                    continue
                w = diff[mask]
                loss = (w * torch.nn.functional.softplus(-(lo[:, None] - lo[None, :])[mask])).sum() / w.sum()
                loss.backward()
                torch.nn.utils.clip_grad_norm_(params, 1.0)
                optim.step()
                sched.step()
                optim.zero_grad()
            print(f"epoch {ep + 1}/{args.epochs} done", flush=True)
        model.save_pretrained(os.path.join(args.out, "adapter"))

    model.eval()
    rows = [json.loads(l) for l in open(os.path.join(ROOT, "benchmark", "passages.jsonl"))]
    preds = {}
    with torch.no_grad():
        for i in range(0, len(rows), 16):
            chunk = rows[i:i + 16]
            lo = logodds(model, encode(tok, [(r["query"], r["text"]) for r in chunk], args.max_len, device), yes, no)
            preds.update({f"{r['query']}||{r['src_idx']}": v for r, v in zip(chunk, lo.float().cpu().tolist())})
    json.dump(preds, open(os.path.join(args.out, "predictions.json"), "w"))
    print(f"{len(preds)} predictions written to {args.out}/predictions.json")


if __name__ == "__main__":
    main()