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

void mergeSort(vector* v, bool (*compare)(), int i, int j);

vector* newVector(){
    vector* v = (vector *)malloc(sizeof(vector));
    v->size = 0;
    v->capacity = 0;

    v->growthFactor = 2;

    v->compare = NULL;
    v->toString = NULL;

    return v;
}

void vectorPush_back(vector* v, void* element){
    if(v->size == v->capacity){
        if(v->capacity)
            vectorResize(v, v->capacity * v->growthFactor);
        else
            vectorResize(v, 1);
    }

    v->at[v->size] = element;
    v->size++;
}

void vectorPop_back(vector* v){
    if(!v->size)
        return;

    free(v->at[v->size-1]);
    v->size--;
}

void vectorInsert(vector* v, void* element, int pos){
    if(pos > v->size || pos < 0){
        fprintf(stderr, "INSERT INVALID\n");
        return;
    }

    vectorPush_back(v, v->at[v->size-1]);
    for(int i=v->size-1; i>pos; i--)
        v->at[i] = v->at[i-1];
    
    v->at[pos] = element;
}

void vectorErase(vector* v, int pos){
    if(pos > v->size || pos < 0){
        fprintf(stderr, "ERASE INVALID\n");
        return;
    }

    free(v->at[pos]);

    for(int i=pos; i<v->size; i++){
        v->at[i] = v->at[i+1];
    }
    v->size--;
}

void vectorResize(vector* v, int capacity){
    for(int i=v->size; i>capacity; i--)
        free(v->at[i-1]);
    

        void **at = realloc(v->at, sizeof(void *) * capacity);
        v->at = at;
        v->capacity = capacity;
}

void vectorClear(vector* v){
    vectorResize(v, 0);
    v->size = 0;
}

void vectorSwap(void** a, void** b){
    void* tmp = *a;
    *a = *b;
    *b = tmp;
}

void vectorPrint(vector* v){
    if(v->toString == NULL){
        fprintf(stderr, "TOSTRING NOT DEFINED\n");
        return;
    }

    for(int i=0; i<v->size; i++)
        v->toString(v->at[i]);
    
    printf("\n");
}

void vectorSort(vector* v){
    if(!v->compare){
        fprintf(stderr, "compare NOT DEFINED\n");
        return;
    }

    mergeSort(v, v->compare, 0, v->size);
}

void mergeSort(vector* v, bool (*compare)(), int i, int j){
    if(i == j-1)
        return;

    mergeSort(v, compare, i, (i+j)/2);
    mergeSort(v, compare, (i+j)/2, j);
    
    vector(tmp);
    int h = i, k = (i+j)/2;

    while(h<(i+j)/2 || k<j){
        if(h==(i+j)/2 || (k<j && compare(v->at[h], v->at[k]))){
            vectorPush_back(tmp, v->at[k]);
            k++;
        }else{
            vectorPush_back(tmp, v->at[h]);
            h++;
        }   
    }

    for(h=i; h<j; h++)
        v->at[h] = tmp->at[h-i];
    
    free(tmp->at);
    free(tmp);
}

void vectorShrink_to_fit(vector* v){
    vectorResize(v, v->size);
}

bool vectorIsEmpty(vector* v){
    return v->size > 0 ? false : true;
}

void vectorFree(vector *v){
    vectorClear(v);
    free(v);
}