#!/usr/bin/env python3
"""LoRA fine-tuning entrypoint for RunPod GPU pods."""

from __future__ import annotations

import json
import os
import re
from pathlib import Path

ROOT = Path(__file__).resolve().parents[1]
DEFAULT_CONFIG = ROOT / "config" / "training.yaml"


def load_config(path: Path) -> dict:
    import yaml

    text = path.read_text()

    def repl(match: re.Match[str]) -> str:
        var, default = match.group(1), match.group(2) or ""
        return os.environ.get(var, default)

    text = re.sub(r"\$\{([^}:]+)(?::-([^}]*))?\}", repl, text)
    return yaml.safe_load(text)


def format_example(row: dict) -> dict:
    messages = row["messages"]
    return {"messages": messages}


def main() -> None:
    import torch
    from datasets import Dataset, load_dataset
    from peft import LoraConfig, get_peft_model
    from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments
    from trl import SFTTrainer

    config_path = Path(os.environ.get("CONFIG_PATH", DEFAULT_CONFIG))
    cfg = load_config(config_path)
    train_cfg = cfg["training"]

    data_dir = ROOT / "data" / "processed"
    train_file = data_dir / "train.jsonl"
    if not train_file.exists():
        fallback = ROOT / cfg["dataset"]["output_file"]
        if fallback.exists():
            train_file = fallback
        else:
            raise SystemExit(f"No training data at {data_dir}/train.jsonl or {fallback}")

    rows = [json.loads(line) for line in train_file.read_text().splitlines() if line.strip()]
    dataset = Dataset.from_list([format_example(r) for r in rows])

    val_file = data_dir / "val.jsonl"
    eval_dataset = None
    if val_file.exists():
        val_rows = [json.loads(line) for line in val_file.read_text().splitlines() if line.strip()]
        eval_dataset = Dataset.from_list([format_example(r) for r in val_rows])

    base_model = os.environ.get("BASE_MODEL", train_cfg["base_model"])
    output_dir = os.environ.get("OUTPUT_DIR", train_cfg["output_dir"])
    Path(output_dir).mkdir(parents=True, exist_ok=True)

    tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)
    if tokenizer.pad_token is None:
        tokenizer.pad_token = tokenizer.eos_token

    model = AutoModelForCausalLM.from_pretrained(
        base_model,
        torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
        device_map="auto",
        trust_remote_code=True,
    )

    lora_config = LoraConfig(
        r=int(train_cfg["lora_r"]),
        lora_alpha=int(train_cfg["lora_alpha"]),
        lora_dropout=float(train_cfg["lora_dropout"]),
        bias="none",
        task_type="CAUSAL_LM",
        target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
    )
    model = get_peft_model(model, lora_config)

    def formatting_func(batch):
        texts = []
        for messages in batch["messages"]:
            texts.append(
                tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=False)
            )
        return {"text": texts}

    formatted = dataset.map(formatting_func, batched=True, remove_columns=dataset.column_names)
    formatted_eval = None
    if eval_dataset is not None:
        formatted_eval = eval_dataset.map(
            formatting_func, batched=True, remove_columns=eval_dataset.column_names
        )

    max_steps = int(os.environ.get("RUNPOD_MAX_STEPS", "0"))
    training_args = TrainingArguments(
        output_dir=output_dir,
        num_train_epochs=float(train_cfg["num_train_epochs"]) if not max_steps else 1.0,
        max_steps=max_steps if max_steps > 0 else -1,
        per_device_train_batch_size=int(train_cfg["per_device_train_batch_size"]),
        gradient_accumulation_steps=int(train_cfg["gradient_accumulation_steps"]),
        learning_rate=float(train_cfg["learning_rate"]),
        warmup_ratio=float(train_cfg["warmup_ratio"]),
        logging_steps=int(train_cfg["logging_steps"]),
        save_steps=int(train_cfg["save_steps"]),
        save_total_limit=2,
        bf16=torch.cuda.is_available(),
        report_to="none",
        remove_unused_columns=False,
    )

    trainer = SFTTrainer(
        model=model,
        args=training_args,
        train_dataset=formatted,
        eval_dataset=formatted_eval,
        processing_class=tokenizer,
    )
    trainer.train()
    trainer.save_model(output_dir)
    tokenizer.save_pretrained(output_dir)

    meta = {
        "base_model": base_model,
        "train_examples": len(rows),
        "output_dir": output_dir,
    }
    Path(output_dir, "training_meta.json").write_text(json.dumps(meta, indent=2))
    print(json.dumps(meta, indent=2))


if __name__ == "__main__":
    main()