/*
 * Andrew Haynes
 * dmm.dev@icloud.com
 * No LICENSE
 * Vector Library For C
 */

/*
 * All functions needed
 * Ones that start with '>' I have completed
 *
 * > at()	Returns an indexed element from a vector
 * > back()	Returns the last element of a vector
 * > begin()	Returns an iterator pointing to the beginning of a vector
 * > capacity()	Returns the number of elements that a vector's reserved memory is able to store
 * > front()	Returns the first element of a vector
 * > end() Returns an iterator pointing to the end of a vector
 * > push_back()	Adds an element to the end of a vector
 * > size()	Returns the number of elements in a vector
 * > clear()	Removes all of the contents of a vector
 * > empty()	Checks whether a vector is empty or not
 *
 * assign()	Fills a vector with multiple values
 * data() Returns a pointer to the block of memory where a vector's elements are
 * stored  erase()	Removes
 * a number of elements from a vector insert()	Inserts a number of elements
 * into a vector max_size()	Returns the maximum number of elements that a
 * vector can have pop_back()	Removes the last element of a vector rbegin()
 * Returns a reverse iterator pointing to the last element of a vector rend()
 * Returns a reverse iterator pointing to a position right before the first
 * element of a vector reserve()	Reserves memory for a vector resize()
 * Changes the size of a vector, adding or removing elements if necessary
 * shrink_to_fit()	Reduces the reseved memory of a vector if necessary to
 * exactly fit the number of elements swap()	Swaps the contents of one vector
 * with another
 * */

/*
 * Types Wanted:
 *      Char
 *      Float
 *      Int
 *      String
 */

/* Absolutely no AI is permitted when writing code.
 * AI is and can be used to generate tests for code; however, the test results
 * and the AI can not give code as to how to fix the source aside from psuedo
 * code that has no clear relation to the source aside from a recreation of the
 * problem in a different way entirely
 *
 * Any code comments below are just used for my purposes with short term memory.
 * It also serves as a way to remember what needs to be changed to be readable
 * and not need comments in the first place.
 */
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct
{
	char* arr;
	size_t size;
	size_t capacity;
} Vec8_t;

#define CAPACITY 1024

Vec8_t
create(const Vec8_t* input)
{
	Vec8_t vec = { .arr = nullptr, .size = 0, .capacity = CAPACITY };
	if (input != nullptr && input->size > 0)
	{
		vec.size = input->size + 1;
	}
	vec.arr = calloc(vec.capacity, sizeof(char));
	return vec;
}

void
delete(Vec8_t* vec)
{
	if (vec->arr != nullptr)
	{
		free(vec->arr);
	}
	vec->arr = nullptr;
}

Vec8_t
clear(Vec8_t* vec)
{
	if (vec != nullptr && vec->capacity > 0)
	{
                for(int i = 0; i < vec->size; i++) {
                        if(!vec->arr) continue;
                        vec->arr[i] = 0;
                }
	}
        return *vec;
}

char
at(const Vec8_t* vec, const int idx)
{
	if (vec == nullptr)
	{
		return -2;
	}
	if (vec->arr == nullptr)
	{
		return -3;
	}
	if (vec->size <= idx)
	{
		return -4;
	}
	if (vec != nullptr && vec->arr != nullptr && vec->size > idx)
	{
		return vec->arr[idx];
	}
	return -1;
}

Vec8_t*
erase(Vec8_t* vec, const int iter) {
        /*
         * Clear the value at iter to 0
         * shift all the values in the vector over to the left one
         * */
        if(vec == nullptr) return nullptr;
        if(vec->arr == nullptr) return nullptr;
        vec->arr[iter] = 0;
        memmove(&vec[iter], &vec[iter + 1], (vec->size * sizeof(char)) -1);
        return vec;
}

void
print_vec(const Vec8_t* vec)
{
	for (int i = 0; i < vec->size; i++)
	{
		if (vec->arr[i])
		{
			printf("%c ", at(vec, i));
		}
	}
	printf("\n");
}

int
begin(const Vec8_t* vec)
{
	if (vec != nullptr && vec->arr != nullptr && vec->size > 0)
	{
		return 0;
	}
	return -1;
}

int
end(const Vec8_t* vec)
{
	if (vec != nullptr && vec->arr != nullptr && vec->size > 0)
	{
		return (int)(vec->size - 1);
	}
	return -1;
}

char
front(const Vec8_t* vec)
{
	return at(vec, 0);
}

char
back(const Vec8_t* vec)
{
	if (vec)
	{
		return at(vec, (int)vec->size - 1);
	}
	return -1;
}

int
empty(const Vec8_t* vec) {

        if(vec->size > 0) {
                return 1;
        }
        return 0;
}

Vec8_t
add_back(Vec8_t* vec, const char val)
{
	if (vec->size >= vec->capacity)
	{
		vec->capacity *= 2;
		char* nvec = reallocf(vec->arr, vec->capacity * sizeof(char));
		if (nvec == NULL)
		{
			return *vec;
		}
		vec->arr = nvec;
	}
	vec->arr[vec->size] = val;
	vec->size++;
	return *vec;
}

int
main()
{
	Vec8_t vec = create(nullptr);
	vec = add_back(&vec, '3');
	vec = add_back(&vec, '4');
	vec = add_back(&vec, '5');
	vec = add_back(&vec, '6');
	vec = add_back(&vec, '8');
	vec = add_back(&vec, '6');
        vec = *erase(&vec, begin(&vec) + 2);
        // for(int i = 0; i < vec.size; i++) {
        //         printf("%i\n", at(&vec, i));
        // }
	print_vec(&vec);
	//        printf("%c", at(nullptr, 0));

	delete(&vec);
	return 0;
}