"""
Stress test for DELETE_DEREF removal.
Tests that del on closure variables works correctly with the new
LOAD_DEREF + POP_TOP + PUSH_NULL + STORE_DEREF sequence.
"""
import sys
import threading
import timeit
import statistics
import gc
import weakref

ITERATIONS = 100_000

def test_basic_del_deref():
    """Basic: del a closure variable and verify UnboundLocalError."""
    errors = 0
    for _ in range(ITERATIONS):
        x = 42
        def inner():
            return x
        del x
        try:
            inner()
            errors += 1
        except NameError:
            pass
    assert errors == 0, f"Expected NameError but got value {errors} times"

def test_del_deref_with_reassign():
    """Del then reassign closure variable."""
    for _ in range(ITERATIONS):
        x = "hello"
        def inner():
            return x
        del x
        try:
            inner()
            assert False, "Should have raised"
        except NameError:
            pass
        x = "world"
        assert inner() == "world"

def test_del_deref_refcount():
    """Verify that del properly releases the object (no leaks)."""
    destroyed = [0]
    class Tracer:
        def __del__(self):
            destroyed[0] += 1

    for _ in range(ITERATIONS):
        obj = Tracer()
        ref = weakref.ref(obj)
        def inner():
            return obj
        del obj
        gc.collect()
        assert ref() is None, "Object was not released after del"

    assert destroyed[0] == ITERATIONS, f"Leak detected: only {destroyed[0]}/{ITERATIONS} destroyed"

def test_del_deref_nested():
    """Nested closures with del."""
    for _ in range(ITERATIONS // 10):
        x = [1, 2, 3]
        def level1():
            def level2():
                return x
            return level2
        fn = level1()
        assert fn() == [1, 2, 3]
        del x
        try:
            fn()
            assert False
        except NameError:
            pass

def test_del_deref_threaded():
    """Concurrent del on closure variables."""
    errors = []
    def worker(thread_id):
        try:
            for _ in range(ITERATIONS // 10):
                val = thread_id
                def capture():
                    return val
                assert capture() == thread_id
                del val
                try:
                    capture()
                    errors.append(f"Thread {thread_id}: expected NameError")
                except NameError:
                    pass
        except Exception as exc:
            errors.append(f"Thread {thread_id}: {exc}")

    threads = [threading.Thread(target=worker, args=(tid,)) for tid in range(8)]
    for t in threads:
        t.start()
    for t in threads:
        t.join()
    assert not errors, f"Thread errors: {errors}"

def test_del_deref_in_loop():
    """Del in a tight loop to stress the new instruction sequence."""
    for _ in range(ITERATIONS):
        values = []
        x = 99
        def reader():
            return x
        values.append(reader())
        del x
        try:
            reader()
        except NameError:
            values.append("deleted")
        x = 100
        values.append(reader())
        assert values == [99, "deleted", 100]

if __name__ == "__main__":
    tests = [
        ("basic_del_deref", test_basic_del_deref),
        ("del_deref_with_reassign", test_del_deref_with_reassign),
        ("del_deref_refcount", test_del_deref_refcount),
        ("del_deref_nested", test_del_deref_nested),
        ("del_deref_threaded", test_del_deref_threaded),
        ("del_deref_in_loop", test_del_deref_in_loop),
    ]

    print(f"Python {sys.version}")
    print(f"Running stress tests ({ITERATIONS} iterations each)...\n")

    failed = 0
    for name, test_fn in tests:
        try:
            test_fn()
            print(f"  PASS: {name}")
        except Exception as exc:
            print(f"  FAIL: {name} -- {exc}")
            failed += 1

    print(f"\nResults: {len(tests) - failed}/{len(tests)} passed")
    if failed:
        sys.exit(1)
    else:
        print("All stress tests PASSED")

"""Benchmark for del on closure variables."""
import timeit
import statistics

ITERATIONS = 100_000

setup = """
def make():
    x = 42
    def inner():
        return x
    del x
    try:
        inner()
    except NameError:
        pass
"""

times = timeit.repeat("make()", setup=setup, number=ITERATIONS, repeat=50)
mean = statistics.mean(times)
stdev = statistics.stdev(times)
print(f"del closure var ({ITERATIONS} iters x 50 rounds):")
print(f"  mean:  {mean:.4f}s")
print(f"  stdev: {stdev:.4f}s")
print(f"  min:   {min(times):.4f}s")
print(f"  max:   {max(times):.4f}s")