from epsilon import Runtime

# Load and run a WebAssembly module
with Runtime() as runtime:
    wasm_bytes = open("add.wasm", "rb").read()
    with runtime.instantiate(wasm_bytes) as module:
        result = module.call("add", 5, 37)
        print(result)  # [42]

with Runtime() as runtime:
    with runtime.instantiate(wasm_bytes) as module:
        # Read memory
        data = module.read_memory(offset=0, length=100, memory_name="memory")

        # Write memory
        module.write_memory(offset=0, data=b"Hello, WASM!", memory_name="memory")

        # Get memory size (in pages, 1 page = 64KB)
        size = module.get_memory_size("memory")

with Runtime() as runtime:
    with runtime.instantiate(wasm_bytes) as module:
        exports = module.get_export_names()
        print(exports)  # ['add', 'memory', 'global_counter', ...]

with Runtime() as runtime:
    with runtime.instantiate(wasm_bytes) as module:
        # Call with typed arguments
        result = module.call_typed("compute", [
            (42, 'i32'),
            (3.14, 'f64'),
            (1000000, 'i64'),
        ])

# Limit memory to 256 pages (16 MB)
with Runtime(max_memory_pages=256) as runtime:
    module = runtime.instantiate(wasm_bytes)

# Or per-module
with Runtime() as runtime:
    module = runtime.instantiate(wasm_bytes, max_memory_pages=128)

# Set a timeout (in milliseconds)
result = module.call("slow_function", 42, timeout_ms=5000)

class Runtime:
    PAGE_SIZE = 65536  # 64KB
    MAX_PAGES = 32768  # 2GB total

    def __init__(self, max_memory_pages: int = 0):
        """Create a new WebAssembly runtime.

        Args:
            max_memory_pages: Default max memory for modules (0 = no limit)
        """

    def instantiate(self, wasm_bytes, max_memory_pages=None) -> Module:
        """Instantiate a WASM module from bytes."""

    def instantiate_file(self, file_path, max_memory_pages=None) -> Module:
        """Instantiate a WASM module from a file."""

    def close(self):
        """Close the runtime and free resources."""

class Module:
    def call(self, func_name: str, *args, timeout_ms=None) -> List[int]:
        """Call an exported function."""

    def call_typed(self, func_name: str, args: List[tuple], timeout_ms=None) -> List[int]:
        """Call with typed arguments: [(value, 'i32'|'i64'|'f32'|'f64'), ...]"""

    def get_export_names(self) -> List[str]:
        """Get names of all exports."""

    def get_memory_size(self, memory_name="memory") -> int:
        """Get memory size in pages."""

    def read_memory(self, offset, length, memory_name="memory") -> bytes:
        """Read bytes from linear memory."""

    def write_memory(self, offset, data, memory_name="memory") -> int:
        """Write bytes to linear memory."""

    def get_global(self, global_name: str) -> int:
        """Get the value of an exported global."""

    def close(self):
        """Close the module and free resources."""

class EpsilonError(Exception):
    """Base exception for epsilon errors."""

class EpsilonTimeoutError(EpsilonError):
    """Raised when execution times out."""

def version() -> str:
    """Get the epsilon library version."""

def wrapper_version() -> str:
    """Get the Python wrapper version."""