import random
from types import SimpleNamespace

import numpy as np
import pytest
import torch

from pallet.experiments.loading import make_loader
from pallet.experiments.evaluate import predict_batch_boxes, predict_boxes
from pallet.experiments.dataset import SampleMeta


class RandomDataset:
    def __len__(self):
        return 5

    def __getitem__(self, index):
        value = index + random.random() + float(np.random.random()) + torch.rand(()).item()
        return torch.full((4, 2, 2), value), torch.empty((0, 4)), SimpleNamespace(frame_id=str(index))


def _epoch(generator):
    loader = make_loader(RandomDataset(), batch_size=2, shuffle=True, workers=1, generator=generator)
    return [batch['img'].clone() for batch in loader]


def test_workers_resume_augmentation_rng_at_epoch_boundary():
    generator = torch.Generator().manual_seed(42)
    _epoch(generator)
    state = generator.get_state()
    continued = _epoch(generator)
    restored = torch.Generator()
    restored.set_state(state)
    resumed = _epoch(restored)
    for left, right in zip(continued, resumed):
        torch.testing.assert_close(left, right, rtol=0, atol=0)
    assert continued[-1].shape[0] == 1


def test_loader_rejects_invalid_workers_and_disables_persistent_state():
    with pytest.raises(ValueError, match='workers'):
        make_loader(RandomDataset(), batch_size=2, workers=-1)
    loader = make_loader(RandomDataset(), batch_size=2, workers=1)
    assert loader.persistent_workers is False
    assert loader.prefetch_factor == 2


def test_batched_yolo_predictions_use_each_native_coordinate_frame(monkeypatch):
    from ultralytics.utils import nms

    class Model:
        def __call__(self, images):
            return images

    monkeypatch.setattr(nms, 'non_max_suppression', lambda images, **kwargs: [
        torch.tensor([[2., 4., 10., 12., .8, 0.]]) for _ in images])
    images = torch.zeros(2, 4, 16, 16)
    metas = [SampleMeta('a', (16, 16), 1., (0, 0)),
             SampleMeta('b', (8, 8), 2., (0, 0))]
    output = predict_batch_boxes(Model(), images, metas, size=16)
    assert output[0][0][0] == [2., 4., 10., 12.]
    assert output[1][0][0] == [1., 2., 5., 6.]
    assert predict_boxes(Model(), images[:1], metas[0], size=16) == output[0]
