#include <stdio.h>

#include "vector.h"
#include "util.h"
#include "macro.h"
#include "munit/munit.h"

static MunitResult
test_vector_len(const MunitParameter params[], void * data)
{
	ivector v;
	vector_init(&v);

	munit_assert_size(vector_len(&v), ==, 0);

	// Lame method, that checks vector_len getter
	v.n = 1337;
	munit_assert_size(vector_len(&v), ==, 1337);

	vector_free(&v);
	munit_assert_size(vector_len(&v), ==, 0);

	return MUNIT_OK;
}

static MunitResult
test_vector_data(const MunitParameter params[], void * data)
{
	// (Really stupid) test for vector_data
	ivector v;
	vector_init(&v);

	munit_assert_not_null(vector_data(&v));
	vector_free(&v);
	munit_assert_null(vector_data(&v));

	return MUNIT_OK;
}

static MunitResult
test_vector_initdata(const MunitParameter params[], void * data)
{
	int *p;
	int i;
	ivector v;
	int arr[] = {
		1, 2, 3, 4, 5
	};

	vector_initdata(&v, arr, ARRSZ(arr));
	p = vector_data(&v);
	munit_assert_not_null(p);
	munit_assert_size(vector_len(&v), ==, ARRSZ(arr));

	for (i = 0; i < ARRSZ(arr); i++) {
		munit_assert_int(arr[i], ==, p[i]);
	}
	vector_free(&v);

	return MUNIT_OK;
}

static MunitResult
test_vector_resize(const MunitParameter params[], void * data)
{
	int i;
	int arr[] = {
		1, 2, 3, 4, 5
	};
	int *p;

	ivector v;

	vector_initdata(&v, arr, ARRSZ(arr));
	vector_resize(&v, 16);
	munit_assert_size(vector_len(&v), ==, 16);

	munit_assert_size(v.n, <=, v.maxsz);

	// Try to check that new memory is really zeroed
	i = ARRSZ(arr);
	p = vector_data(&v);
	for (; i < 16; i++) {
		munit_assert_int(0, ==, p[i]);
	}

	vector_free(&v);
	return MUNIT_OK;
}

static MunitResult
test_vector_set_get(const MunitParameter params[], void * data)
{
	int arr[] = {
		1, 2, 3, 4, 5
	};
	ivector v;
	int *p;
	int i;

	vector_initdata(&v, arr, ARRSZ(arr));
	for (i = 0; i < vector_len(&v); i++) {
		vector_set(&v, i, i);
	}

	p = vector_data(&v);
	for (i = 0; i < vector_len(&v); i++) {
		int item = vector_get(&v, i);
		munit_assert_int(item, ==, i);
		//double check with raw pointer
		munit_assert_int(p[i], ==, i);
	}

	vector_free(&v);
	return MUNIT_OK;
}

static MunitResult
test_vector_push_pop(const MunitParameter params[], void * data)
{
	int arr[] = {
		1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
		11, 12, 13, 14, 15, 16, 17, 18, 19, 20};
	int i, tmp;

	ivector v;

	vector_init(&v);

	for (i = 0; i < ARRSZ(arr); i++) {
		vector_push(&v, arr[i]);
	}
	munit_assert_size(vector_len(&v), ==, ARRSZ(arr));

	// test vector_get
	for (i = 0; i < ARRSZ(arr); i++) {
		tmp = vector_get(&v, i);
		munit_assert_int(tmp, ==, arr[i]);
	}
	munit_assert_size(vector_len(&v), ==, ARRSZ(arr));


	vector_pop(&v);
	vector_pop(&v);

	for (i = 0; i < ARRSZ(arr) - 2; i++) {
		tmp = vector_get(&v, i);
		munit_assert_int(tmp, ==, arr[i]);
	}
	munit_assert_size(vector_len(&v), ==, ARRSZ(arr) - 2);

	//test vector_pop underflow
	for (i = 0; i < ARRSZ(arr); i++) {
		vector_pop(&v);
	}
	munit_assert_size(vector_len(&v), ==, 0);

	//test vector_pop

	vector_free(&v);

	return MUNIT_OK;
}

static MunitResult
test_vector_insert(const MunitParameter params[], void* data) {
    ivector v;
    vector_init(&v);
    
    // В�тавка в пу�той вектор
    vector_insert(&v, 0, 1);
    munit_assert_size(vector_len(&v), ==, 1);
    munit_assert_int(vector_get(&v, 0), ==, 1);
    
    // В�тавка в начало
    vector_insert(&v, 0, 2);
    munit_assert_size(vector_len(&v), ==, 2);
    munit_assert_int(vector_get(&v, 0), ==, 2);
    munit_assert_int(vector_get(&v, 1), ==, 1);
    
    // В�тавка в конец
    vector_insert(&v, 2, 3);
    munit_assert_size(vector_len(&v), ==, 3);
    munit_assert_int(vector_get(&v, 2), ==, 3);
    
    // В�тавка в �ередину
    vector_insert(&v, 1, 4);
    munit_assert_size(vector_len(&v), ==, 4);
    munit_assert_int(vector_get(&v, 1), ==, 4);
    munit_assert_int(vector_get(&v, 2), ==, 1);
    
    vector_free(&v);
    return MUNIT_OK;
}

static MunitResult
test_vector_del(const MunitParameter params[], void* data) {
    ivector v;
    int init[] = {1, 2, 3, 4, 5};
    vector_initdata(&v, init, ARRSZ(init));
    
    // Удаление из начала
    vector_del(&v, 0);
    munit_assert_size(vector_len(&v), ==, 4);
    munit_assert_int(vector_get(&v, 0), ==, 2);
    
    // Удаление из конца
    vector_del(&v, 3);
    munit_assert_size(vector_len(&v), ==, 3);
    munit_assert_int(vector_get(&v, 2), ==, 4);
    
    // Удаление из �ередины
    vector_del(&v, 1);
    munit_assert_size(vector_len(&v), ==, 2);
    munit_assert_int(vector_get(&v, 0), ==, 2);
    munit_assert_int(vector_get(&v, 1), ==, 4);
    
    vector_free(&v);
    return MUNIT_OK;
}

#define TEST_ITEM(func) {#func, func, NULL, NULL, MUNIT_TEST_OPTION_NONE }

static MunitTest test_suite_tests[] = {
	TEST_ITEM(test_vector_len),
	TEST_ITEM(test_vector_data),
	TEST_ITEM(test_vector_initdata),

	TEST_ITEM(test_vector_resize),
	TEST_ITEM(test_vector_set_get),
	TEST_ITEM(test_vector_push_pop),
	TEST_ITEM(test_vector_insert),
	TEST_ITEM(test_vector_del),
	{ NULL, NULL, NULL, NULL, MUNIT_TEST_OPTION_NONE, NULL }
};

static const MunitSuite test_suite = {
	(char *) "",
	test_suite_tests,
	NULL,
	1,
	MUNIT_SUITE_OPTION_NONE
};


int
main(int argc, const char *argv[])
{
	munit_suite_main(&test_suite, (void *) "vector_test", argc, (char * const*) argv);
	return 0;
}