AuroraRuntime/Include/Aurora/Time/Time.hpp

/***
    Copyright (C) 2021 J Reece Wilson (a/k/a "Reece"). All rights reserved.

    File: Time.hpp
    Date: 2021-6-9
    Author: Reece
***/
#pragma once

namespace Aurora::Time
{
    static auline AuString TimeLocaleGetDayChar()
    {
        return "d"; //for.now
    }

    static auline AuString TimeLocaleS()
    {
        return "s";
    }

    static auline AuString TimeLocaleGetMSChar()
    {
        return "ms"; //for.now
    }

    static AuString &_TextPrepadZeroIfOne(AuString &in)
    {
        if (in.size() == 1) in.insert(in.begin(), '0');
        return in;
    }

    static AuString _TextPrepadZeroIfOne(const AuString &in)
    {
        AuString ret = in;
        if (ret.size() == 1) ret.insert(ret.begin(), '0');
        return ret;
    }

    static AuString _TextPrepadZeroMS(const AuString &in)
    {
        AuString ret = in;
        if (ret.size() == 1) ret.insert(0, "000", 3);
        if (ret.size() == 2) ret.insert(0, "000", 2);
        if (ret.size() == 3) ret.insert(0, "000", 1);
        while (ret.size() > 1 && ret[ret.size() - 1] == '0')
            ret.pop_back();
        return ret;
    }
    static AuString _TextPrepadZeroNS(const AuString &in)
    {
        AuString ret = in;
        if (ret.size() == 1) ret.insert(0, "000000", 6);
        if (ret.size() == 2) ret.insert(0, "000000", 5);
        if (ret.size() == 3) ret.insert(0, "000000", 4);
        if (ret.size() == 4) ret.insert(0, "000000", 3);
        if (ret.size() == 5) ret.insert(0, "000000", 2);
        if (ret.size() == 6) ret.insert(0, "000000", 1);
        while (ret.size() > 1 && ret[ret.size() - 1] == '0')
            ret.pop_back();
        return ret;
    }

    static auline AuString ConvertMSToTimescale(AuUInt32 ms)
    {
        const auto msDiv1000 = ms / 1000;           // seconds
        const auto msDiv1000Mod60 = msDiv1000 % 60; // remaining seconds relative to next whole minute
        const auto msDiv1000Div60 = msDiv1000 / 60; // total minutes
        
        if (ms < 1000)
        {
            return AuToString(ms) + TimeLocaleGetMSChar();
        } 
        else if (ms < (1000 * 60))
        {
            auto s     = msDiv1000;
            auto remMs = ms % 1000;
            return _TextPrepadZeroIfOne(AuToString(s)) + "." + _TextPrepadZeroMS(AuToString(remMs)) + TimeLocaleS();
        }
        else if (ms < (1000 * 60 * 60))
        {
            auto m    = msDiv1000Div60;
            auto remS = msDiv1000Mod60;
            return _TextPrepadZeroIfOne(AuToString(m)) + ":" + _TextPrepadZeroIfOne(AuToString(remS));
        }
        else if (ms < (1000 * 60 * 60 * 24))
        {
            auto h = msDiv1000Div60 / 60;
            auto remM = msDiv1000Div60;
            auto remS = msDiv1000Mod60;

            return _TextPrepadZeroIfOne(AuToString(h)) + ":" + _TextPrepadZeroIfOne(AuToString(remM)) + ":" + _TextPrepadZeroIfOne(AuToString(remS));
        }
        else
        {
            auto d = (msDiv1000Div60 / 60 / 24);
            auto h = (msDiv1000Div60 / 60) - (d * 24);
            auto remM = msDiv1000Div60;
            auto remS = msDiv1000Mod60;
            return AuToString(d) + TimeLocaleGetDayChar() + " " + _TextPrepadZeroIfOne(AuToString(h)) + ":" + _TextPrepadZeroIfOne(AuToString(remM)) + ":" + _TextPrepadZeroIfOne(AuToString(remS));
        }
    }

    static auline AuString ConvertNSToTimescale(AuUInt64 ns)
    {
        if (ns < AuUInt64(1000000000))
        {
            const auto ms = ns / 1000000;
            const auto remNs = ns % 1000000;
            return _TextPrepadZeroMS(AuToString(ms)) + "." + _TextPrepadZeroNS(AuToString(remNs)) + TimeLocaleGetMSChar();
        }
        else
        {
            return ConvertMSToTimescale(ns / AuUInt64(1000000000));
        }
    }

}

#include "Clock.hpp"
#include "Timer.hpp"
#include "TimerHighRes.hpp"
#include "DebugBenchmark.hpp"