import memhub


class Vector[T]():
    data:      bytes
    length:    sizet
    capacity:  sizet
    elem_size: sizet
    pool:      memhub.MemManager*

    def __init__(self, pool: memhub.MemManager*, capacity: sizet, _hint: T):
        self.elem_size = T.__sizeof__()
        self.capacity = capacity
        self.length = 0
        self.pool = pool
        self.data = pool.alloc(capacity * self.elem_size)

    def push(self, value: T):
        if self.data == None: return
        if self.length >= self.capacity:
            self._grow()
            if self.length >= self.capacity: return
        offset: uint64 = uint64(self.data) + self.length * self.elem_size
        dst: T* = T*(offset)    # typed pointer: store whole T, not its first byte
        *dst = value
        self.length += 1

    def _grow(self):
        if self.pool == None: return
        new_capacity: sizet = self.capacity * 2
        if new_capacity == 0: new_capacity = 4
        new_size: sizet = new_capacity * self.elem_size
        new_data: rawptr = self.pool.realloc(self.data, new_size)
        if new_data == None: return
        self.data = new_data
        self.capacity = new_capacity

    def get(self, index: sizet) -> T:
        if self.data == None: return T(0)
        offset: uint64 = uint64(self.data) + index * self.elem_size
        typed_ptr = T*(offset)
        return *typed_ptr

    def set(self, index: sizet, value: T):
        if index >= self.length: return
        if self.data == None: return
        offset: uint64 = uint64(self.data) + index * self.elem_size
        dst: T* = T*(offset)    # typed pointer: store whole T, not its first byte
        *dst = value

    def len(self) -> sizet:
        return self.length

    def clear(self):
        self.length = 0

    def free(self):
        if self.data != None:
            if self.pool != None:
                self.pool.free(self.data)
            self.data = None
        self.length = 0
        self.capacity = 0