import pytest

from random_order.shuffler import _shuffle_items


def identity_key(item, session):
    return item


def modulus_2_key(item, session):
    return item % 2


def lt_10_key(item, session):
    return item < 10


def disable_if_gt_1000(item, session):
    # if disable returns a truthy value, it must also be usable as a key.
    if item > 1000:
        return item // 1000
    else:
        return False


@pytest.mark.parametrize('key', [
    None,
    lambda item, session: None,
    lambda item, session: item % 2,
])
def test_shuffles_empty_list_in_place(key):
    items = []
    items_id = id(items)
    _shuffle_items(items, bucket_key=key)
    assert items == []
    assert id(items) == items_id


@pytest.mark.parametrize('key', [
    None,
    lambda item, session: None,
    lambda item, session: item % 2,
])
def test_shuffles_one_item_list_in_place(key):
    items = [42]
    items_id = id(items)
    _shuffle_items(items, bucket_key=key)
    assert items == [42]
    assert id(items) == items_id


def test_identity_key_results_in_complete_reshuffle():
    items = list(range(20))
    items_copy = list(items)
    _shuffle_items(items, bucket_key=identity_key)
    assert items != items_copy


def test_two_bucket_reshuffle():
    # If we separate a list of 20 integers from 0 to 19 into two buckets
    # [[0..9], [10..19]] then the result should be
    # either [{0..9}, {10..19}]
    # or [{10..19}, {0..9}]
    items = list(range(20))
    items_copy = list(items)
    _shuffle_items(items, bucket_key=lt_10_key)
    assert items != items_copy
    for i, item in enumerate(items):
        if lt_10_key(i, None):
            assert lt_10_key(item, None) == lt_10_key(items[0], None), items
        else:
            assert lt_10_key(item, None) == lt_10_key(items[10], None), items


def test_eight_bucket_reshuffle():
    # This is a cross-check to test shuffling of buckets.
    items = [
        1, 1,
        2, 2,
        3, 3,
        4, 4,
        5, 5,
        6, 6,
        7, 7,
        8, 8,
    ]
    items_copy = list(items)

    _shuffle_items(items, bucket_key=identity_key)

    assert items != items_copy

    # Items of the same bucket should remain next to each other.
    assert items[0] == items[1]
    assert items[2] == items[3]
    assert items[-1] == items[-2]


def test_shuffle_respects_single_disabled_group_in_each_of_two_buckets():
    items = [
        11, 13, 9995, 9997, 19, 21, 23, 25, 27, 29,  # bucket 1 -- odd numbers
        12, 14, 9996, 9998, 20, 22, 24, 26, 28, 30,  # bucket 2 -- even numbers
    ]
    items_copy = list(items)

    _shuffle_items(items, bucket_key=modulus_2_key, disable=disable_if_gt_1000)

    assert items != items_copy
    assert items.index(9995) + 1 == items.index(9997)
    assert items.index(9996) + 1 == items.index(9998)


def test_shuffle_respects_two_distinct_disabled_groups_in_one_bucket():
    # all items are in one oddity bucket, but the two groups
    # of large numbers are separate because they are disabled
    # from two different units.
    # This is simulating two disabled modules within same package.
    # The two modules shouldn't be mixed up in one bucket.
    items = [
        11, 13, 8885, 8887, 8889, 21, 23, 9995, 9997, 9999,
    ]
    items_copy = list(items)

    for i in range(5):
        _shuffle_items(items, bucket_key=modulus_2_key, disable=disable_if_gt_1000)
        if items != items_copy:
            assert items[items.index(8885):items.index(8885) + 3] == [8885, 8887, 8889]
            assert items[items.index(9995):items.index(9995) + 3] == [9995, 9997, 9999]
            return

    assert False


def test_shuffle_respects_seed():
    sorted_items = list(range(30))

    for seed in range(20):
        # Reset
        items1 = list(range(30))
        _shuffle_items(items1, seed=seed)

        assert items1 != sorted_items

        items2 = list(range(30))
        _shuffle_items(items2, seed=seed)

        assert items2 == items1