#include <iostream>
#include <string>
#include <memory>
#include <vector>
#include <random>
#include <ctime>
#include <chrono>
#include <cassert>
 
using namespace std;
using namespace std::chrono;
 
class TestData
{
public:
	TestData()
		: int_value(0), str_value("")
	{ }
	TestData(int intval, string strval)
		: int_value(intval), str_value(strval)
	{ }
	TestData(TestData&& src)
		: int_value(std::move(src.int_value)),
		str_value(std::move(src.str_value))
	{ }
	TestData& operator = (TestData&& src)
	{
		int_value = std::move(src.int_value);
		str_value = std::move(src.str_value);
		return *this;
	}
	int int_value;
	string str_value;
};
 
using TestDataVec = vector<TestData>;
using TestDataPtrVec = vector<TestData*>;
 
class Timer
{
public:
	Timer() {}
	void Start(string timer_title)
	{
		title = timer_title;
		t1 = system_clock::now();
	}
	void Stop()
	{
		t2 = system_clock::now();
	}
	void StopAndPrint(string timer_title)
	{
		Stop();
		auto ms1 = duration_cast<std::chrono::microseconds>(t2 - t1);
		cout << timer_title << endl;
		cout << "\tDuration, mcs: " << ms1.count() << endl;
	}
	void StopAndPrint()
	{
		StopAndPrint(title);
	}
private:
	system_clock::time_point t1 = system_clock::now();
	system_clock::time_point t2;
	string  title;
};
 
// Globals: tested objects
const int MaxObjectCount = 10000000;
unique_ptr<int[]> random_access(new int[MaxObjectCount]);
TestDataVec* v1 = nullptr;
TestDataPtrVec* v2 = nullptr;
 
void TestFillAllocated()
{
	Timer t1;
	t1.Start("Allocating TestDataVec");
	v1 = new TestDataVec(MaxObjectCount);
	t1.StopAndPrint();
	t1.Start("Allocating TestDataPtrVec");
	v2 = new TestDataPtrVec(MaxObjectCount);
	t1.StopAndPrint();
	t1.Start("Fill with TestData");
	for (int i = 0; i < MaxObjectCount; i++)
	{
		TestData data(i, "Mov " + std::to_string(i));
		(*v1)[i] = std::move(data);
	}
	t1.StopAndPrint();
	t1.Start("Fill with TestData*");
	for (int i = 0; i < MaxObjectCount; i++)
	{
		TestData* data = new TestData(i, "Ptr " + std::to_string(i));
		(*v2)[i] = data;
	}
	t1.StopAndPrint();
}
 
void TestFillPushBack()
{
	Timer t1;
	t1.Start("Allocating TestDataVec");
	v1 = new TestDataVec();
	t1.StopAndPrint();
	t1.Start("Allocating TestDataPtrVec");
	v2 = new TestDataPtrVec();
	t1.StopAndPrint();
	t1.Start("Fill with TestData");
	for (int i = 0; i < MaxObjectCount; i++)
	{
		TestData data(i, "Mov " + std::to_string(i));
		v1->push_back(std::move(data));
	}
	t1.StopAndPrint();
	t1.Start("Fill with TestData*");
	for (int i = 0; i < MaxObjectCount; i++)
	{
		TestData* data = new TestData(i, "Ptr " + std::to_string(i));
		v2->push_back(data);
	}
	t1.StopAndPrint();
}
 
void TestAccess()
{
	Timer t1;
	t1.Start("Sequential access TestData");
	for (int i = 0; i < MaxObjectCount; i++)
	{
		(*v1)[i].int_value++;
		assert((*v1)[i].int_value == i + 1);
	}
	t1.StopAndPrint();
	t1.Start("Sequential access TestData*");
	for (int i = 0; i < MaxObjectCount; i++)
	{
		(*v2)[i]->int_value++;
		assert((*v2)[i]->int_value == i + 1);
	}
	t1.StopAndPrint();
	t1.Start("Random access TestData");
	for (int i = 0; i < MaxObjectCount; i++)
	{
		int index = random_access[i];
		int old_value = (*v1)[index].int_value;
		(*v1)[index].int_value++;
		assert((*v1)[index].int_value == old_value + 1);
	}
	t1.StopAndPrint();
	t1.Start("Random access TestData*");
	for (int i = 0; i < MaxObjectCount; i++)
	{
		int index = random_access[i];
		int old_value = (*v2)[index]->int_value;
		(*v2)[index]->int_value++;
		assert((*v2)[index]->int_value == old_value + 1);
	}
	t1.StopAndPrint();
}
 
void TestReverseList()
{
	Timer t1;
	t1.Start("Reverse list TestData");
	std::reverse(v1->begin(), v1->end());
	t1.StopAndPrint();
	t1.Start("Reverse list TestData*");
	std::reverse(v2->begin(), v2->end());
	t1.StopAndPrint();
}
 
void TestDelete()
{
	Timer t1;
	t1.Start("Deleting TestData");
	delete v1;
	t1.StopAndPrint();
	t1.Start("Deleting TestData*");
	for (TestDataPtrVec::iterator it = v2->begin(); it != v2->end(); it++)
		delete *it;
	delete v2;
	t1.StopAndPrint();
}
 
int main()
{
	// Random access order
	random_device rnd_device;
	default_random_engine rnd_engine(rnd_device());
	uniform_int_distribution<int> uniform_dist(0, MaxObjectCount - 1);
	for (size_t i = 0; i < MaxObjectCount; i++)
		random_access[i] = uniform_dist(rnd_engine);
	// Benchmarks
	cout << "Test preallocated vector data" << endl;
	TestFillAllocated();
	TestAccess();
	TestReverseList();
	TestDelete();
	cout << endl << "Test dynamically added vector data" << endl;
	TestFillPushBack();
	TestAccess();
	TestReverseList();
	TestDelete();
}