// EXAMPLES : https://pastebin.com/VLCGGW7c
#if defined __C_VECTOR_INCLUDED__
    #endinput
#endif
#define __C_VECTOR_INCLUDED__
#define __C_VECTOR_VERSION__ 0x200

#include <YSI_Coding\y_malloc>
#tryinclude <YSI_Data\y_iterate>

#define VECTOR_NULL                     (Vector:NO_ALLOC)
#define INVALID_VECTOR_INDEX            (cellmin)

enum _:E_VECTOR {
    Alloc:E_VECTOR_DATA,
    E_VECTOR_SIZE
}

#if defined _INC_y_iterate

iterfunc stock vector(&iterstate, cur, Vector:vector, array[] = cellmin, size = sizeof(array)) {
    #pragma unused cur
    if(array[0] == cellmin) {
        return vector_get_value(vector, iterstate++);
    } else {
        return vector_get_array(vector, iterstate++, array, size);
    }
}
#define iterstart@vector iterstate(INVALID_VECTOR_INDEX, 0)

iterfunc stock array(&iterstate, cur, const array[], size, size2 = sizeof(array)) {
    #pragma unused cur
    if(iterstate < size && iterstate < size2) {
        return array[iterstate++];
    }
    return INVALID_VECTOR_INDEX;
}
#define iterstart@array iterstate(INVALID_VECTOR_INDEX, 0)

#endif

static stock vector_push_back_ptr(&Vector:vector, &Alloc:ptr, size = 0) {
    new 
        v[E_VECTOR];

    if(vector == VECTOR_NULL) {
        v[E_VECTOR_DATA] = malloc(E_VECTOR, true);
        v[E_VECTOR_SIZE] = E_VECTOR;
        vector = Vector:malloc(E_VECTOR);
    } else {
        memcpy(v, YSI_gMallocMemory[_:vector], 0, E_VECTOR * 4, E_VECTOR);
        v[E_VECTOR_SIZE] += E_VECTOR;
        new 
            Alloc:a = malloc(v[E_VECTOR_SIZE], true);

        memcpy(YSI_gMallocMemory[_:a], YSI_gMallocMemory[_:v[E_VECTOR_DATA]], 0, v[E_VECTOR_SIZE]*4, v[E_VECTOR_SIZE]);
        free(v[E_VECTOR_DATA]);
        v[E_VECTOR_DATA] = a;
    }

    new 
        value_ptr[E_VECTOR];

    ptr = value_ptr[E_VECTOR_DATA] = malloc(size == 0 ? 1 : size, true);
    value_ptr[E_VECTOR_SIZE] = size;

    memcpy(YSI_gMallocMemory[_:vector], v, 0, E_VECTOR * 4, E_VECTOR);
    memcpy(YSI_gMallocMemory[_:v[E_VECTOR_DATA] + (v[E_VECTOR_SIZE] - E_VECTOR)], value_ptr, 0, E_VECTOR * 4, E_VECTOR);
}

stock vector_push_back_value(&Vector:vector, value) {
    new 
        Alloc:ptr;

    vector_push_back_ptr(vector, ptr);
    YSI_gMallocMemory[_:ptr] = value;
}

stock vector_push_back_array(&Vector:vector, const array[], size = sizeof(array)) {
    new 
        Alloc:ptr;

    vector_push_back_ptr(vector, ptr, size);
    memcpy(YSI_gMallocMemory[_:ptr], array, 0, size * 4, size);
}

stock vector_remove(&Vector:vector, index) {
    if(vector != VECTOR_NULL) {
        new 
            v[E_VECTOR];

        memcpy(v, YSI_gMallocMemory[_:vector], 0, E_VECTOR * 4, E_VECTOR);
        index *= E_VECTOR;

        if(0 <= index < v[E_VECTOR_SIZE]) {
            if(index == 0 && (v[E_VECTOR_SIZE] - E_VECTOR) == 0) {
                vector_free(vector);
            } else {
                free(Alloc:mget(v[E_VECTOR_DATA] + Alloc:index, E_VECTOR_DATA));

                for(new i = index, j = index + E_VECTOR; j < v[E_VECTOR_SIZE]; i += E_VECTOR) {
                    YSI_gMallocMemory[_:v[E_VECTOR_DATA] + i] = YSI_gMallocMemory[_:v[E_VECTOR_DATA] + j];
                    YSI_gMallocMemory[_:v[E_VECTOR_DATA] + i + E_VECTOR_SIZE] = YSI_gMallocMemory[_:v[E_VECTOR_DATA] + j + E_VECTOR_SIZE];
                    j += E_VECTOR;
                }

                v[E_VECTOR_SIZE] -= E_VECTOR;

                new 
                    Alloc:a = malloc(v[E_VECTOR_SIZE], true);

                memcpy(YSI_gMallocMemory[_:a], YSI_gMallocMemory[_:v[E_VECTOR_DATA]], 0, (v[E_VECTOR_SIZE])*4, v[E_VECTOR_SIZE]);
                free(v[E_VECTOR_DATA]);
                v[E_VECTOR_DATA] = a;

                memcpy(YSI_gMallocMemory[_:vector], v, 0, E_VECTOR * 4, E_VECTOR);
            }

            return true;
        }
    }

    return false;
}

stock vector_get_value(Vector:vector, index) {
    if(vector != VECTOR_NULL) {
        new 
            v_data = YSI_gMallocMemory[_:vector],
            v_size = YSI_gMallocMemory[_:vector + E_VECTOR_SIZE];

        index *= 2;

        if(0 <= index < v_size) {
            return YSI_gMallocMemory[YSI_gMallocMemory[v_data + index]];
        }
    }

    return INVALID_VECTOR_INDEX;
}

stock vector_get_array(Vector:vector, index, array[], size = sizeof(array)) {
    if(vector != VECTOR_NULL) {
        new 
            v_data = YSI_gMallocMemory[_:vector],
            v_size = YSI_gMallocMemory[_:vector + E_VECTOR_SIZE];

        index *= 2;

        if(0 <= index < v_size) {
            new 
                ptr_data = YSI_gMallocMemory[v_data + index],
                ptr_size = YSI_gMallocMemory[v_data + index + E_VECTOR_SIZE];

            new 
                n_sz = ((size > ptr_size) ? ptr_size : size);

            memcpy(array, YSI_gMallocMemory[ptr_data], 0, n_sz * 4, n_sz);

            return n_sz;
        }
    }

    return INVALID_VECTOR_INDEX;
}

stock vector_set_value(Vector:vector, index, value) {
    if(vector != VECTOR_NULL) {
        new 
            v[E_VECTOR];

        memcpy(v, YSI_gMallocMemory[_:vector], 0, E_VECTOR * 4, E_VECTOR);
        index *= 2;

        if(0 <= index < v[E_VECTOR_SIZE]) {
            YSI_gMallocMemory[YSI_gMallocMemory[_:v[E_VECTOR_DATA] + index]] = value;
        }
    }
}

stock vector_set_array(Vector:vector, index, array[], size = sizeof(array)) {
    if(vector != VECTOR_NULL) {
        new 
            v[E_VECTOR];

        memcpy(v, YSI_gMallocMemory[_:vector], 0, E_VECTOR * 4, E_VECTOR);
        index *= 2;

        if(0 <= index < v[E_VECTOR_SIZE]) {
            new 
                ptr[E_VECTOR];

            memcpy(ptr, YSI_gMallocMemory[_:v[E_VECTOR_DATA] + index], 0, E_VECTOR * 4, E_VECTOR);
            if(size != ptr[E_VECTOR_SIZE]) {
                free(ptr[E_VECTOR_DATA]);
                ptr[E_VECTOR_DATA] = malloc(size, true);
                ptr[E_VECTOR_SIZE] = size;
            }

            memcpy(YSI_gMallocMemory[_:ptr[E_VECTOR_DATA]], array, 0, size * 4, size);
            memcpy(YSI_gMallocMemory[_:v[E_VECTOR_DATA] + index], ptr, 0, E_VECTOR * 4, E_VECTOR);
        }
    }
}

stock bool:vector_is_storing_array(Vector:vector) {
    if(vector != VECTOR_NULL) {
        return YSI_gMallocMemory[YSI_gMallocMemory[_:vector + E_VECTOR_DATA] + E_VECTOR_SIZE] != 0;
    }

    return false;
}

stock vector_free(&Vector:vector) {
    if(vector != VECTOR_NULL) {
        new 
            v[E_VECTOR];
    
        memcpy(v, YSI_gMallocMemory[_:vector], 0, E_VECTOR * 4, E_VECTOR);

        for(new i = 0; i < v[E_VECTOR_SIZE]; i += 2) {
            free(Alloc:YSI_gMallocMemory[_:v[E_VECTOR_DATA] + i]);
        }

        free(v[E_VECTOR_DATA]);
        free(Alloc:vector);
        vector = VECTOR_NULL;
    }
}

stock vector_get_array_size(Vector:vector, index) {
    if(vector != VECTOR_NULL) {
        new 
            v[E_VECTOR];

        memcpy(v, YSI_gMallocMemory[_:vector], 0, E_VECTOR * 4, E_VECTOR);
        index *= 2;

        if(0 <= index < v[E_VECTOR_SIZE]) {
            return YSI_gMallocMemory[_:v[E_VECTOR_DATA] + E_VECTOR_SIZE];
        }
    }

    return 0;
}

stock vector_get_size(Vector:vector) {
    if(vector != VECTOR_NULL) {
        return YSI_gMallocMemory[_:vector + E_VECTOR_SIZE] / E_VECTOR;
    }

    return 0;
}