import numpy as np

class CustomVRAM:
    def __init__(self, global_mem):
        self.global_mem = global_mem
        self.texture_registry = {}
        self.texture_counter = 0

    def load_texture(self, data: np.ndarray, name: str = None) -> str:
        if name is None:
            name = f"texture_{self.texture_counter}"
            self.texture_counter += 1

        # Serialize numpy array to bytes
        data_bytes = data.tobytes()
        data_shape = data.shape
        data_dtype = str(data.dtype)

        # Store metadata and data in global memory
        # For simplicity, we'll store everything contiguously for now.
        # In a real system, this would involve more sophisticated memory management.
        
        # Find a suitable address in global memory (very simplified, no actual allocation logic)
        # For this simulation, we'll just use a simple counter for addresses.
        # In a real scenario, you'd need a proper memory allocator.
        address = self.global_mem.allocate_space(len(data_bytes) + 100) # +100 for metadata

        # Store shape, dtype, and then data
        # This is a very basic serialization. For production, consider more robust methods.
        metadata = f"{data_shape};{data_dtype};{len(data_bytes)}".encode("utf-8")
        self.global_mem.write(address, list(metadata))
        self.global_mem.write(address + len(metadata), list(data_bytes))

        self.texture_registry[name] = {
            "address": address,
            "size": len(data_bytes),
            "shape": data_shape,
            "dtype": data_dtype,
            "metadata_size": len(metadata)
        }
        return name

    def get_texture(self, name: str) -> np.ndarray:
        if name not in self.texture_registry:
            return None

        texture_info = self.texture_registry[name]
        address = texture_info["address"]
        size = texture_info["size"]
        shape = texture_info["shape"]
        dtype = texture_info["dtype"]
        metadata_size = texture_info["metadata_size"]

        # Read data from global memory
        data_bytes = bytes(self.global_mem.read(address + metadata_size, size))
        
        # Deserialize bytes to numpy array
        return np.frombuffer(data_bytes, dtype=dtype).reshape(shape)

    def has_texture(self, name: str) -> bool:
        return name in self.texture_registry

    def delete_texture(self, name: str):
        if name in self.texture_registry:
            # In a real system, you'd deallocate the memory.
            # For this simulation, we just remove the entry.
            del self.texture_registry[name]