#include <iostream>
#include <vector>
#include <chrono>
#include <memory>
#include <string>
#include <sstream>
#include <algorithm>

#include <pugixml.hpp>

using namespace std;
using namespace chrono;
using namespace pugi;

struct Date {
    int D, M, Y;
    int h, m, s;
};

void ParseDate(const char *sdate, Date &date) {
    stringstream tmp(sdate);
    tmp >> date.D;
    tmp.get();
    tmp >> date.M;
    tmp.get();
    tmp >> date.Y;
    tmp.get();
    tmp >> date.h;
    tmp.get();
    tmp >> date.m;
    tmp.get();
    tmp >> date.s;
}

bool Compare(const Date &d1, const Date &d2) {
    if (d1.Y < d2.Y)
        return true;
    if (d1.Y > d2.Y)
        return false;
    if (d1.M < d2.M)
        return true;
    if (d1.M > d2.M)
        return false;
    if (d1.D < d2.D)
        return true;
    if (d1.D > d2.D)
        return false;
    if (d1.h < d2.h)
        return true;
    if (d1.h > d2.h)
        return false;
    if (d1.m < d2.m)
        return true;
    if (d1.m > d2.m)
        return false;
    return d1.s <= d2.s;
}

int main() {
    xml_document doc;
    auto result = doc.load_file("RequestsDB.xml");
    if (!result) {
        cout << "Cannot load xml\n";
        return 1;
    }
    vector<pair<Date, xpath_node>> reqs;
    {
        auto tmpReqs = doc.child("DBModel").select_nodes("Requests");
        reqs.reserve(tmpReqs.size());

        auto start = system_clock::now();

        for (auto &req : tmpReqs) {
            auto sdate = req.node().child("Creation_Date").text().as_string();
            Date date;
            ParseDate(sdate, date);
            reqs.emplace_back(pair{date, req});
        }

        auto end = system_clock::now();
        auto duration = duration_cast<milliseconds>(end - start).count();
        auto secs = duration / 1000;
        auto millis = duration % 1000;
        cout << "Reqs count: " << reqs.size() << endl;
        cout << "Fill reqs takes " << secs << "s" << millis << "ms" << endl;
    }
    {
        auto start = system_clock::now();

        sort(reqs.begin(), reqs.end(), [](auto &r1, auto &r2) {
            return Compare(r1.first, r2.first);
        });

        auto end = system_clock::now();
        auto duration = duration_cast<milliseconds>(end - start).count();
        auto secs = duration / 1000;
        auto millis = duration % 1000;
        cout << "Sort reqs takes " << secs << "s" << millis << "ms" << endl;
    }

    {
        auto start = system_clock::now();

        xml_document newDoc;
        //<DBModel xmlns="http://tempuri.org/DBModel.xsd">
        auto parentNode = newDoc.append_child("DBModel");
        auto attribute = parentNode.append_attribute("xmlns");
        attribute.set_value("http://tempuri.org/DBModel.xsd");
        size_t position{1};
        for (auto &req : reqs) {
            auto newNode = parentNode.append_copy(req.second.node());
            newNode.child("Id").text() = to_string(position++).c_str();
        }
        newDoc.save_file("RequestsDB_new.xml");

        auto end = system_clock::now();
        auto duration = duration_cast<milliseconds>(end - start).count();
        auto secs = duration / 1000;
        auto millis = duration % 1000;
        cout << "Create doc takes " << secs << "s" << millis << "ms" << endl;
    }

    vector<size_t> ids;
    ids.reserve(reqs.size());
    for (auto &req : reqs)
        ids.emplace_back(req.second.node().child("Id").text().as_int());
}