import random
from intervals import merge, overlaps, total_covered, find_gaps, normalize

def test_merge_basic():
    assert merge([(1,3),(2,4)]) == [(1,4)]
    assert merge([(1,2),(3,4)]) == [(1,2),(3,4)]  # touching-ish? no, gap
    assert merge([(1,2),(2,3)]) == [(1,2),(2,3)]  # touching stays separate

def test_merge_nested_unsorted():
    assert merge([(5,9),(1,10),(2,3)]) == [(1,10)]

def test_empty():
    assert merge([]) == []
    assert total_covered([]) == 0

def test_total_covered():
    assert total_covered([(1,4),(2,5)]) == 4
    assert total_covered([(1,2),(2,3)]) == 2

def test_overlaps():
    assert overlaps((1,3),(2,4)) is True
    assert overlaps((1,2),(2,3)) is False
    assert overlaps((1,5),(2,3)) is True

def test_find_gaps():
    assert find_gaps([(1,3),(5,7)], 0, 8) == [(0,1),(3,5),(7,8)]
    assert find_gaps([], 0, 5) == [(0,5)]
    assert find_gaps([(0,5)], 0, 5) == []

def test_validate():
    try:
        merge([(2,1)])
        raise AssertionError("expected ValueError")
    except ValueError:
        pass

def test_fuzz_against_brute():
    rng = random.Random(42)
    for _ in range(2000):
        n = rng.randint(0, 8)
        ivs = []
        for _ in range(n):
            a = rng.randint(-5, 5)
            b = rng.randint(-5, 5)
            ivs.append((min(a,b), max(a,b)))
        # brute union length over integer points? use half-open lengths with integer grid
        merged = merge(ivs)
        # check no overlaps remain
        for i in range(len(merged)-1):
            assert merged[i][1] <= merged[i+1][0], (merged, ivs)
        # check total length equals brute force over unit grid
        pts = set()
        for s,e in ivs:
            for x in range(s, e):
                pts.add(x)
        assert total_covered(ivs) == len(pts), (ivs, merged, total_covered(ivs), len(pts))