#include <algorithm>
#include <chrono>
#include <iomanip>
#include <iostream>
#include <random>
#include <ratio>
#include <vector>

using namespace std;
using namespace std::chrono;

int main() {
    constexpr int min_year = -32767;
    constexpr int max_year = 32767;
    constexpr int runs     = 5;

    cout << fixed << setprecision(1);

    vector<year_month_day> ymds;
    ymds.reserve((max_year - min_year + 1) * 366);

    for (int y = min_year; y <= max_year; ++y) {
        for (unsigned int m = 1; m <= 12; ++m) {
            for (unsigned int d = 1; d <= 31; ++d) {
                auto ymd = year{y} / month{m} / day{d};
                if (!ymd.ok()) {
                    break;
                }

                ymds.push_back(ymd);
            }
        }
    }

    mt19937 rng(random_device{}());

    const size_t total = ymds.size();
    vector<sys_days> sds(total);

    for (int i = 0; i < runs; ++i) {
        ranges::shuffle(ymds, rng);

        const auto start_t = steady_clock::now();
        ranges::transform(ymds, sds.begin(), [](const auto& ymd) { return sys_days{ymd}; });
        const auto end_t = steady_clock::now();

        unsigned int dummy = 0;
        for (const auto& sd : sds) {
            dummy += sd.time_since_epoch().count();
        }

        cout << "year_month_day => sys_days: " << setw(6) << (duration<double, nano>{end_t - start_t} / total)
             << " (dummy: " << dummy << ")\n";
    }

    for (int i = 0; i < runs; ++i) {
        ranges::shuffle(sds, rng);

        const auto start_t = steady_clock::now();
        ranges::transform(sds, ymds.begin(), [](const auto& sd) { return year_month_day{sd}; });
        const auto end_t = steady_clock::now();

        unsigned int dummy = 0;
        for (const auto& ymd : ymds) {
            dummy += static_cast<int>(ymd.year());
            dummy += static_cast<unsigned int>(ymd.month());
            dummy += static_cast<unsigned int>(ymd.day());
        }

        cout << "sys_days => year_month_day: " << setw(6) << (duration<double, nano>{end_t - start_t} / total)
             << " (dummy: " << dummy << ")\n";
    }

    return 0;
}