#include <iostream>
#include <sstream>
#include <fstream>
#include <string>
#include <vector>
#include <thread>
#include <ctime>
#include <chrono>

using namespace std;
using namespace std::chrono;

typedef char TestDataType;
TestDataType* test_data;
TestDataType* test_data_copy;

void fill_data(const size_t from, const size_t to)
{
  for (size_t i = from; i < to; i++)
    test_data[i] = static_cast<TestDataType>(rand());
}

void copy_data(const size_t from, const size_t to)
{
  for (size_t i = from; i < to; i++)
    test_data_copy[i] = test_data[i];
}

void save_mem_to_file(const string file_name, const size_t from, const size_t to)
{
  ofstream out(file_name, ofstream::trunc);
  out.write(&test_data[from], to - from);
  out.close();
}

int main(int argc, char* argv[])
{
  int thread_count = 1;
  if (argc > 1)
    thread_count = atoi(argv[1]);
  int file_count = 10;
  if (argc > 2)
    file_count = atoi(argv[2]);
  size_t data_length = 255 * 1024 * 1024; // 255 MB by default
  if (argc > 3)
    data_length = atol(argv[3]);
  size_t batch_size = data_length / thread_count;
  cout << "Thread count: " << thread_count << endl
    << "Batch size: " << batch_size << " bytes" << endl
    << "Files count: " << file_count << endl;

  try
  {
    srand(static_cast<unsigned int>(std::time(nullptr)));
    vector<thread> threads;
    // Fill memory (random values)
    cout << "Starting memory fill test" << endl;
    test_data = new TestDataType[data_length];
    system_clock::time_point t11 = system_clock::now();
    for (int i = 0; i < thread_count; i++)
    {
      size_t from = batch_size * i;
      size_t to = from + batch_size - 1;
      cout << "Thread " << i << ": " << from << " - " << to << endl;
      threads.push_back(thread(fill_data, from, to));
    }
    for (thread& th : threads)
      th.join();
    system_clock::time_point t12 = system_clock::now();
    auto ms1 = std::chrono::duration_cast<std::chrono::milliseconds>(t12 - t11);
    cout << "Memory fill finished" << endl;
    cout << "Duration, msec: " << ms1.count() << endl;
    threads.clear();
    // Copy memory
    cout << "Starting memory copy test" << endl;
    test_data_copy = new TestDataType[data_length];
    system_clock::time_point t21 = system_clock::now();
    for (int i = 0; i < thread_count; i++)
    {
      size_t from = batch_size * i;
      size_t to = from + batch_size - 1;
      cout << "Thread " << i << ": " << from << " - " << to << endl;
      threads.push_back(thread(copy_data, from, to));
    }
    for (thread& th : threads)
      th.join();
    system_clock::time_point t22 = system_clock::now();
    auto ms2 = std::chrono::duration_cast<std::chrono::milliseconds>(t22 - t21);
    cout << "Memory copy finished" << endl;
    cout << "Duration, msec: " << ms2.count() << endl;
    threads.clear();
    delete test_data_copy;
    // Save to files
    string file_name_base = "testdump";
    system_clock::time_point t31 = system_clock::now();
    size_t file_size = data_length / file_count;
    int i = 0, j = 0;
    while (i < file_count)
    {
      if (j < thread_count)
      {
        size_t from = file_size * j;
        size_t to = from + file_size - 1;
        stringstream file_name;
        file_name << file_name_base << i << ".dmp";
        cout << "Thread " << i << ", file " << file_name.str() << ": " << from << " - " << to << endl;
        threads.push_back(thread(save_mem_to_file, file_name.str(), from, to));
        i++;
        j++;
      }
      else
      {
        j = 0;
        for (thread& th : threads)
          th.join();
        threads.clear();
      }
    }
    for (thread& th : threads)
      th.join();
    system_clock::time_point t32 = system_clock::now();
    auto ms3 = std::chrono::duration_cast<std::chrono::milliseconds>(t32 - t31);
    cout << "Memory writing finished" << endl;
    cout << "Duration, msec: " << ms3.count() << endl;

    cout << "Test finished" << endl;
    delete test_data;
  }
  catch (std::bad_alloc& e)
  {
    cout << "Insufficient memory. Error: " << e.what() << endl;
  }
  catch (std::exception& e)
  {
    cout << e.what() << endl;
  }
  catch (...)
  {
    cout << "Unexpected exception" << endl;
  }
}