#pragma once
#include <vector>
#include <string>


class container_test
{
protected:
    int container_size;
    std::vector<std::string> ops;
public:
    std::vector<std::string> get_results()
    {
        return ops;
    }
    virtual void run()
    {
        insert_beg();
        insert_end();
        sequential_access();
        random_access();
    }
    virtual void insert_beg() = 0;
    virtual void insert_end() = 0;
    virtual void sequential_access() = 0;
    virtual void random_access() = 0;
};

//////////////////////////////////////////////
class deque_test : public container_test
{
private:
    std::deque<int> my_deque;
public:
    explicit deque_test(int size)
    {
        container_size = size;
        ops.push_back("Deque(" + std::to_string(size) + ")");
    }
    virtual void insert_beg() override;
    void insert_mid();
    virtual void run() override;
    virtual void insert_end() override;
    virtual void sequential_access() override;
    virtual void random_access() override;
};
////////////////////////////////////////////
#pragma once
#include "container_test.h"
#include <set>


class set_test : public container_test
{
private:
    std::set<int> my_set;
public:
    explicit set_test(int size)
    {
        container_size = size;
        ops.push_back("Set(" + std::to_string(size) + ")");
    }
    virtual void insert_beg() override;
    virtual void insert_end() override;
    virtual void sequential_access() override;
    virtual void random_access() override;
};
/////////////////////////////////////////////////////////////
#pragma once
#include "container_test.h"
#include <unordered_map>


class unordered_map_test : public container_test
{
private:
    std::unordered_map<int, int> my_unordered_map;
public:
    explicit unordered_map_test(int size)
    {
        container_size = size;
        ops.push_back("Hashmap(" + std::to_string(size) + ")");
    }
    virtual void insert_beg() override;
    virtual void insert_end() override;
    virtual void sequential_access() override;
    virtual void random_access() override;
};
///////////////////////////////////////////////////////////
#pragma once
#include <vector>
#include <string>
#include <iostream>

class Statistics
{
private:
    std::vector<std::string> results;
public:
    Statistics(){}

    void add_result(std::vector<std::string>& res)
    {
        for (auto str : res)
            results.push_back(str + "\n");
        results.push_back("\n");
    }
    void print_results()
    {
        for (auto str : results)
            std::cout << str;
    }
};
////////////////////////////////////////////////////////////
#include "deque_test.h"
#include <chrono>
#include <sstream>
#include <random>
#include <iostream>

void deque_test::insert_beg()
{
    std::chrono::time_point<std::chrono::system_clock> beg;
    std::chrono::time_point<std::chrono::system_clock> end;
    std::chrono::duration<double> dur;
    std::chrono::nanoseconds dts;

    beg = std::chrono::system_clock::now();
    for (int i = 0; i < container_size; i++)
    {
        my_deque.push_front(i);
    }
    end = std::chrono::system_clock::now();
    dur = end - beg;
    dts = std::chrono::duration_cast<std::chrono::nanoseconds>(dur);
    std::stringstream stream;
    stream << "push front " << dts.count() / container_size << " ns";
    ops.push_back(stream.str());
    my_deque.clear();
}

void deque_test::insert_mid()
{
    std::chrono::time_point<std::chrono::system_clock> beg;
    std::chrono::time_point<std::chrono::system_clock> end;
    std::chrono::duration<double> dur;
    std::chrono::nanoseconds dts;

    for (int i = 0; i < container_size/2; i++)
    {
        my_deque.push_back(i);
    }

    beg = std::chrono::system_clock::now();
    for (int i = 0; i < container_size / 2; i++)
    {
        int mid = my_deque.size();
        my_deque.insert(my_deque.begin() + mid, i);
    }
    end = std::chrono::system_clock::now();
    dur = end - beg;
    dts = std::chrono::duration_cast<std::chrono::nanoseconds>(dur);
    std::stringstream stream;
    stream << "insert mid " << dts.count() / container_size / 2 << " ns";
    ops.push_back(stream.str());
    my_deque.clear();
}

void deque_test::run()
{
    insert_beg();
    insert_mid();
    insert_end();
    sequential_access();
    random_access();
}


void deque_test::insert_end()
{
    std::chrono::time_point<std::chrono::system_clock> beg;
    std::chrono::time_point<std::chrono::system_clock> end;
    std::chrono::duration<double> dur;
    std::chrono::nanoseconds dts;

    beg = std::chrono::system_clock::now();
    for (int i = 0; i < container_size; i++)
    {
        my_deque.push_back(i);
    }
    end = std::chrono::system_clock::now();
    dur = end - beg;
    dts = std::chrono::duration_cast<std::chrono::nanoseconds>(dur);
    std::stringstream stream;
    stream << "push back " << dts.count() / container_size << " ns";
    ops.push_back(stream.str());
    my_deque.clear();

}

void deque_test::sequential_access()
{
    std::chrono::time_point<std::chrono::high_resolution_clock> beg;
    std::chrono::time_point<std::chrono::high_resolution_clock> end;
    std::chrono::duration<double> dur;
    std::chrono::nanoseconds dts;

    for (int i = 0; i < container_size; i++)
    {
        my_deque.push_front(i);
    }

    beg = std::chrono::high_resolution_clock::now();
    for (auto num : my_deque)
        num++;
    end = std::chrono::high_resolution_clock::now();
    dur =std::chrono::duration_cast<std::chrono::duration<double>>(end - beg);
    //dts = std::chrono::duration_cast<std::chrono::nanoseconds>(dur);
    std::stringstream stream;
    stream << "seq access " << dur.count() / container_size << " sec";
    ops.push_back(stream.str());
    my_deque.clear();

}

void deque_test::random_access()
{
    std::chrono::time_point<std::chrono::system_clock> beg;
    std::chrono::time_point<std::chrono::system_clock> end;
    std::chrono::duration<double> dur;
    std::chrono::nanoseconds dts;

    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(0, container_size-1);

    for (int i = 0; i < container_size; i++)
    {
        my_deque.push_front(i);
    }

    beg = std::chrono::system_clock::now();
    for (int i = 0; i < container_size; i++)
        my_deque[dis(gen)]++;
    end = std::chrono::system_clock::now();
    dur = end - beg;
    dts = std::chrono::duration_cast<std::chrono::nanoseconds>(dur);
    std::stringstream stream;
    stream << "random access " << dts.count() / container_size << " ns";
    ops.push_back(stream.str());
    my_deque.clear();
}
//////////////////////////////////////////
#include "set_test.h"
#include <chrono>
#include <sstream>

void set_test::insert_beg()
{
    std::chrono::time_point<std::chrono::system_clock> beg;
    std::chrono::time_point<std::chrono::system_clock> end;
    std::chrono::duration<double> dur;
    std::chrono::nanoseconds dts;

    beg = std::chrono::system_clock::now();
    for (int i = 0; i < container_size; i++)
        my_set.insert(i);
    end = std::chrono::system_clock::now();
    dur = end - beg;
    dts = std::chrono::duration_cast<std::chrono::nanoseconds>(dur);
    std::stringstream stream;
    stream << "insert " << dts.count() / container_size << " ns";
    ops.push_back(stream.str());
    my_set.clear();
}


void set_test::insert_end()
{
    std::chrono::time_point<std::chrono::system_clock> beg;
    std::chrono::time_point<std::chrono::system_clock> end;
    std::chrono::duration<double> dur;
    std::chrono::nanoseconds dts;

    beg = std::chrono::system_clock::now();
    for (int i = 0; i < container_size; i++)
        my_set.emplace_hint(my_set.end(), i);
    end = std::chrono::system_clock::now();
    dur = end - beg;
    dts = std::chrono::duration_cast<std::chrono::nanoseconds>(dur);
    std::stringstream stream;
    stream << "insert end(hint) " << dts.count() / container_size << " ns";
    ops.push_back(stream.str());
    my_set.clear();
}

void set_test::sequential_access()
{
    std::chrono::time_point<std::chrono::system_clock> beg;
    std::chrono::time_point<std::chrono::system_clock> end;
    std::chrono::duration<double> dur;
    std::chrono::nanoseconds dts;

    for (int i = 0; i < container_size; i++)
        my_set.insert(i);

    beg = std::chrono::system_clock::now();
    for (auto num : my_set)
        num++;
    end = std::chrono::system_clock::now();
    dur = end - beg;
    dts = std::chrono::duration_cast<std::chrono::nanoseconds>(dur);
    std::stringstream stream;
    stream << "seq access " << dts.count() / container_size << " ns";
    ops.push_back(stream.str());
    my_set.clear();
}

void set_test::random_access()
{
    std::chrono::time_point<std::chrono::system_clock> beg;
    std::chrono::time_point<std::chrono::system_clock> end;
    std::chrono::duration<double> dur;
    std::chrono::nanoseconds dts;

    for (int i = 0; i < container_size; i++)
        my_set.insert(i);

    beg = std::chrono::system_clock::now();
    for (int i = 0; i < container_size; i++)
        my_set.find(i);
    end = std::chrono::system_clock::now();
    dur = end - beg;
    dts = std::chrono::duration_cast<std::chrono::nanoseconds>(dur);
    std::stringstream stream;
    stream << "random access " << dts.count() / container_size << " ns";
    ops.push_back(stream.str());
    my_set.clear();
}
///////////////////////////////////////////////////////////////
#include "unordered_map_test.h"
#include <chrono>
#include <sstream>
#include <random>


void unordered_map_test::insert_beg()
{
    std::chrono::time_point<std::chrono::system_clock> beg;
    std::chrono::time_point<std::chrono::system_clock> end;
    std::chrono::duration<double> dur;
    std::chrono::nanoseconds dts;

    beg = std::chrono::system_clock::now();
    for (int i = 0; i < container_size; i++)
        my_unordered_map.insert({ i, i });
    end = std::chrono::system_clock::now();
    dur = end - beg;
    dts = std::chrono::duration_cast<std::chrono::nanoseconds>(dur);
    std::stringstream stream;
    stream << "insert " << dts.count() / container_size << " ns";
    ops.push_back(stream.str());
    my_unordered_map.clear();
}

void unordered_map_test::insert_end()
{
    std::chrono::time_point<std::chrono::system_clock> beg;
    std::chrono::time_point<std::chrono::system_clock> end;
    std::chrono::duration<double> dur;
    std::chrono::nanoseconds dts;

    beg = std::chrono::system_clock::now();
    for (int i = 0; i < container_size; i++)
        my_unordered_map.insert(my_unordered_map.end(), { i, i });
    end = std::chrono::system_clock::now();
    dur = end - beg;
    dts = std::chrono::duration_cast<std::chrono::nanoseconds>(dur);
    std::stringstream stream;
    stream << "insert end(hint) " << dts.count() / container_size << " ns";
    ops.push_back(stream.str());
    my_unordered_map.clear();
}

void unordered_map_test::sequential_access()
{
    std::chrono::time_point<std::chrono::high_resolution_clock> beg;
    std::chrono::time_point<std::chrono::high_resolution_clock> end;
    std::chrono::duration<double> dur;
    std::chrono::nanoseconds dts;

    for (int i = 0; i < container_size; i++)
        my_unordered_map.insert({ i, i });

    beg = std::chrono::high_resolution_clock::now();
    for (auto pair : my_unordered_map)
        pair.second++;
    end = std::chrono::high_resolution_clock::now();
    dur = end - beg;
    //dts = std::chrono::duration_cast<std::chrono::nanoseconds>(dur);
    std::stringstream stream;
    stream << "seq access " << dur.count() / container_size << " sec";
    ops.push_back(stream.str());
    my_unordered_map.clear();
}

void unordered_map_test::random_access()
{
    std::chrono::time_point<std::chrono::high_resolution_clock> beg;
    std::chrono::time_point<std::chrono::high_resolution_clock> end;
    std::chrono::duration<double> dur;
    std::chrono::nanoseconds dts;

    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(0, container_size - 1);

    for (int i = 0; i < container_size; i++)
        my_unordered_map.insert({ i, i });

    beg = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < container_size; i++)
        my_unordered_map.at(dis(gen));
    end = std::chrono::high_resolution_clock::now();
    dur = end - beg;
    dts = std::chrono::duration_cast<std::chrono::nanoseconds>(dur);
    std::stringstream stream;
    stream << "random access " << dts.count() / container_size << " ns";
    ops.push_back(stream.str());
    my_unordered_map.clear();

}
/////////////////////////