#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 << "Duration, mcsec: " << 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 = 1000000;
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 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();
   TestDelete();
   cout << endl << "Test dynamically added vector data" << endl;
   TestFillPushBack();
   TestAccess();
   TestDelete();
}