#!/usr/bin/env python
from __future__ import annotations

import argparse
import sys
from pathlib import Path

ROOT = Path(__file__).resolve().parents[1]
if str(ROOT) not in sys.path:
    sys.path.insert(0, str(ROOT))

from datasets import load_dataset
from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    DataCollatorForLanguageModeling,
    Trainer,
    TrainingArguments,
)

from spec_rag.llm_lora import LoRAConfigSpec, build_lora_model


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Fine-tune Llama/Gemma with LoRA on RAG data.")
    parser.add_argument("--model-name", required=True)
    parser.add_argument("--train-jsonl", required=True)
    parser.add_argument("--eval-jsonl", default=None)
    parser.add_argument("--output-dir", required=True)
    parser.add_argument("--max-length", type=int, default=1024)
    parser.add_argument("--batch-size", type=int, default=2)
    parser.add_argument("--epochs", type=int, default=1)
    parser.add_argument("--lr", type=float, default=2e-4)
    parser.add_argument("--load-in-4bit", action="store_true")
    parser.add_argument("--use-chat-template", action="store_true")
    return parser.parse_args()


def main() -> None:
    args = parse_args()
    out_dir = Path(args.output_dir)
    out_dir.mkdir(parents=True, exist_ok=True)

    tokenizer = AutoTokenizer.from_pretrained(args.model_name, use_fast=True)
    if tokenizer.pad_token is None:
        tokenizer.pad_token = tokenizer.eos_token

    lora_cfg = LoRAConfigSpec()
    model = build_lora_model(
        args.model_name,
        lora_cfg,
        load_in_4bit=args.load_in_4bit,
    )

    data_files = {"train": args.train_jsonl}
    if args.eval_jsonl:
        data_files["validation"] = args.eval_jsonl
    dataset = load_dataset("json", data_files=data_files)

    def format_text(example):
        if "messages" in example:
            if args.use_chat_template and hasattr(tokenizer, "apply_chat_template"):
                text = tokenizer.apply_chat_template(example["messages"], tokenize=False)
            else:
                msgs = example["messages"]
                text = "\n".join(f"{m['role']}: {m['content']}" for m in msgs)
        else:
            prompt = example.get("prompt", "")
            target = example.get("target", "")
            text = prompt + target
        return {"text": text}

    dataset = dataset.map(format_text, remove_columns=dataset["train"].column_names)

    def tokenize(batch):
        return tokenizer(
            batch["text"],
            truncation=True,
            max_length=args.max_length,
            padding="max_length",
        )

    tokenized = dataset.map(tokenize, batched=True)
    data_collator = DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm=False)

    train_args = TrainingArguments(
        output_dir=str(out_dir),
        per_device_train_batch_size=args.batch_size,
        per_device_eval_batch_size=args.batch_size,
        learning_rate=args.lr,
        num_train_epochs=args.epochs,
        evaluation_strategy="steps" if args.eval_jsonl else "no",
        eval_steps=500 if args.eval_jsonl else None,
        save_strategy="epoch",
        save_total_limit=3,  # Keep only last 3 checkpoints
        logging_steps=50,
        report_to=[],
        warmup_steps=100,
        fp16=True,  # Use mixed precision for faster training
        gradient_checkpointing=True,  # Save memory
    )

    trainer = Trainer(
        model=model,
        args=train_args,
        train_dataset=tokenized["train"],
        eval_dataset=tokenized.get("validation"),
        data_collator=data_collator,
        tokenizer=tokenizer,
    )
    trainer.train()
    trainer.save_model(str(out_dir))


if __name__ == "__main__":
    main()