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

vector_t vector_init(int size){
    vector_t vec;
    vec.max_size = size;
    vec.arr = malloc(sizeof(int)*vec.max_size);
    vec.cur_size = 0;
    return vec;
}

int size(vector_t vec){
    return vec.cur_size;
}

int capacity(vector_t vec){
    return vec.max_size;
}

int is_empty(vector_t vec){
    if (vec.cur_size == 0){
        return 1;
    }
    return 0;
}

int at(vector_t vec, int index){
    if (index >= size(vec) || index < 0){
        printf("Index out of bound!!\n");
        exit(-1);
    }

    return vec.arr[index];
}

void push(vector_t *vec, int value){
    resize_vec_check(vec); 
    vec->arr[vec->cur_size] = value;
    vec->cur_size++;
}

void insert(vector_t *vec, int index, int val){
    resize_vec_check(vec);
    
    int tmp;
    for (int i = index; i <= vec->cur_size; i++){
        tmp = val;
        val = vec->arr[i];
        vec->arr[i] = tmp;
    }
    vec->cur_size += 1;
}

void delete_vec(vector_t *vec, int index){
    if (!(index < vec->cur_size)){
       printf("Invalid Index!\nFailed to Delete Element\n");
       exit(-1);
    }
    int len = vec->cur_size - 1;

    for (int i = index; i < len; i++){
        vec->arr[i] = vec->arr[i+1];
    }

    vec->cur_size = vec->cur_size - 1;
    resize_vec_check(vec);
}

void remove_val(vector_t *vec, int value){
    int i = 0;
    while (i < vec->cur_size){
        if (vec->arr[i] == value){
            delete_vec(vec, i);
            continue;
        }
        i++;
    }
    resize_vec_check(vec);
}

void prepend(vector_t *vec, int value){
    insert(vec, 0, value);
}

int pop(vector_t *vec){
    // remove item at the end, return value
    int ret = vec->arr[vec->cur_size-1];
    vec->cur_size--;
    resize_vec_check(vec);
    return ret;
}

void print_vec(vector_t vec){
    printf("[");
    for (int i = 0; i < vec.cur_size; i++){
        printf("%d ", vec.arr[i]);

    }
    printf("]\n");
}

void destroy_vec(vector_t *vec){
    free(vec->arr);
}

int find_vec(vector_t vec, int value){
    for (int i = 0; i < size(vec); i++){
        if (at(vec, i) == value){
            return i;
        }
    }
    return -1;
}

void resize_vec_check(vector_t *vec){
    int capacity = vec->max_size;
    int cur_size = vec->cur_size;

    if (cur_size == capacity){
        resize_vec(vec, capacity*2);
    }
    if (cur_size <= capacity/4){
        resize_vec(vec, capacity/2);
    }
}

void resize_vec(vector_t *vec, int new_capacity){
   vec->arr = (int*)realloc(vec->arr, sizeof(int)*new_capacity); 
   vec->max_size = new_capacity;
}