#pragma once
#include <winsock2.h>
#include <stdint.h>
#include <sstream>
namespace Windows
{
    struct CpuFrequency
    {
        static uint64_t getFrequency() { uint64_t f; if (!QueryPerformanceFrequency(reinterpret_cast<LARGE_INTEGER*>(&f)))throw 0; return f; }

        inline static double s_frequency = static_cast<double>(getFrequency());
        inline static double s_invFrequency = 1. / s_frequency;
    };
}

struct TimePoint
{
    friend struct Duration;
private:
    double m_data;
    static TimePoint s_programStartTime;
public:
    TimePoint() :m_data{ 0 } {}
    TimePoint(double value) :m_data{ value } {}
    TimePoint(uint64_t value) :m_data{ value * Windows::CpuFrequency::s_invFrequency } {}
    static TimePoint now() { uint64_t t; if (!QueryPerformanceCounter(reinterpret_cast<LARGE_INTEGER*>(&t)))throw 0; return t; }

    bool operator>(const TimePoint& rhs)const { return m_data > rhs.m_data; }
    bool operator>=(const TimePoint& rhs)const { return m_data >= rhs.m_data; }
    bool operator<(const TimePoint& rhs)const { return m_data < rhs.m_data; }
    bool operator<=(const TimePoint& rhs)const { return m_data <= rhs.m_data; }
    bool operator==(const TimePoint& rhs)const { return m_data == rhs.m_data; }
    bool operator!=(const TimePoint& rhs)const { return m_data != rhs.m_data; }

    const auto& data()const { return m_data; }
    auto& data() { return m_data; }

    static const TimePoint& programStartTime() { return s_programStartTime; }

    template<class Ch, class Tr>
    friend inline decltype(auto) operator<<(std::basic_ostream<Ch, Tr>& os, const TimePoint& timepoint)
    {
        os << (timepoint - s_programStartTime);
        return os;
    }
};
TimePoint TimePoint::s_programStartTime = TimePoint::now();

struct Duration
{
    friend struct TimePoint;
private:
    double m_data;
public:
    explicit constexpr Duration(double value = 0.) :m_data{ value } {}
    const auto& data()const { return m_data; }
    auto& data() { return m_data; }

    bool isPositive()const { return m_data > 0; }

    operator bool()const { return m_data != 0; }

    static Duration sinceProgramStarts();

    double toMilliseconds()const { return m_data * 1000.; }
    double toSeconds()const { return m_data; }
    double toMinutes()const { return m_data * 0.01666666666666666666666666666; }
    double toHours()const { return m_data * 0.0002777777777777777777777777; }
    double toDays()const { return m_data * 1.157407407407407e-5; }

    template<class T>static constexpr Duration milliseconds(T value) { return Duration{ static_cast<double>(value * 0.001) }; }
    template<class T>static constexpr Duration seconds(T value) { return Duration{ static_cast<double>(value) }; }
    template<class T>static constexpr Duration minutes(T value) { return Duration{ static_cast<double>(value * 60) }; }
    template<class T>static constexpr Duration hours(T value) { return Duration{ static_cast<double>(value * 3600) }; }
    template<class T>static constexpr Duration days(T value) { return Duration{ static_cast<double>(value * 86400) }; }

    bool operator>(const Duration& rhs)const { return m_data > rhs.m_data; }
    bool operator>=(const Duration& rhs)const { return m_data >= rhs.m_data; }
    bool operator<(const Duration& rhs)const { return m_data < rhs.m_data; }
    bool operator<=(const Duration& rhs)const { return m_data <= rhs.m_data; }
    bool operator==(const Duration& rhs)const { return m_data == rhs.m_data; }
    bool operator!=(const Duration& rhs)const { return m_data != rhs.m_data; }

    template<class Ch, class Tr>
    friend inline decltype(auto) operator<<(std::basic_ostream<Ch, Tr>& os, const Duration& duration)
    {
        os << duration.toMilliseconds() << "ms";
        return os;
    }
};

Duration& operator+=(Duration& lhs, const Duration& rhs) { lhs.data() += rhs.data(); return lhs; }
Duration operator+(const Duration& lhs, const Duration& rhs) { auto copy{ lhs }; return copy += rhs; }

Duration& operator-=(Duration& lhs, const Duration& rhs) { lhs.data() -= rhs.data(); return lhs; }
Duration operator-(const Duration& lhs, const Duration& rhs) { auto copy{ lhs }; return copy -= rhs; }

template<class T>Duration& operator*=(Duration& lhs, T rhs) { lhs.data() *= rhs; return lhs; }
template<class T>Duration operator*(const Duration& lhs, T rhs) { Duration copy{ lhs }; return copy *= rhs; }
template<class T>Duration operator*(T lhs, const Duration& rhs) { return rhs * lhs; }

template<class T>Duration& operator/=(Duration& lhs, T rhs) { lhs.data() /= rhs; return lhs; }
template<class T>Duration operator/(const Duration& lhs, T rhs) { auto copy{ lhs }; return copy /= rhs; }

double operator/(const Duration& lhs, const Duration& rhs) { return lhs.data() / rhs.data(); }

TimePoint& operator+=(TimePoint& lhs, const Duration& rhs) { lhs.data() += rhs.data(); return lhs; }
TimePoint operator+(const TimePoint& lhs, const Duration& rhs) { auto copy{ lhs }; return copy += rhs; }

TimePoint& operator-=(TimePoint& lhs, const Duration& rhs) { lhs.data() -= rhs.data(); return lhs; }
TimePoint operator-(const TimePoint& lhs, const Duration& rhs) { auto copy{ lhs }; return copy -= rhs; }

TimePoint operator+(const Duration& lhs, const TimePoint& rhs) { return rhs + lhs; }

Duration operator-(const TimePoint& lhs, const TimePoint& rhs) { return Duration{ lhs.data() - rhs.data() }; }

Duration Duration::sinceProgramStarts() { return TimePoint::now() - TimePoint::programStartTime(); }

struct StopWatch
{
private:
    TimePoint m_startTimePoint;
public:
    StopWatch() :m_startTimePoint{ TimePoint::now() } {}

    Duration timeElapsed()const { return TimePoint::now() - m_startTimePoint; }
    void reset() { m_startTimePoint = TimePoint::now(); }
};


constexpr Duration operator ""_s(long double sec) { return Duration::seconds(sec); }

constexpr Duration operator ""_ms(long double ms) { return Duration::milliseconds(ms); }

namespace Windows
{
    inline bool sleep100Ns(LONGLONG ns)
    {
        HANDLE timer;
        if (!(timer = CreateWaitableTimerA(nullptr, TRUE, nullptr)))return false;
        LARGE_INTEGER li;
        li.QuadPart = -ns;
        if (!SetWaitableTimer(timer, &li, 0, nullptr, nullptr, FALSE))
        {
            CloseHandle(timer);
            return false;
        }
        WaitForSingleObject(timer, INFINITE);
        CloseHandle(timer);
        return true;
    }

    inline bool sleep(const Duration& duration) { return sleep100Ns(static_cast<long long>(duration.toMilliseconds() * 10000)); }

    inline bool sleepUntil(const TimePoint& target) { Duration diff{ target - TimePoint::now() }; return (diff.isPositive() ? sleep(diff) : true); }
}