#include <iostream>
#include <string>
#include "colors.h"
#include "tests.hpp"
#include <iomanip> // std::setw()

#include <vector>
#ifdef STL
	namespace ft = std;
#else
	#include "vector.hpp"
#endif

int	main() {

/*
	TEST(vector::vector (constructor))
    {
		// title
		TITLE(cplusplus.com reference :)

		// constructors used in the same order as described above:
		std::vector<int> first;                                // empty vector of ints
		std::vector<int> second (4,100);                       // four ints with value 100
		std::vector<int> third (second.begin(),second.end());  // iterating through second
		std::vector<int> fourth (third);                       // a copy of third

		// the iterator constructor can also be used to construct from arrays:
		int myints[] = {16,2,77,29};
		std::vector<int> fifth (myints, myints + sizeof(myints) / sizeof(int) );

		std::cout << "The contents of fifth are:";
		for (std::vector<int>::iterator it = fifth.begin(); it != fifth.end(); ++it)
			std::cout << ' ' << *it;
		std::cout << '\n';
	}
	TESTEND


	TEST(vector::=operator)
	{
		// title
		TITLE(cplusplus.com reference :)

		std::vector<int> foo (3,0);
		std::vector<int> bar (5,0);

		bar = foo;
		foo = std::vector<int>();

		std::cout << "Size of foo: " << int(foo.size()) << '\n';
		std::cout << "Size of bar: " << int(bar.size()) << '\n';
	}
	TESTEND


	TEST(vector::begin)
	{
		// title
		TITLE(cplusplus.com reference :)

		std::vector<int> myvector;
		for (int i=1; i<=5; i++) myvector.push_back(i);

		std::cout << "myvector contains:";
		for (std::vector<int>::iterator it = myvector.begin() ; it != myvector.end(); ++it)
			std::cout << ' ' << *it;
		std::cout << '\n';
	}
	TESTEND


	TEST(vector::end)
	{
		// title
		TITLE(cplusplus.com reference :)

		std::vector<int> myvector;
		for (int i=1; i<=5; i++) myvector.push_back(i);

		std::cout << "myvector contains:";
		for (std::vector<int>::iterator it = myvector.begin() ; it != myvector.end(); ++it)
			std::cout << ' ' << *it;
		std::cout << '\n';
	}
	TESTEND


	TEST(vector::rbegin)
	{
		// title
		TITLE(cplusplus.com reference :)

		std::vector<int> myvector (5);  // 5 default-constructed ints

		int i=0;

		std::vector<int>::reverse_iterator rit = myvector.rbegin();
		for (; rit!= myvector.rend(); ++rit)
			*rit = ++i;

		std::cout << "myvector contains:";
		for (std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it)
			std::cout << ' ' << *it;
		std::cout << '\n';
	}
	TESTEND


	TEST(vector::rend)
	{
		// title
		TITLE(cplusplus.com reference :)

		std::vector<int> myvector (5);  // 5 default-constructed ints

		std::vector<int>::reverse_iterator rit = myvector.rbegin();

		int i=0;
		for (rit = myvector.rbegin(); rit!= myvector.rend(); ++rit)
			*rit = ++i;

		std::cout << "myvector contains:";
		for (std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it)
			std::cout << ' ' << *it;
		std::cout << '\n';
	}
	TESTEND


	TEST(vector::size)
	{
		// title
		TITLE(cplusplus.com reference :)

		std::vector<int> myints;
		std::cout << "0. size: " << myints.size() << '\n';

		for (int i=0; i<10; i++) myints.push_back(i);
		std::cout << "1. size: " << myints.size() << '\n';

		myints.insert (myints.end(),10,100);
		std::cout << "2. size: " << myints.size() << '\n';

		myints.pop_back();
		std::cout << "3. size: " << myints.size() << '\n';
	}
	TESTEND


	TEST(vector::max_size)
	{
		// title
		TITLE(cplusplus.com reference :)

		std::vector<int> myvector;

		// set some content in the vector:
		for (int i=0; i<100; i++) myvector.push_back(i);

		std::cout << "size: " << myvector.size() << "\n";
		std::cout << "capacity: " << myvector.capacity() << "\n";
		std::cout << "max_size: " << myvector.max_size() << "\n";
	}
	TESTEND
*/


	TEST(vector::resize)
	{
		// title
		TITLE(cplusplus.com reference :)

		ft::vector<int> myvector;

		// set some initial content:
		for (int i = 1; i < 10; i++) myvector.push_back(i);

		myvector.resize(5);
		myvector.resize(8,100);
		myvector.resize(12);

		std::cout << "myvector contains:";
		for (unsigned int i = 0; i < myvector.size(); i++)
			std::cout << ' ' << myvector[i];
		std::cout << '\n';


		// title
		TITLE(test size and capacity 1 :)

		ft::vector<int>	vector2;

		std::cout << "size: " << vector2.size() << " - capacity: " << vector2.capacity() << "\n\n";

		std::cout << "assign(10, 1)\n";
		vector2.assign(10, 1);
		for (unsigned int i = 0; i < vector2.size(); i++)
			std::cout << "[" << i << "]" << vector2[i] << " ";
		std::cout << "\n";

		std::cout << "\nsize: " << vector2.size() << " - capacity: " << vector2.capacity() << "\n\n";

		std::cout << "resize(15)\n";
		vector2.resize(15);
		for (unsigned int i = 0; i < vector2.size(); i++)
			std::cout << "[" << i << "]" << vector2[i] << " ";
		std::cout << "\n";

		std::cout << "\nsize: " << vector2.size() << " - capacity: " << vector2.capacity() << "\n\n";

		std::cout << "resize(10)\n";
		vector2.resize(10);
		for (unsigned int i = 0; i < vector2.size(); i++)
			std::cout << "[" << i << "]" << vector2[i] << " ";
		std::cout << "\n";

		std::cout << "\nsize: " << vector2.size() << " - capacity: " << vector2.capacity() << "\n\n";

		std::cout << "resize(19)\n";
		vector2.resize(19);
		for (unsigned int i = 0; i < vector2.size(); i++)
			std::cout << "[" << i << "]" << vector2[i] << " ";
		std::cout << "\n";

		std::cout << "\nsize: " << vector2.size() << " - capacity: " << vector2.capacity() << "\n\n";

		std::cout << "resize(20)\n";
		vector2.resize(20);
		for (unsigned int i = 0; i < vector2.size(); i++)
			std::cout << "[" << i << "]" << vector2[i] << " ";
		std::cout << "\n";

		std::cout << "\nsize: " << vector2.size() << " - capacity: " << vector2.capacity() << "\n\n";

		std::cout << "resize(21)\n";
		vector2.resize(21);
		for (unsigned int i = 0; i < vector2.size(); i++)
			std::cout << "[" << i << "]" << vector2[i] << " ";
		std::cout << "\n";


		// title
		TITLE(test size and capacity 2 :)

		ft::vector<int>	vector3;

		std::cout << "size: " << vector3.size() << " - capacity: " << vector3.capacity() << "\n\n";

		std::cout << "assign(10, 1)\n";
		vector3.assign(10, 1);
		for (unsigned int i = 0; i < vector3.size(); i++)
			std::cout << "[" << i << "]" << vector3[i] << " ";
		std::cout << "\n";

		std::cout << "\nsize: " << vector3.size() << " - capacity: " << vector3.capacity() << "\n\n";

		std::cout << "resize(21)\n";
		vector3.resize(21);
		for (unsigned int i = 0; i < vector3.size(); i++)
			std::cout << "[" << i << "]" << vector3[i] << " ";
		std::cout << "\n";

		std::cout << "\nsize: " << vector3.size() << " - capacity: " << vector3.capacity() << "\n\n";
	}
	TESTEND


	TEST(vector::capacity)
	{
		// title
		TITLE(cplusplus.com reference :)

		ft::vector<int> myvector;

		// set some content in the vector:
		for (int i=0; i<100; i++) myvector.push_back(i);

		std::cout << "size: " << (int) myvector.size() << '\n';
		std::cout << "capacity: " << (int) myvector.capacity() << '\n';
		std::cout << "max_size: " << (int) myvector.max_size() << '\n';
	}
	TESTEND


	TEST(vector::empty)
	{
		// title
		TITLE(cplusplus.com reference :)

		ft::vector<int>	myvector;
		int				sum (0);

		for (int i=1;i<=10;i++) myvector.push_back(i);

		while (!myvector.empty())
		{
			sum += myvector.back();
			myvector.pop_back();
		}

		std::cout << "total: " << sum << '\n';
	}
	TESTEND


	TEST(vector::reserve)
	{
		// title
		TITLE(cplusplus.com reference :)

		ft::vector<int>::size_type	sz;
		ft::vector<int>				foo;

		sz = foo.capacity();
		std::cout << "making foo grow:\n";
		for (int i=0; i<100; ++i) {
			foo.push_back(i);
			if (sz!=foo.capacity()) {
				sz = foo.capacity();
				std::cout << "capacity changed: " << sz << '\n';
			}
		}

		ft::vector<int> bar;

		sz = bar.capacity();
		bar.reserve(100);   // this is the only difference with foo above
		std::cout << "making bar grow:\n";
		for (int i=0; i<100; ++i) {
			bar.push_back(i);
			if (sz!=bar.capacity()) {
				sz = bar.capacity();
				std::cout << "capacity changed: " << sz << '\n';
			}
		}
	}
	TESTEND


	TEST(vector::operator[])
	{
		// title
		TITLE(cplusplus.com reference :)

		ft::vector<int>				myvector (10);   // 10 zero-initialized elements
		ft::vector<int>::size_type	sz = myvector.size();

		// assign some values:
		for (unsigned i=0; i<sz; i++) myvector[i]=i;

		// reverse vector using operator[]:
		for (unsigned i=0; i<sz/2; i++)
		{
			int temp;
			temp = myvector[sz-1-i];
			myvector[sz-1-i]=myvector[i];
			myvector[i]=temp;
		}

		std::cout << "myvector contains:";
		for (unsigned i=0; i<sz; i++)
			std::cout << ' ' << myvector[i];
		std::cout << '\n';
	}
	TESTEND


	TEST(vector::at)
	{
		// title
		TITLE(cplusplus.com reference :)

		ft::vector<int> myvector (10);   // 10 zero-initialized ints

		// assign some values:
		for (unsigned i=0; i<myvector.size(); i++)
			myvector.at(i)=i;

		std::cout << "myvector contains:";
		for (unsigned i=0; i<myvector.size(); i++)
			std::cout << ' ' << myvector.at(i);
		std::cout << '\n';
	}
	TESTEND


	TEST(vector::front)
	{
		// title
		TITLE(cplusplus.com reference :)

		ft::vector<int> myvector;

		myvector.push_back(78);
		myvector.push_back(16);

		// now front equals 78, and back 16

		myvector.front() -= myvector.back();

		std::cout << "myvector.front() is now " << myvector.front() << '\n';
	}
	TESTEND


	TEST(vector::back)
	{
		// title
		TITLE(cplusplus.com reference :)

		ft::vector<int> myvector;

		myvector.push_back(78);
		myvector.push_back(16);

		// now front equals 78, and back 16

		myvector.front() -= myvector.back();
		std::cout << "myvector.front() is now " << myvector.front() << '\n';


		// title
		TITLE(test with negatives :)

		myvector.push_back(236);
		myvector.push_back(8973);

		myvector.front() -= myvector.back();
		std::cout << "myvector.front() is now " << myvector.front() << '\n';


		// title
		TITLE(test with char :)

		ft::vector<char> letters;
		letters.push_back('o');
		letters.push_back('m');
		letters.push_back('g');
		letters.push_back('w');
		letters.push_back('t');
		letters.push_back('f');

		if (!letters.empty()) {
			std::cout << "The first character is '" << letters.front() << "'.\n";
		}
	}
	TESTEND

	TEST(vector::assign)
	{
		// title
		TITLE(cplusplus.com reference :)

		ft::vector<int> first;
		ft::vector<int> second;
		ft::vector<int> third;

		first.assign (7,100);             // 7 ints with a value of 100

		ft::vector<int>::iterator it;
		it=first.begin()+1;

		second.assign (it,first.end()-1); // the 5 central values of first

		int myints[] = {1776,7,4};
		third.assign (myints,myints+3);   // assigning from array.

		std::cout << "Size of first: " << int (first.size()) << '\n';
		std::cout << "Size of second: " << int (second.size()) << '\n';
		std::cout << "Size of third: " << int (third.size()) << '\n';

		// title
		TITLE(capacity tests of assignation :)

		ft::vector<int> myvector;
		int	size;

		std::cout << "capacity before assignation : " << myvector.capacity() << "\n";

		std::cout << "\nassign 1\n";
		myvector.assign(1, 12);
		size = myvector.size();
		for (int i = 0; i < size; i++)
			std::cout << "[" << i << "] " << myvector[i] << " - ";
		std::cout << "\nsize : " << size << " , capacity : "  << myvector.capacity() << "\n";

		std::cout << "\nassign 3\n";
		myvector.assign(3, 12);
		size = myvector.size();
		for (int i = 0; i < size; i++)
			std::cout << "[" << i << "] " << myvector[i] << " - ";
		std::cout << "\nsize : " << size << " , capacity : "  << myvector.capacity() << "\n";

		std::cout << "\nassign 7268\n";
		myvector.assign(7268, 12);
		size = myvector.size();
		for (int i = 0; i < size; i++)
			std::cout << "[" << i << "] " << myvector[i] << " - ";
		std::cout << "\nsize : " << size << " , capacity : "  << myvector.capacity() << "\n";


		// title
		TITLE(tests of iterators :)

		ft::vector<int> int_vector_1;
		ft::vector<int> int_vector_2;
		ft::vector<int> int_vector_3;
		ft::vector<int> it_vector;
		int	ssize;

		std::cout << "\nassign 1\n";
		int_vector_1.assign(1, 12);
		it_vector.assign(int_vector_1.begin(), int_vector_1.end());
		ssize = it_vector.size();
		for (int i = 0; i < ssize; i++)
			std::cout << "[" << i << "] " << it_vector[i] << " - ";
		std::cout << "\nsize : " << ssize << " , capacity : "  << it_vector.capacity() << "\n";

		std::cout << "\nassign 0\n";
		int_vector_2.assign(1, 6);
		it_vector.assign(int_vector_2.begin(), int_vector_2.end() - 1);
		ssize = it_vector.size();
		for (int i = 0; i < ssize; i++)
			std::cout << "[" << i << "] " << it_vector[i] << " - ";
		std::cout << "\nsize : " << ssize << " , capacity : "  << it_vector.capacity() << "\n";

		std::cout << "\nassign 266 - 13 - 172 = 81\n";
		int_vector_3.assign(266, 1);
		it_vector.assign(int_vector_3.begin() + 13, int_vector_3.end() - 172);
		ssize = it_vector.size();
		for (int i = 0; i < ssize; i++)
			std::cout << "[" << i << "] " << it_vector[i] << " - ";
		std::cout << "\nsize : " << ssize << " , capacity : "  << it_vector.capacity() << "\n";
	}
	TESTEND


	TEST(vector::push_back)
	{
		// title
		TITLE(cplusplus.com reference :)

		ft::vector<int> myvector;

		int	myint[] = {12434, -2432, 12, 5345, 23, 0, -4, 387, 8432, -934723, 1};
		int	size = sizeof(myint) / sizeof(myint[0]);
		for (int i = 0; i < size; i++)
		{
			myvector.push_back(myint[i]);
			std::cout << "[capacity : "
					  << std::setw(2) << myvector.capacity() << "] "
					  << myvector[i] << "\n";
		}
		for (int i = 0; i < size; i++)
			std::cout << "[" << std::setw(2) << i << "] " << myvector[i] << "\n";
		std::cout << "  -> size : " << myvector.size() << " , capacity :"  << myvector.capacity() << "\n";


		// title
		TITLE(big push back :)

		for (int i = 0; i < 72363; i++)
		{
			myvector.push_back(9);
			std::cout << "[" << i
					  << ":" << myvector.capacity() << "] ";
		}
		std::cout << "  -> size : " << myvector.size() << " , capacity :"  << myvector.capacity() << "\n";
	}
	TESTEND

	TEST(vector::pop_back)
	{
		// title
		TITLE(cplusplus.com reference :)

		ft::vector<int> myvector;

		int sum (0);

		myvector.push_back (100);
		myvector.push_back (200);
		myvector.push_back (300);

		while (!myvector.empty())
		{
			sum+=myvector.back();
			myvector.pop_back();
		}

		std::cout << "The elements of myvector add up to " << sum << '\n';


		// title
		TITLE(check state :)

		std::cout << "size : "		<< myvector.size() << '\n';
		std::cout << "capacity : "	<< myvector.capacity() << '\n';
	}
	TESTEND


/*
	TEST(vector::insert)
	{
		// title
		TITLE(cplusplus.com reference :)

		std::vector<int> myvector (3,100);
		std::vector<int>::iterator it;

		it = myvector.begin();
		it = myvector.insert ( it , 200 );

		myvector.insert (it,2,300);

		// "it" no longer valid, get a new one:
		it = myvector.begin();

		std::vector<int> anothervector (2,400);
		myvector.insert (it+2,anothervector.begin(),anothervector.end());

		int myarray [] = { 501,502,503 };
		myvector.insert (myvector.begin(), myarray, myarray+3);

		std::cout << "myvector contains:";
		for (it=myvector.begin(); it<myvector.end(); it++)
			std::cout << ' ' << *it;
		std::cout << '\n';
	}
	TESTEND

	TEST(vector::erase)
	{
		// title
		TITLE(cplusplus.com reference :)

		std::vector<int> myvector;

		// set some values (from 1 to 10)
		for (int i=1; i<=10; i++) myvector.push_back(i);

		// erase the 6th element
		myvector.erase (myvector.begin()+5);

		// erase the first 3 elements:
		myvector.erase (myvector.begin(),myvector.begin()+3);

		std::cout << "myvector contains:";
		for (unsigned i=0; i<myvector.size(); ++i)
			std::cout << ' ' << myvector[i];
		std::cout << '\n';
	}
	TESTEND

	TEST(vector::swap)
	{
		// title
		TITLE(cplusplus.com reference :)

		std::vector<int> foo (3,100);   // three ints with a value of 100
		std::vector<int> bar (5,200);   // five ints with a value of 200

		foo.swap(bar);

		std::cout << "foo contains:";
		for (unsigned i=0; i<foo.size(); i++)
			std::cout << ' ' << foo[i];
		std::cout << '\n';

		std::cout << "bar contains:";
		for (unsigned i=0; i<bar.size(); i++)
			std::cout << ' ' << bar[i];
		std::cout << '\n';
	}
	TESTEND

	TEST(vector::clear)
	{
		// title
		TITLE(cplusplus.com reference :)

		std::vector<int> myvector;
		myvector.push_back (100);
		myvector.push_back (200);
		myvector.push_back (300);

		std::cout << "myvector contains:";
		for (unsigned i=0; i<myvector.size(); i++)
			std::cout << ' ' << myvector[i];
		std::cout << '\n';

		myvector.clear();
		myvector.push_back (1101);
		myvector.push_back (2202);

		std::cout << "myvector contains:";
		for (unsigned i=0; i<myvector.size(); i++)
			std::cout << ' ' << myvector[i];
		std::cout << '\n';
	}
	TESTEND

	TEST(vector::get_allocator)
	{
		// title
		TITLE(cplusplus.com reference :)

		std::vector<int> myvector;
		int * p;
		unsigned int i;

		// allocate an array with space for 5 elements using vector's allocator:
		p = myvector.get_allocator().allocate(5);

		// construct values in-place on the array:
		for (i=0; i<5; i++) myvector.get_allocator().construct(&p[i],i);

		std::cout << "The allocated array contains:";
		for (i=0; i<5; i++) std::cout << ' ' << p[i];
		std::cout << '\n';

		// destroy and deallocate:
		for (i=0; i<5; i++) myvector.get_allocator().destroy(&p[i]);
		myvector.get_allocator().deallocate(p,5);
	}
	TESTEND
*/


	// execute tests and print them :

	int size = test_list.size();
	for(int i = 0; i < size; i++)
	{	
		std::cout
			<< "\n" B_YELLOW "[" << i + 1 << "/" << size << "] "
			<< test_list[i]->title << " :" RESET "\n";
		test_list[i]->func();
	}

	return 0;
}