"""Measure real source-training batches without updating experiment checkpoints."""
import argparse
import json
from pathlib import Path
import time

import numpy as np
import torch

from pallet.annotation import load_jsonl
from pallet.cli import _attach_cache
from pallet.data.loader import NormalizationStats
from pallet.data.protocol import load_protocol
from pallet.devices import resolve_device
from pallet.experiments.dataset import PalletDataset
from pallet.experiments.loading import make_loader
from pallet.experiments.yolo_recipe import YoloResearchRecipe
from pallet.export import load_detector_checkpoint


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('--source-output', required=True)
    parser.add_argument('--output', required=True)
    args = parser.parse_args()
    source = Path(args.source_output)
    partition = json.loads((source / 'manual_partition.json').read_text())
    run = json.loads((source / 'training/run.json').read_text())
    records, _, _ = load_protocol(Path('outputs/protocol_v5'))
    records = _attach_cache(records, 'outputs/cache_v5/sealed_index.json')
    allowed = set(partition['train_frame_ids'])
    candidates = sorted((r for r in records if r.frame_id in allowed), key=lambda r: r.frame_id)
    rng = np.random.default_rng(42)
    selected = [candidates[i] for i in rng.permutation(len(candidates))[:256]]
    dataset = PalletDataset(selected, load_jsonl(source / 'inputs/annotations.jsonl'),
        NormalizationStats(**run['normalization']), size=640, augmentation=True,
        spatial_augmentation=True, manual_training_ids=allowed, manual_role='train')
    device = str(resolve_device(run['device_uuid']))
    results = []
    for batch_size, workers in [(4, 0), (8, 4), (16, 4)]:
        torch.manual_seed(42)
        np.random.seed(42)
        model, _ = load_detector_checkpoint(source / 'training/last.pt')
        model.to(device).train()
        recipe = YoloResearchRecipe(model, samples=len(allowed), epochs=300,
                                   batch_size=batch_size, num_batches=(len(allowed) + batch_size - 1) // batch_size)
        optimizer = recipe.optimizer
        optimizer.zero_grad(set_to_none=True)
        loader = make_loader(dataset, batch_size=batch_size, shuffle=True, workers=workers,
                             device=device, generator=torch.Generator().manual_seed(42))
        torch.cuda.reset_peak_memory_stats(device)
        started = time.perf_counter()
        measured_at = None
        measured_images = 0
        for step, batch in enumerate(loader):
            inputs = {key: value.to(device, non_blocking=True)
                      for key, value in batch.items() if key != 'meta'}
            with torch.autocast('cuda', dtype=torch.bfloat16):
                loss, _ = model.loss(inputs)
            loss.sum().backward()
            if (step + 1) % (16 // batch_size) == 0:
                torch.nn.utils.clip_grad_norm_(model.parameters(), 10.)
                optimizer.step()
                optimizer.zero_grad(set_to_none=True)
            seen = (step + 1) * batch_size
            if seen == 32:
                torch.cuda.synchronize(device)
                measured_at = time.perf_counter()
            elif seen > 32:
                measured_images += batch_size
        torch.cuda.synchronize(device)
        ended = time.perf_counter()
        result = {'batch_size': batch_size, 'effective_batch': 16, 'accumulation': 16 // batch_size,
            'workers': workers, 'images': len(dataset), 'measured_images': measured_images,
            'seconds_including_worker_start_and_warmup': ended - started,
            'steady_seconds': ended - measured_at,
            'steady_images_per_second': measured_images / (ended - measured_at),
            'peak_allocated_mib': torch.cuda.max_memory_allocated(device) / 2**20,
            'peak_reserved_mib': torch.cuda.max_memory_reserved(device) / 2**20}
        results.append(result)
        print(json.dumps(result), flush=True)
        del model, recipe, optimizer, loader, inputs, loss
        torch.cuda.empty_cache()
    report = {'source_output': str(source), 'device_uuid': run['device_uuid'],
        'source_training_only': True, 'selected_frame_ids': [r.frame_id for r in selected],
        'augmentation': 'spatial_float_v1', 'size': 640, 'precision': 'bfloat16',
        'experimental_weights_updated': False, 'results': results}
    Path(args.output).write_text(json.dumps(report, ensure_ascii=False, indent=2) + '\n')


if __name__ == '__main__':
    main()
