import pytest

from System.IO import MemoryStream, FileStream, FileMode, File, Path, StreamWriter


def test_memory_stream_context_manager():
    """Test that MemoryStream can be used as a context manager"""
    data = bytes([1, 2, 3, 4, 5])

    with MemoryStream() as stream:
        # Convert Python bytes to .NET byte array for proper writing
        from System import Array, Byte

        dotnet_bytes = Array[Byte](data)
        stream.Write(dotnet_bytes, 0, len(dotnet_bytes))

        assert stream.Length == 5
        stream.Position = 0

        # Create a .NET byte array to read into
        buffer = Array[Byte](5)
        stream.Read(buffer, 0, 5)

        # Convert back to Python bytes for comparison
        result = bytes(buffer)
        assert result == data

    # The stream should be disposed (closed) after the with block
    with pytest.raises(Exception):
        stream.Position = 0  # This should fail because the stream is closed


def test_file_stream_context_manager(tmpdir: str):
    """Test that FileStream can be used as a context manager"""
    # Create a temporary file path
    temp_path = Path.Combine(str(tmpdir), Path.GetRandomFileName())

    try:
        # Write data to the file using with statement
        data = "Hello, context manager!"
        with FileStream(temp_path, FileMode.Create) as fs:
            writer = StreamWriter(fs)
            writer.Write(data)
            writer.Flush()

        # Verify the file was written and stream was closed
        assert File.Exists(temp_path)
        content = File.ReadAllText(temp_path)
        assert content == data

        # The stream should be disposed after the with block
        with pytest.raises(Exception):
            fs.Position = 0  # This should fail because the stream is closed
    finally:
        # Clean up
        if File.Exists(temp_path):
            File.Delete(temp_path)


def test_disposable_in_multiple_contexts():
    """Test that using .NET IDisposable objects in multiple contexts works correctly"""
    # Create multiple streams and check that they're all properly disposed

    # Create a list to track if streams were properly disposed
    # (we'll check this by trying to access the stream after disposal)
    streams_disposed = [False, False]

    # Use nested context managers with .NET IDisposable objects
    with MemoryStream() as outer_stream:
        # Write some data to the outer stream
        from System import Array, Byte

        outer_data = Array[Byte]([10, 20, 30])
        outer_stream.Write(outer_data, 0, len(outer_data))

        # Check that the outer stream is usable
        assert outer_stream.Length == 3

        with MemoryStream() as inner_stream:
            # Write different data to the inner stream
            inner_data = Array[Byte]([40, 50, 60, 70])
            inner_stream.Write(inner_data, 0, len(inner_data))

            # Check that the inner stream is usable
            assert inner_stream.Length == 4

        # Try to use the inner stream - should fail because it's disposed
        try:
            inner_stream.Position = 0
        except Exception:
            streams_disposed[1] = True

    # Try to use the outer stream - should fail because it's disposed
    try:
        outer_stream.Position = 0
    except Exception:
        streams_disposed[0] = True

    # Verify both streams were properly disposed
    assert all(streams_disposed)


def test_exception_handling():
    """Test that exceptions propagate correctly through the context manager"""
    with pytest.raises(ValueError):
        with MemoryStream() as stream:
            raise ValueError("Test exception")

    # Stream should be disposed despite the exception
    with pytest.raises(Exception):
        stream.Position = 0