import asyncio  # used to run async functions
import random  # used for generating large random lists
import sys  # used for edge case with maxsize

import pytest  # used for our unit tests
from src.async_examples.concurrency import sorter

# ---------------------------
# Basic Test Cases
# ---------------------------

@pytest.mark.asyncio
async def test_sorter_empty_list():
    # Test sorting an empty list
    arr = []
    result = await sorter(arr.copy())

@pytest.mark.asyncio
async def test_sorter_single_element():
    # Test sorting a single-element list
    arr = [42]
    result = await sorter(arr.copy())

@pytest.mark.asyncio
async def test_sorter_sorted_list():
    # Test sorting an already sorted list
    arr = [1, 2, 3, 4, 5]
    result = await sorter(arr.copy())

@pytest.mark.asyncio
async def test_sorter_reverse_sorted_list():
    # Test sorting a reverse sorted list
    arr = [5, 4, 3, 2, 1]
    result = await sorter(arr.copy())

@pytest.mark.asyncio
async def test_sorter_unsorted_list():
    # Test sorting a typical unsorted list
    arr = [3, 1, 4, 2, 5]
    result = await sorter(arr.copy())

@pytest.mark.asyncio
async def test_sorter_duplicates():
    # Test sorting a list with duplicate values
    arr = [4, 2, 2, 3, 1, 4]
    result = await sorter(arr.copy())

@pytest.mark.asyncio
async def test_sorter_negative_numbers():
    # Test sorting a list with negative numbers
    arr = [-3, -1, -2, 0, 2, 1]
    result = await sorter(arr.copy())

@pytest.mark.asyncio
async def test_sorter_mixed_types():
    # Test sorting a list with both positive and negative numbers
    arr = [0, -1, 1, -2, 2]
    result = await sorter(arr.copy())

# ---------------------------
# Edge Test Cases
# ---------------------------

@pytest.mark.asyncio
async def test_sorter_all_equal():
    # Test sorting a list where all elements are equal
    arr = [7, 7, 7, 7, 7]
    result = await sorter(arr.copy())

@pytest.mark.asyncio
async def test_sorter_large_numbers():
    # Test sorting a list with very large and very small integers
    arr = [sys.maxsize, -sys.maxsize, 0, 999999999, -999999999]
    result = await sorter(arr.copy())

@pytest.mark.asyncio
async def test_sorter_concurrent_calls():
    # Test concurrent execution of the sorter function with different inputs
    arr1 = [3, 2, 1]
    arr2 = [9, 8, 7, 6]
    arr3 = [5, 10, 0, -1]
    results = await asyncio.gather(
        sorter(arr1.copy()),
        sorter(arr2.copy()),
        sorter(arr3.copy())
    )

@pytest.mark.asyncio
async def test_sorter_cancellation():
    # Test cancellation of the sorter coroutine
    arr = [5, 3, 1, 2, 4]
    task = asyncio.create_task(sorter(arr.copy()))
    await asyncio.sleep(0.000005)  # Let the task start
    task.cancel()
    try:
        await task
    except asyncio.CancelledError:
        pass  # Expected behavior

@pytest.mark.asyncio
async def test_sorter_exception_handling():
    # Test that sorter raises an exception if input is not a list
    with pytest.raises(TypeError):
        await sorter("not a list")  # Should fail as string is iterable but not list

# ---------------------------
# Large Scale Test Cases
# ---------------------------

@pytest.mark.asyncio
async def test_sorter_large_list():
    # Test sorting a large list of random numbers (under 1000 elements)
    arr = random.sample(range(-10000, -9000), 999)
    expected = sorted(arr)
    result = await sorter(arr.copy())

@pytest.mark.asyncio
async def test_sorter_many_concurrent_large_lists():
    # Test concurrent sorting of many large lists
    lists = [random.sample(range(-10000, -9000), 100) for _ in range(10)]
    expected = [sorted(lst) for lst in lists]
    results = await asyncio.gather(*(sorter(lst.copy()) for lst in lists))

@pytest.mark.asyncio
async def test_sorter_performance_under_load():
    # Test performance under concurrent load (timing, but no assert on time)
    lists = [random.sample(range(1000), 50) for _ in range(20)]
    # Await all sorts concurrently
    results = await asyncio.gather(*(sorter(lst.copy()) for lst in lists))
    for lst, result in zip(lists, results):
        pass

# ---------------------------
# Async/Await Behavior Tests
# ---------------------------

@pytest.mark.asyncio
async def test_sorter_returns_coroutine():
    # Test that sorter returns a coroutine and must be awaited
    arr = [2, 1]
    codeflash_output = sorter(arr.copy()); coro = codeflash_output
    result = await coro

@pytest.mark.asyncio
async def test_sorter_does_not_block_event_loop():
    # Test that sorter yields control to event loop (simulate by running with another task)
    arr = [3, 2, 1]
    side_effect = []
    async def side_task():
        await asyncio.sleep(0.000005)
        side_effect.append("ran")
    await asyncio.gather(sorter(arr.copy()), side_task())
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import asyncio  # used to run async functions

import pytest  # used for our unit tests
from src.async_examples.concurrency import sorter

# -------------------------
# Basic Test Cases
# -------------------------

@pytest.mark.asyncio
async def test_sorter_empty_list():
    # Test sorting an empty list
    arr = []
    result = await sorter(arr.copy())

@pytest.mark.asyncio
async def test_sorter_single_element():
    # Test sorting a single-element list
    arr = [42]
    result = await sorter(arr.copy())

@pytest.mark.asyncio
async def test_sorter_sorted_list():
    # Test sorting an already sorted list
    arr = [1, 2, 3, 4, 5]
    result = await sorter(arr.copy())

@pytest.mark.asyncio
async def test_sorter_reverse_sorted_list():
    # Test sorting a reverse-sorted list
    arr = [5, 4, 3, 2, 1]
    result = await sorter(arr.copy())

@pytest.mark.asyncio
async def test_sorter_unsorted_list():
    # Test sorting a typical unsorted list
    arr = [3, 1, 4, 5, 2]
    result = await sorter(arr.copy())

@pytest.mark.asyncio
async def test_sorter_with_duplicates():
    # Test sorting a list with duplicate values
    arr = [4, 2, 5, 2, 3, 4]
    result = await sorter(arr.copy())

@pytest.mark.asyncio
async def test_sorter_negative_numbers():
    # Test sorting a list with negative numbers
    arr = [-3, -1, -2, 0, 2]
    result = await sorter(arr.copy())

@pytest.mark.asyncio
async def test_sorter_mixed_numbers():
    # Test sorting a list with positive, negative, and zero
    arr = [0, -1, 3, -2, 2, 1]
    result = await sorter(arr.copy())

# -------------------------
# Edge Test Cases
# -------------------------

@pytest.mark.asyncio
async def test_sorter_all_equal_elements():
    # Test sorting a list where all elements are equal
    arr = [7, 7, 7, 7]
    result = await sorter(arr.copy())

@pytest.mark.asyncio
async def test_sorter_large_numbers():
    # Test sorting a list with very large integers
    arr = [999999, 123456789, -987654321, 0]
    result = await sorter(arr.copy())

@pytest.mark.asyncio
async def test_sorter_floats_and_integers():
    # Test sorting a list with floats and integers
    arr = [3.2, 1, 4.5, 2.2, 0]
    result = await sorter(arr.copy())

@pytest.mark.asyncio
async def test_sorter_concurrent_calls():
    # Test concurrent execution of sorter with different input lists
    arr1 = [5, 3, 1]
    arr2 = [10, 2, 8, 6]
    arr3 = [0]
    # Run all at once
    results = await asyncio.gather(
        sorter(arr1.copy()),
        sorter(arr2.copy()),
        sorter(arr3.copy())
    )

@pytest.mark.asyncio
async def test_sorter_awaitable_behavior():
    # Test that sorter returns a coroutine and must be awaited
    arr = [3, 2, 1]
    codeflash_output = sorter(arr.copy()); coro = codeflash_output
    result = await coro

@pytest.mark.asyncio
async def test_sorter_cancelled_task():
    # Test cancellation of sorter coroutine
    arr = [4, 3, 2, 1]
    task = asyncio.create_task(sorter(arr.copy()))
    await asyncio.sleep(0.000001)  # Let the sorter start
    task.cancel()
    try:
        await task
    except asyncio.CancelledError:
        # Expected behavior
        return

@pytest.mark.asyncio
async def test_sorter_exception_on_non_list():
    # Test that sorter raises an exception on non-list input
    with pytest.raises(TypeError):
        await sorter("not a list")
    with pytest.raises(TypeError):
        await sorter(None)
    with pytest.raises(TypeError):
        await sorter(123)

@pytest.mark.asyncio
async def test_sorter_list_with_unorderable_types():
    # Test that sorter raises exception on list with unorderable types
    arr = [1, "two", 3]
    with pytest.raises(TypeError):
        await sorter(arr.copy())

# -------------------------
# Large Scale Test Cases
# -------------------------

@pytest.mark.asyncio
async def test_sorter_large_list():
    # Test sorting a large list (but <1000 elements)
    arr = list(range(999, -1, -1))  # 1000 elements, descending
    result = await sorter(arr.copy())

@pytest.mark.asyncio
async def test_sorter_concurrent_large_lists():
    # Test concurrent sorting of multiple large lists
    lists = [list(range(i, i-100, -1)) for i in range(999, 899, -20)]  # 5 lists of 100 elements each
    coros = [sorter(lst.copy()) for lst in lists]
    results = await asyncio.gather(*coros)
    for res in results:
        pass

@pytest.mark.asyncio
async def test_sorter_performance_under_load():
    # Test performance under concurrent load (10 lists of 100 elements)
    lists = [list(range(100, 0, -1)) for _ in range(10)]
    coros = [sorter(lst.copy()) for lst in lists]
    # Set a reasonable timeout to ensure performance (should not take >1 second)
    try:
        results = await asyncio.wait_for(asyncio.gather(*coros), timeout=1.0)
    except asyncio.TimeoutError:
        pytest.fail("sorter took too long under concurrent load")
    for res in results:
        pass
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.