"""Train LFM or Qwen from this dataset with native TRL SFTTrainer."""
import argparse
import json
from pathlib import Path

from datasets import load_dataset
from huggingface_hub import HfApi, hf_hub_download
from transformers import AutoModelForCausalLM, AutoModelForImageTextToText, AutoTokenizer
from trl import SFTConfig, SFTTrainer
import torch

REPO = 'FineEnvs/SmolDataEnvs-multiharness-sft'
CONFIGS = {'lfm': 'lfm25_2_6b', 'qwen': 'qwen35_2b'}
HARNESSES = ['opencode', 'claude-code', 'codex', 'mini-swe-agent']


def load_training_data(model, config=None, revision='main', harness=None, common_tasks=False, limit=None):
    revision = HfApi().dataset_info(REPO, revision=revision).sha
    metadata_file = hf_hub_download(REPO, 'manifest.json', repo_type='dataset', revision=revision)
    manifest = json.loads(Path(metadata_file).read_text())
    model_config = CONFIGS[model]
    config = config or model_config
    if config in CONFIGS.values() and config != model_config:
        raise ValueError('Token IDs are specific to the model; choose the matching configuration.')
    data = load_dataset(REPO, config, split='train', revision=revision)
    if harness:
        data = data.filter(lambda row: row['harness'] == harness)
    if common_tasks:
        data = data.filter(lambda row: row['common_task'])
    if limit is not None:
        data = data.select(range(min(limit, len(data))))
    if not len(data):
        raise ValueError('The selected dataset is empty.')
    tokenized = config in CONFIGS.values()
    info = manifest['models'][model_config]
    tokenizer = AutoTokenizer.from_pretrained(info['model'], revision=info['model_revision'])
    original_template = tokenizer.chat_template
    training_template = None
    if tokenized:
        data = data.select_columns(['input_ids', 'labels'])
    else:
        def kwargs(row):
            if model == 'lfm':
                return {'chat_template_kwargs': {'preserve_thinking': True}}
            answer = row['completion'][0]
            content = answer.get('content') or ''
            thinking = bool(answer.get('reasoning_content')) or (isinstance(content, str) and '</think>' in content)
            return {'chat_template_kwargs': {'enable_thinking': thinking}}
        data = data.map(kwargs)
        data = data.select_columns(['prompt', 'completion', 'tools', 'chat_template_kwargs'])
        training_template = hf_hub_download(REPO, f'templates/{model_config}-training_chat_template.jinja', repo_type='dataset', revision=revision)
    return data, tokenizer, original_template, info, revision, tokenized, training_template


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--model', choices=CONFIGS, default='lfm')
    parser.add_argument('--dataset-config', choices=['all', *HARNESSES, *CONFIGS.values()])
    parser.add_argument('--revision', default='main')
    parser.add_argument('--harness', choices=HARNESSES)
    parser.add_argument('--common-tasks', action='store_true')
    parser.add_argument('--output-dir', default='sft-output')
    parser.add_argument('--epochs', type=float, default=2)
    parser.add_argument('--learning-rate', type=float, default=3e-6)
    parser.add_argument('--max-steps', type=int, default=-1)
    parser.add_argument('--limit', type=int)
    args = parser.parse_args()
    data, tokenizer, original, info, revision, tokenized, template = load_training_data(
        args.model, args.dataset_config, args.revision, args.harness, args.common_tasks, args.limit)
    model_class = AutoModelForImageTextToText if args.model == 'qwen' else AutoModelForCausalLM
    model = model_class.from_pretrained(info['model'], revision=info['model_revision'], dtype=torch.bfloat16, attn_implementation='sdpa')
    model.config.use_cache = False
    config = SFTConfig(
        output_dir=args.output_dir, num_train_epochs=args.epochs, max_steps=args.max_steps,
        learning_rate=args.learning_rate, lr_scheduler_type='constant', warmup_steps=0,
        per_device_train_batch_size=1, gradient_accumulation_steps=8,
        bf16=True, optim='paged_adamw_8bit', weight_decay=0.0, max_grad_norm=1.0,
        gradient_checkpointing=True, gradient_checkpointing_kwargs={'use_reentrant': False},
        max_length=None, packing=False, loss_type='chunked_nll',
        completion_only_loss=None if tokenized else True, assistant_only_loss=False,
        dataset_kwargs={'skip_prepare_dataset': True} if tokenized else None,
        chat_template_path=template, dataset_num_proc=None,
        save_strategy='epoch', logging_steps=1, report_to='none', seed=42, data_seed=42,
    )
    trainer = SFTTrainer(model=model, processing_class=tokenizer, args=config, train_dataset=data)
    tokenizer.chat_template = original
    result = trainer.train()
    trainer.save_model(args.output_dir)
    tokenizer.save_pretrained(args.output_dir)
    trainer.save_state()
    Path(args.output_dir, 'dataset_provenance.json').write_text(json.dumps({
        'dataset': REPO, 'revision': revision, 'configuration': args.dataset_config or CONFIGS[args.model],
        'model': info['model'], 'model_revision': info['model_revision'], 'examples': len(data),
        'harness_filter': args.harness, 'common_tasks_only': args.common_tasks, 'metrics': result.metrics,
    }, indent=2) + '\n')


if __name__ == '__main__':
    main()