#include "char.h"

#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>

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

/**
 * Creates a new vector with type char
 * @param Takes in nullptr or another vector object. If an object is passed in
 * the new vector will have its size incremented by 1
 * @return Returns a new vector object
 *
 */

__attribute__((overloadable)) 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;
}

/**
 * Creates a new vector with type char
 * @param Takes in a boolean of true or false to determine if a memory
 * allocation occurs. True callocs a base memory, false does not
 * @return Returns a new vector object
 *
 */

__attribute__((overloadable)) Vec8_t
create(const _Bool init)
{
	Vec8_t vec = { .arr = nullptr, .size = 0, .capacity = CAPACITY };
	if (init)
	{
		vec.arr = calloc(vec.capacity, sizeof(char));
	}
	return vec;
}

Vec8_t
reserve(Vec8_t* ptr, const size_t max_size)
{
	Vec8_t ret = create(nullptr);
	char* res = reallocf(ptr->arr, max_size * sizeof(char));
	ret.arr = res;
	ret.capacity = max_size * sizeof(char);
	ret.size = ptr->size;
	if (ret.size > max_size) ret.size = max_size;
	return ret;
}

Vec8_t
shrink_to_fit(Vec8_t* ptr)
{
	return reserve(ptr, ptr->size);
}

int
swap(Vec8_t* ptr, Vec8_t* ptr_other)
{
	Vec8_t empty = create(false);
	if (ptr == nullptr || ptr_other == nullptr) return 0;
	if (ptr->arr == nullptr || ptr_other->arr == nullptr) return 0;
	empty.arr = ptr->arr;
	ptr->arr = nullptr;
	ptr->arr = ptr_other->arr;
	ptr_other->arr = nullptr;
	ptr_other->arr = empty.arr;
	if (ptr != nullptr && ptr_other != nullptr)
	{
		empty.capacity = ptr->capacity;
		ptr->capacity = ptr_other->capacity;
		empty.size = ptr->size;
		ptr->size = ptr_other->size;

		ptr_other->capacity = empty.capacity;
		ptr_other->size = empty.size;
		return 1;
	}
	free(ptr);
	free(ptr_other);
	return 0;
}

char*
data(const Vec8_t* ptr)
{
	if (ptr == nullptr || ptr->arr == nullptr) return nullptr;
	return &ptr->arr[0];
}

size_t
max_size(const Vec8_t* ptr)
{
	return ptr->capacity;
}

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->size > 0)
	{
		for (int i = 0; i < vec->size; i++)
		{
			if (!vec->arr) continue;
			vec->arr[i] = 0;
		}
		vec->size = 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)
	{
		fprintf(stderr,
			"At Index: [%i] is out of bounds for size: [%zu]", idx,
			vec->size);
		exit(-4);
		// return -4;
	}
	if (vec != nullptr && vec->arr != nullptr && vec->size > idx)
	{
		return vec->arr[idx];
	}
	return -1;
}

__attribute__((overloadable)) Vec8_t*
erase(Vec8_t* vec, const size_t iter)
{
	if (vec == nullptr) return nullptr;
	if (vec->arr == nullptr) return nullptr;
	if (iter >= vec->size) return nullptr;
	memmove(&vec->arr[iter], &vec->arr[iter + 1],
		(vec->size - iter - 1) * sizeof(char));
	vec->arr[vec->size - 1] = 0;
	vec->size--;
	return vec;
}

__attribute__((overloadable)) Vec8_t*
erase(Vec8_t* vec, const size_t iter_start, const size_t iter_end)
{
	if (vec == nullptr) return nullptr;
	if (vec->arr == nullptr) return nullptr;
	if (iter_start < 0 || iter_end > vec->size) return nullptr;
	if (iter_start >= iter_end) return nullptr;
	size_t diff = iter_end - iter_start;
	memmove(&vec->arr[iter_start], &vec->arr[iter_end],
		(vec->size - iter_end) * sizeof(char));
	for (size_t i = vec->size - diff; i < vec->size; i++)
	{
		vec->arr[i] = 0;
	}
	vec->size -= diff;
	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;
}

Vec8_t
pop_back(Vec8_t* vec)
{
	if (vec == nullptr || vec->arr == nullptr || vec->size <= 0)
		return *vec;
	vec->arr[vec->size - 1] = 0;
	vec->size = vec->size - 1;
	return *vec;
}

__attribute__((overloadable)) Vec8_t
resize(Vec8_t* vec, size_t size)
{
	Vec8_t nvec = create(nullptr);
	if (vec == nullptr || vec->arr == nullptr) return nvec;
	if (size <= 0 || vec->size <= 0)
	{
		fprintf(stderr,
			"Size or Vector Size is at or below 0 and is invalid");
		return nvec;
	}
	for (size_t i = size; i < vec->size; i++)
	{
		vec->arr[i] = '\0';
	}
	return *vec;
}

__attribute__((overloadable)) Vec8_t
resize(Vec8_t* vec, size_t size, char val)
{
	Vec8_t nvec = create(nullptr);
	if (vec == nullptr || vec->arr == nullptr) return nvec;
	if (size <= 0 || vec->size <= 0)
	{
		fprintf(stderr,
			"Size or Vector Size is at or below 0 and is invalid");
		return nvec;
	}
	if (size == vec->size)
	{
		fprintf(stderr,
			"Size and Vector Size are equal to each other and is "
			"invalid");
		return nvec;
	}
	if (size < vec->size)
	{
		fprintf(stderr, "Size is below Vector Size is invalid");
		return nvec;
	}
	if (size >= vec->capacity)
	{
		nvec = reserve(vec, size);
	}
	size_t ret = vec->size;
	vec->size = vec->size + (size - vec->size);

	for (size_t i = ret; i < vec->size; i++)
	{
		if (at(vec, (int)i) >= 0)
		{
			vec->arr[i] = val;
		}
	}
	return *vec;
}

__attribute__((overloadable)) Vec8_t
assign(Vec8_t* vec, const Vec8_t* iterator, size_t iter_start, size_t iter_end)
{
	Vec8_t ret = create(nullptr);
	if (vec == nullptr || vec->arr == nullptr) return ret;
	if (iterator == nullptr || iterator->arr == nullptr) return ret;
	if (iter_end <= iter_start) return ret;
	vec = erase(vec, begin(vec), end(vec) + 1);
	size_t res = iter_end - iter_start;
	*vec = reserve(vec, res);
	for (size_t i = iter_start; i < iter_end; i++)
	{
		*vec = add_back(vec, at(iterator, (int)i));
	}
	return *vec;
}

__attribute__((overloadable)) Vec8_t
assign(Vec8_t* vec, const size_t amount, char val)
{
	Vec8_t ret = create(nullptr);
	if (vec == nullptr || vec->arr == nullptr) return ret;
	vec = erase(vec, begin(vec), end(vec) + 1);
	*vec = reserve(vec, amount);
	for (int i = 0; i < amount; i++)
	{
		*vec = add_back(vec, val);
	}
	return *vec;
}

__attribute__((overloadable)) Vec8_t
insert(Vec8_t* vec, size_t iter, char val)
{
}

__attribute__((overloadable)) Vec8_t
insert(Vec8_t* vec, size_t iter, size_t amount, char val)
{
}

__attribute__((overloadable)) Vec8_t
insert(Vec8_t* dst_vec, size_t iter, Vec8_t* src_vec, size_t iter_start,
       size_t iter_end)
{
}

/* insert()	Inserts a number of elements into a vector vector can have
	vector.insert(iterator position, <type> value);
	vector.insert(iterator position, size_t amount, <type> value);
	vector.insert(iterator position (vector to add to), iterator to add
 with (other vector) iterator start, iterator end);
 * */