#include "vector.h"
#include <debug.h>
#include <stdlib.h>

#define Vector_log(msg) dbg_sprintf(dbgout, "[Vector] %s\n", msg)


bool Vector_consume(Vector* self, const void* value){
    bool success = vc_vector_push_back(self->_vector, value);
    free((void*)value);
    if(!success){
        Vector_log("Faield to consume value");
    }
    return success;
}

bool Vector_push(Vector* self, const void* value){
    return vc_vector_push_back(self->_vector, value);
}

void* Vector_pop(Vector* self){
    void* item = vc_vector_end(self->_vector);
    if(vc_vector_pop_back(self->_vector)){
        return NULL;
    }
    return item;
}

bool Vector_replace(Vector* self, size_t i, const void* value){
    return vc_vector_replace(self->_vector, i, value);
}

void Vector_clear(Vector* self){
    vc_vector_clear(self->_vector);
}

size_t Vector_count(Vector* self){
    return self->_vector->count;
}

void free_Vector(Vector* self){
    Vector_log("Freeing vc_vector");
    self->clear(self);
    free(self->_vector);
    Vector_log("Freeing Vector");
    free(self);
}

void* Vector_get(Vector* self, size_t i){
    return vc_vector_at(self->_vector, i);
}

Vector* new_Vector(int size, size_t obj_size, vc_vector_deleter* deleter){
    return new_VectorFromVC(vc_vector_create(size, obj_size, deleter));
}

Vector* new_VectorFromVC(vc_vector* vector){
    Vector* self = (Vector*)malloc(sizeof(Vector));
    self->_vector = vector;

    self->consume = &Vector_consume;
    self->push = &Vector_push;
    self->pop = &Vector_pop;
    self->replace = &Vector_replace;
    self->clear = &Vector_clear;
    self->count = &Vector_count;
    self->get = &Vector_get;
    return self;
}

Vector* copy_Vector(Vector* vector){
    return new_VectorFromVC(vc_vector_create_copy(vector->_vector));
}