List un_list_create(u64 start_capacity, u64 element_size, Allocator alloc) {
    List list;

    list.count = 0;
    list.capacity = start_capacity;
    list.element_size = element_size;
    list.alloc = alloc;

    list.data = un_memory_alloc(list.capacity * list.element_size, alloc);

    assert(list.data != NULL);
    return list;
}

void un_list_destroy(List *list) {
    un_memory_destroy(&list->alloc);
    UN_CLEAR(*list);
}

List un_list_clone(List *list, Allocator alloc) {
    List result;

    result = *list;
    result.alloc = alloc;
    result.data  = un_memory_alloc(result.capacity * result.element_size, alloc);
    assert(result.data != NULL);

    un_memory_copy(result.data, list->data, result.count * result.element_size);

    return result;
}

static b32 list_grow_if_needed(List *list) {
    if ((list->count + 1) <= list->capacity) {
        return true;
    } else {
        void *mem = un_memory_realloc(list->data, list->element_size * list->capacity * 2, list->alloc);

        if (!mem) {
            return false;
        }

        list->data = mem;
        list->capacity *= 2;
    }

    return true;
}

b32 un_list_append(List *list, void *data) {
    void *addr;

    if (list_grow_if_needed(list)) {
        addr = (u8*)list->data + list->count * list->element_size;
        un_memory_copy(addr, data, list->element_size);
        list->count++;
        return true;
    } else {
        return false;
    }
}

void *un_list_get(List *list, u64 index) {
    if (index >= list->count) return NULL;

    return (u8*)list->data + index * list->element_size;
}

void un_list_remove(List *list, u64 index) {
    void *addr;
    u64 move_elements;
    
    if (index >= list->count) return;

    addr = (u8*)list->data + index * list->element_size;
    
    move_elements = list->count - (index + 1);

    if (move_elements) {
        un_memory_move(addr, (u8*)addr + list->element_size, move_elements * list->element_size);
    }

    list->count--;
}