from __future__ import annotations

import argparse
import os

from transformers import Trainer, TrainingArguments, set_seed

from .common import load_rows
from .data import DriveDataset, SFTCollator
from .modeling import (
    load_base_model,
    load_processor,
    prepare_trainable_model,
    trainable_parameter_summary,
)


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="LoRA SFT for Qwen3.5 VLM")
    parser.add_argument("--model", required=True)
    parser.add_argument("--data-dir", required=True)
    parser.add_argument("--output-dir", required=True)
    parser.add_argument("--adapter-path", default=None)
    parser.add_argument("--train-split", default="train")
    parser.add_argument("--val-split", default="val")
    parser.add_argument("--num-views", type=int, default=1)
    parser.add_argument("--max-length", type=int, default=2048)
    parser.add_argument("--max-steps", type=int, default=1000)
    parser.add_argument("--learning-rate", type=float, default=2e-4)
    parser.add_argument("--gradient-accumulation-steps", type=int, default=16)
    parser.add_argument("--lora-r", type=int, default=16)
    parser.add_argument("--lora-alpha", type=int, default=32)
    parser.add_argument("--lora-dropout", type=float, default=0.05)
    parser.add_argument("--eval-steps", type=int, default=100)
    parser.add_argument("--save-steps", type=int, default=100)
    parser.add_argument("--logging-steps", type=int, default=5)
    parser.add_argument("--seed", type=int, default=42)
    parser.add_argument("--attn-implementation", default="sdpa")
    parser.add_argument("--deepspeed", default=None)
    parser.add_argument("--freeze-vision", action=argparse.BooleanOptionalAction, default=True)
    return parser.parse_args()


def main() -> None:
    args = parse_args()
    set_seed(args.seed)
    processor = load_processor(args.model)
    model = load_base_model(args.model, attn_implementation=args.attn_implementation)
    model = prepare_trainable_model(
        model,
        adapter_path=args.adapter_path,
        lora_r=args.lora_r,
        lora_alpha=args.lora_alpha,
        lora_dropout=args.lora_dropout,
        freeze_vision=args.freeze_vision,
    )
    trainable, total = trainable_parameter_summary(model)
    print(f"trainable_parameters={trainable:,}/{total:,} ({trainable / total:.4%})")

    train_dataset = DriveDataset(load_rows(args.data_dir, args.train_split))
    eval_dataset = DriveDataset(load_rows(args.data_dir, args.val_split))
    collator = SFTCollator(processor, args.num_views, args.max_length)
    training_args = TrainingArguments(
        output_dir=args.output_dir,
        per_device_train_batch_size=1,
        per_device_eval_batch_size=1,
        gradient_accumulation_steps=args.gradient_accumulation_steps,
        learning_rate=args.learning_rate,
        max_steps=args.max_steps,
        warmup_ratio=0.03,
        lr_scheduler_type="cosine",
        bf16=True,
        tf32=True,
        gradient_checkpointing=True,
        eval_strategy="steps",
        eval_steps=args.eval_steps,
        save_strategy="steps",
        save_steps=args.save_steps,
        save_total_limit=2,
        logging_steps=args.logging_steps,
        report_to="none",
        remove_unused_columns=False,
        dataloader_num_workers=0,
        ddp_find_unused_parameters=False,
        deepspeed=args.deepspeed,
        seed=args.seed,
    )
    trainer = Trainer(
        model=model,
        args=training_args,
        train_dataset=train_dataset,
        eval_dataset=eval_dataset,
        data_collator=collator,
    )
    trainer.train(resume_from_checkpoint=False)
    final_dir = os.path.join(args.output_dir, "final_adapter")
    trainer.save_model(final_dir)
    processor.save_pretrained(final_dir)
    print(f"SFT_DONE adapter={final_dir}")


if __name__ == "__main__":
    main()