#pragma optimize( "[optimization-list]", {off} )
#include <iomanip>
#include <iostream>
#include <string>
#include <vector>
#include <fstream>
#include <list>
#include <chrono>
#include <iterator>
#include <algorithm>

using namespace std;
int sizes[10] = { 100000, 200000, 300000, 400000, 500000, 600000, 700000, 800000, 900000, 1000000 };

class TimeLogger {
public:
    std::ofstream outstream;

    TimeLogger(const string& PATH) {
        outstream.open(PATH);
        frozen_time = std::chrono::steady_clock::now();
        current_time = std::chrono::steady_clock::now();
    }

    ~TimeLogger() {
        outstream.close();
    }

    void reset() {
        set_ctime(std::chrono::steady_clock::now());
        set_ftime(std::chrono::steady_clock::now());
    }
    std::chrono::steady_clock::time_point get_ftime() {
        frozen_time;
    }
    std::chrono::steady_clock::time_point get_ctime() {
        current_time;
    }
    void set_ftime(std::chrono::steady_clock::time_point time) {
        frozen_time = time;
    }
    void set_ctime(std::chrono::steady_clock::time_point time) {
        current_time = time;
    }
    void log(const string container_type, const int len, const string operation) {
        if (outstream.is_open()) {
            set_ctime(std::chrono::steady_clock::now());
            auto elapsed_ms = std::chrono::duration_cast<std::chrono::milliseconds>(get_ctime() - get_ftime());
            outstream << "container: " << container_type << "; size: " << len
                << "; operation: " << operation << "; " << "time:"
                << elapsed_ms.count() << ";\n";
        }
    }
private:
    std::chrono::steady_clock::time_point frozen_time;
    std::chrono::steady_clock::time_point current_time;
};

std::vector<int> integer_vec_reader(const string& PATH, const int len) {
    std::ifstream instream(PATH);
    vector<int>result;
    if (instream.is_open()) {
        for (int i = 0; i < len; i++) {
            string current;
            getline(instream, current);
            result.push_back(std::stoi(current));
        }
    }
    instream.close();
    return result;
}

std::list<int> integer_list_reader(const string& PATH, const int len) {
    std::ifstream instream(PATH);
    std::list<int>result;
    if (instream.is_open()) {
        for (int i = 0; i < len; i++) {
            string current;
            getline(instream, current);
            result.push_back(std::stoi(current));
        }
    }
    instream.close();
    return result;
}

std::vector<string>string_vec_reader(const string& PATH, const int len) {
    std::ifstream instream(PATH);
    vector<string> result;
    if (instream.is_open()) {
        string current;
        for (int i = 0; i < len; i++) {
            getline(instream, current);
            result.push_back(current);
        }
    }
    instream.close();
    return result;
}

std::list<string>string_list_reader(const string& PATH, const int len) {
    std::ifstream instream(PATH);
    std::list<string> ans;
    if (instream.is_open()) {
        string current;
        for (int i = 0; i < len; i++) {
            getline(instream, current);
            ans.push_back(current);
        }
    }
    instream.close();
    return ans;
}
int main() {
    std::ofstream fout;
    std::ofstream sout;
    fout.open("IntDatabase.txt");
    sout.open("StrDataBase.txt");
    TimeLogger logger("Logs.txt");
    //OPERATION : FIND
    for (auto elem : sizes) {
        logger.reset();
        vector<int>nums = integer_vec_reader("IntDataBase.txt", elem);
        auto it = std::find(nums.begin(), nums.end(), nums[elem-1]);
        logger.log("vector<int>", elem, "std::find");
    }
    logger.outstream << endl;
   for (auto elem : sizes) {
        logger.reset();
        list<int>nums = integer_list_reader("IntDataBase.txt", elem);
        auto it = std::find(nums.begin(), nums.end(), *next(nums.begin(), elem-1));
        logger.log("list<int>", elem, "std::find");
    }
    logger.outstream << endl;
    for (auto elem : sizes) {
        logger.reset();
        vector<string>nums = string_vec_reader("StrDataBase.txt", elem);
        std::find(nums.begin(), nums.end(), nums[elem - 1]);
        logger.log("vector<string>", elem, "std::find");
    }
    logger.outstream << endl;
    for (auto elem : sizes) {
        logger.reset();
        list<string>nums = string_list_reader("StrDataBase.txt", elem);
        auto it = std::find(nums.begin(), nums.end(), *next(nums.begin(), elem - 1));
        logger.log("list<string>", elem, "std::find");
    }
    //OPERATION : SORT
    for (auto elem : sizes) {
        vector<int>nums = integer_vec_reader("IntDataBase.txt", elem);
        logger.reset();
        std::sort(nums.begin(), nums.end());
        logger.log("vector<int>", elem, "std::sort");
    }
    logger.outstream << endl;
    for (auto elem : sizes) {
        logger.reset();
        list<int>nums = integer_list_reader("IntDataBase.txt", elem);
        nums.sort();
        logger.log("list<int>", elem, "std::sort");
    }
    logger.outstream << endl;
    for (auto elem : sizes) {
        logger.reset();
        vector<string>nums = string_vec_reader("StrDataBase.txt", elem);
        std::sort(nums.begin(), nums.end());
        logger.log("vector<string>", elem, "std::sort");
    }
    logger.outstream << endl;
    for (auto elem : sizes) {
        logger.reset();
        list<string>nums = string_list_reader("StrDataBase.txt", elem);
        nums.sort();
        logger.log("list<string>", elem, "std::sort");
    }
    // POP_BACK
    for (auto elem : sizes) {
        logger.reset();
        vector<int>nums = integer_vec_reader("IntDataBase.txt", elem);
        for (int i = 0; i < elem; i++) {
            nums.pop_back();
        }
        logger.log("vector<int>", elem, "pop_back()");
    }
    logger.outstream << endl;
    for (auto elem : sizes) {
        logger.reset();
        list<int>nums = integer_list_reader("IntDataBase.txt", elem);
        for (int i = 0; i < elem; i++) {
            nums.pop_back();
        }
        logger.log("list<int>", elem, "pop_back()");
    }
    logger.outstream << endl;
    for (auto elem : sizes) {
        logger.reset();
        vector<string>nums = string_vec_reader("StrDataBase.txt", elem);
        for (int i = 0; i < elem; i++) {
            nums.pop_back();
        }
        logger.log("vector<string>", elem, "pop_back()");
    }
    logger.outstream << endl;
    for (auto elem : sizes) {
        logger.reset();
        list<string>nums = string_list_reader("StrDataBase.txt", elem);
        for (int i = 0; i < elem; i++) {
            nums.pop_back();
        }
        logger.log("list<string>", elem, "pop_back()");
    }
    // POP_FRONT
    for (auto elem : sizes) {
        logger.reset();
        vector<int>nums = integer_vec_reader("IntDataBase.txt", elem);
        for (int i = 0; i < elem; i++) {
            nums.erase(nums.begin());
        }
        logger.log("vector<int>", elem, "pop_front()");
    }
    logger.outstream << endl;
    for (auto elem : sizes) {
        logger.reset();
        list<int>nums = integer_list_reader("IntDataBase.txt", elem);
        for (int i = 0; i < elem; i++) {
            nums.pop_front();
        }
        logger.log("list<int>", elem, "pop_front()");
    }
    logger.outstream << endl;
    for (auto elem : sizes) {
        logger.reset();
        vector<string>nums = string_vec_reader("StrDataBase.txt", elem);
        for (int i = 0; i < elem; i++) {
            nums.erase(nums.begin());
        }
        logger.log("vector<string>", elem, "pop_front()");
    }
    logger.outstream << endl;
    for (auto elem : sizes) {
        logger.reset();
        list<string>nums = string_list_reader("StrDataBase.txt", elem);
        for (int i = 0; i < elem; i++) {
            nums.pop_front();
        }
        logger.log("list<string>", elem, "pop_front()");
    }
    //PUSH_FRONT
    for (auto elem : sizes) {
        logger.reset();
        vector<int>nums_storage = integer_vec_reader("IntDataBase.txt", elem);
        vector<int>nums;
        for (int i = 0; i < elem; i++) {
            nums.insert(nums.begin(), nums_storage[i]);
        }
        logger.log("vector<int>", elem, "push_front()");
    }
    logger.outstream << endl;
    //PUSH_FRONT IN RESERVE USING CASE
    for (auto elem : sizes) {
        logger.reset();
        vector<int>nums_storage = integer_vec_reader("IntDataBase.txt", elem);
        vector<int>nums;
        nums.reserve(elem);
        for (int i = 0; i < elem; i++) {
            nums.insert(nums.begin(), nums_storage[i]);
        }
        logger.log("vector<int>", elem, "push_front()");
    }
    logger.outstream << endl;
    for (auto elem : sizes) {
        logger.reset();
        list<int>nums_storage = integer_list_reader("IntDataBase.txt", elem);
        list<int>nums;
        for (int i = 0; i < elem; i++) {
            nums.push_front(*next(nums_storage.begin(), i));
        }
        logger.log("list<int>", elem, "push_front()");
    }
    logger.outstream << endl;
    for (auto elem : sizes) {
        logger.reset();
        vector<string>nums_storage = string_vec_reader("StrDataBase.txt", elem);
        vector<string>nums;
        for (int i = 0; i < elem; i++) {
            nums.insert(nums.begin(), nums_storage[i]);
        }
        logger.log("vector<string>", elem, "push_front()");
    }
    logger.outstream << endl;
    for (auto elem : sizes) {
        logger.reset();
        list<string>nums_storage = string_list_reader("StrDataBase.txt", elem);
        list<string>nums;
        for (int i = 0; i < elem; i++) {
            nums.push_front(*next(nums_storage.begin(), i));
        }
        logger.log("list<string>", elem, "push_front()");
    }
    logger.outstream << endl;
    //PUSH_BACK
    for (auto elem : sizes) {
        logger.reset();
        vector<int>nums_storage = integer_vec_reader("IntDataBase.txt", elem);
        vector<int>nums;
        for (int i = 0; i < elem; i++) {
            nums.push_back(nums_storage[i]);
        }
        logger.log("vector<int>", elem, "push_back()");
    }
    logger.outstream << endl;
    //PUSH_BACK IN RESERVE USING CASE
    for (auto elem : sizes) {
        logger.reset();
        vector<int>nums_storage = integer_vec_reader("IntDataBase.txt", elem);
        vector<int>nums;
        nums.reserve(elem);
        for (int i = 0; i < elem; i++) {
            nums.push_back(nums_storage[i]);
        }
        logger.log("vector<int>", elem, "push_back()");
    }
    logger.outstream << endl;
    for (auto elem : sizes) {
        logger.reset();
        list<int>nums_storage = integer_list_reader("IntDataBase.txt", elem);
        list<int>nums;
        for (int i = 0; i < elem; i++) {
            nums.push_back(*next(nums_storage.begin(), i));
        }
        logger.log("list<int>", elem, "push_back()");
    }
    logger.outstream << endl;
    for (auto elem : sizes) {
        logger.reset();
        vector<string>nums_storage = string_vec_reader("StrDataBase.txt", elem);
        vector<string>nums;
        for (int i = 0; i < elem; i++) {
            nums.push_back(nums_storage[i]);
        }
        logger.log("vector<string>", elem, "push_back()");
    }
    logger.outstream << endl;
    for (auto elem : sizes) {
        logger.reset();
        list<string>nums_storage = string_list_reader("StrDataBase.txt", elem);
        list<string>nums;
        for (int i = 0; i < elem; i++) {
            nums.push_back(*next(nums_storage.begin(), i));
        }
        logger.log("list<string>", elem, "push_back()");
    }
    logger.outstream << endl;
    fout.close();
    sout.close();
    return 0;
}