datetime.hpp

/*
 * Copyright (c) 2024 Abdullatif Kalla.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE.txt file in the root directory of this source tree.
 */
 
#ifndef XCLOX_DATE_TIME_HPP
#define XCLOX_DATE_TIME_HPP
 
#include "date.hpp"
#include "time.hpp"
 
#include <cmath>
 
namespace xclox {
 
class DateTime {
    using Duration = std::chrono::nanoseconds;
 
public:
    using Nanoseconds = Time::Nanoseconds; 
    using Microseconds = Time::Microseconds; 
    using Milliseconds = Time::Milliseconds; 
    using Seconds = Time::Seconds; 
    using Minutes = Time::Minutes; 
    using Hours = Time::Hours; 
    using Days = Date::Days; 
    using Weeks = Date::Weeks; 
 
 
    using Weekday = Date::Weekday; 
    using Month = Date::Month; 
 
 
    DateTime() = default;
 
    DateTime(const DateTime& other) = default;
 
    DateTime(DateTime&& other) = default;
 
    explicit DateTime(const Duration& duration)
    {
        const auto& subDay = duration % Days(1);
        const auto& floatingDay = Days(duration.count() < 0 && subDay.count() != 0 ? 1 : 0);
        m_date = Date(std::chrono::duration_cast<Days>(duration - floatingDay));
        m_time = Time(subDay + floatingDay);
    }
 
    explicit DateTime(const std::chrono::system_clock::time_point& timePoint)
        : DateTime(timePoint.time_since_epoch())
    {
    }
 
    explicit DateTime(const Date& date)
        : m_date(date)
        , m_time(Nanoseconds::zero())
    {
    }
 
    explicit DateTime(const Date& date, const Time& time)
        : m_date(date)
        , m_time(time)
    {
    }
 
    ~DateTime() = default;
 
 
    DateTime& operator=(const DateTime& other) = default;
 
    DateTime& operator=(DateTime&& other) = default;
 
 
    bool operator<(const DateTime& other) const
    {
        return (this->m_date < other.m_date) || (this->m_date == other.m_date && this->m_time < other.m_time);
    }
 
    bool operator<=(const DateTime& other) const
    {
        return (this->m_date <= other.m_date) || (this->m_date == other.m_date && this->m_time <= other.m_time);
    }
 
    bool operator>(const DateTime& other) const
    {
        return (this->m_date > other.m_date) || (this->m_date == other.m_date && this->m_time > other.m_time);
    }
 
    bool operator>=(const DateTime& other) const
    {
        return (this->m_date >= other.m_date) || (this->m_date == other.m_date && this->m_time >= other.m_time);
    }
 
    bool operator==(const DateTime& other) const
    {
        return this->m_date == other.m_date && this->m_time == other.m_time;
    }
 
    bool operator!=(const DateTime& other) const
    {
        return this->m_date != other.m_date || this->m_time != other.m_time;
    }
 
 
    Nanoseconds operator-(const DateTime& other) const
    {
        return this->toStdDurationSinceEpoch() - other.toStdDurationSinceEpoch();
    }
 
    DateTime operator-(const Duration& duration) const
    {
        return subtractDuration(duration);
    }
 
    DateTime operator+(const Duration& duration) const
    {
        return addDuration(duration);
    }
 
    bool isValid() const
    {
        return m_date.isValid() && m_time.isValid();
    }
 
    Date date() const
    {
        return m_date;
    }
 
    Time time() const
    {
        return m_time;
    }
 
    long nanosecond() const
    {
        return m_time.nanosecond();
    }
 
    long microsecond() const
    {
        return m_time.microsecond();
    }
 
    int millisecond() const
    {
        return m_time.millisecond();
    }
 
    int second() const
    {
        return m_time.second();
    }
 
    int minute() const
    {
        return m_time.minute();
    }
 
    int hour() const
    {
        return m_time.hour();
    }
 
    int day() const
    {
        return m_date.day();
    }
 
    int month() const
    {
        return m_date.month();
    }
 
    int year() const
    {
        return m_date.year();
    }
 
    void getYearMonthDay(int* year, int* month, int* day) const
    {
        return m_date.getYearMonthDay(year, month, day);
    }
 
    int dayOfWeek() const
    {
        return m_date.dayOfWeek();
    }
 
    int dayOfYear() const
    {
        return m_date.dayOfYear();
    }
 
    int daysInMonth() const
    {
        return m_date.daysInMonth();
    }
 
    int daysInYear() const
    {
        return m_date.daysInYear();
    }
 
    bool isLeapYear() const
    {
        return m_date.isLeapYear();
    }
 
    int weekOfYear(int* weekYear = nullptr) const
    {
        return m_date.weekOfYear(weekYear);
    }
 
    std::string dayOfWeekName(bool shortName = false) const
    {
        return m_date.dayOfWeekName(shortName);
    }
 
    std::string monthName(bool shortName = false) const
    {
        return m_date.monthName(shortName);
    }
 
 
    DateTime addNanoseconds(int nanoseconds) const
    {
        return addDuration(Nanoseconds(nanoseconds));
    }
 
    DateTime subtractNanoseconds(int nanoseconds) const
    {
        return subtractDuration(Nanoseconds(nanoseconds));
    }
 
    DateTime addMicroseconds(int microseconds) const
    {
        return addDuration(Microseconds(microseconds));
    }
 
    DateTime subtractMicroseconds(int microseconds) const
    {
        return subtractDuration(Microseconds(microseconds));
    }
 
    DateTime addMilliseconds(int milliseconds) const
    {
        return addDuration(Milliseconds(milliseconds));
    }
 
    DateTime subtractMilliseconds(int milliseconds) const
    {
        return subtractDuration(Milliseconds(milliseconds));
    }
 
    DateTime addSeconds(int seconds) const
    {
        return addDuration(Seconds(seconds));
    }
 
    DateTime subtractSeconds(int seconds) const
    {
        return subtractDuration(Seconds(seconds));
    }
 
    DateTime addMinutes(int minutes) const
    {
        return addDuration(Minutes(minutes));
    }
 
    DateTime subtractMinutes(int minutes) const
    {
        return subtractDuration(Minutes(minutes));
    }
 
    DateTime addHours(int hours) const
    {
        return addDuration(Hours(hours));
    }
 
    DateTime subtractHours(int hours) const
    {
        return subtractDuration(Hours(hours));
    }
 
    DateTime addDays(int days) const
    {
        return DateTime(m_date.addDays(days), m_time);
    }
 
    DateTime subtractDays(int days) const
    {
        return DateTime(m_date.subtractDays(days), m_time);
    }
 
    DateTime addMonths(int months) const
    {
        return DateTime(m_date.subtractMonths(months), m_time);
    }
 
    DateTime subtractMonths(int months) const
    {
        return DateTime(m_date.subtractMonths(months), m_time);
    }
 
    DateTime addYears(int years) const
    {
        return DateTime(m_date.addYears(years), m_time);
    }
 
    DateTime subtractYears(int years) const
    {
        return DateTime(m_date.subtractYears(years), m_time);
    }
 
    DateTime addDuration(const Duration& duration) const
    {
        if (duration.count() < 0)
            return subtractDuration(-duration);
 
        const Duration totalDuration = Nanoseconds(m_time.toNanosecondsSinceMidnight()) + duration;
        return DateTime(m_date.addDays(std::chrono::duration_cast<Days>(totalDuration).count()), Time(totalDuration % Days(1)));
    }
 
    DateTime subtractDuration(const Duration& duration) const
    {
        if (duration.count() < 0)
            return addDuration(-duration);
 
        return DateTime(m_date.subtractDays(std::abs(std::chrono::duration_cast<Days>(Nanoseconds(m_time.toNanosecondsSinceMidnight()) - duration - Days(1)).count())), Time((Days(1) + Nanoseconds(m_time.toNanosecondsSinceMidnight()) - (duration % Days(1))) % Days(1)));
    }
 
 
    long long toNanosecondsSinceEpoch() const
    {
        return (std::chrono::duration_cast<Nanoseconds>(m_date.toStdDurationSinceEpoch() + m_time.toStdDurationSinceMidnight())).count();
    }
 
    long long toMicrosecondsSinceEpoch() const
    {
        return (std::chrono::duration_cast<Microseconds>(m_date.toStdDurationSinceEpoch() + m_time.toStdDurationSinceMidnight())).count();
    }
 
    long long toMillisecondsSinceEpoch() const
    {
        return (std::chrono::duration_cast<Milliseconds>(m_date.toStdDurationSinceEpoch() + m_time.toStdDurationSinceMidnight())).count();
    }
 
    long long toSecondsSinceEpoch() const
    {
        return (std::chrono::duration_cast<Seconds>(m_date.toStdDurationSinceEpoch() + m_time.toStdDurationSinceMidnight())).count();
    }
 
    long toMinutesSinceEpoch() const
    {
        return (std::chrono::duration_cast<Minutes>(m_date.toStdDurationSinceEpoch() + m_time.toStdDurationSinceMidnight())).count();
    }
 
    long toHoursSinceEpoch() const
    {
        return (std::chrono::duration_cast<Hours>(m_date.toStdDurationSinceEpoch() + m_time.toStdDurationSinceMidnight())).count();
    }
 
    long toDaysSinceEpoch() const
    {
        return m_date.toDaysSinceEpoch();
    }
 
    Microseconds toStdDurationSinceEpoch() const
    {
        return std::chrono::duration_cast<Microseconds>(m_date.toStdDurationSinceEpoch() + m_time.toStdDurationSinceMidnight());
    }
 
    std::chrono::system_clock::time_point toStdTimePoint() const
    {
        return std::chrono::system_clock::time_point(toStdDurationSinceEpoch());
    }
 
    std::tm toBrokenStdTime() const
    {
        int y, m, d;
        getYearMonthDay(&y, &m, &d);
        std::tm cTime = { 0 };
        cTime.tm_year = y - 1970;
        cTime.tm_year = m;
        cTime.tm_year = d;
        cTime.tm_hour = hour();
        cTime.tm_min = minute();
        cTime.tm_sec = second();
 
        return cTime;
    }
 
    std::time_t toScalarStdTime() const
    {
        return std::time_t(toSecondsSinceEpoch());
    }
 
    double toJulianDay() const
    {
        return m_date.toDaysSinceEpoch() + 2440587.5 + static_cast<double>(m_time.toNanosecondsSinceMidnight()) / static_cast<double>(Nanoseconds(Days(1)).count());
    }
 
    std::string toString(const std::string& format = "yyyy-MM-dd hh:mm:ss") const
    {
        if (!isValid() || format.empty())
            return std::string();
        std::stringstream output;
        for (size_t pos = 0; pos < format.size(); ++pos) {
            const auto count = internal::countIdenticalCharsFrom(pos, format);
            output << (internal::isPattern(format.at(pos), count) ? stringify(format.at(pos), count) : format.substr(pos, count));
            pos += count - 1;
        }
        return output.str();
    }
 
 
    static DateTime current()
    {
        return DateTime(std::chrono::system_clock::now());
    }
 
    static DateTime epoch()
    {
        return DateTime(Date::epoch(), Time::midnight());
    }
 
    static DateTime fromString(const std::string& datetime, const std::string& format = "yyyy-MM-dd hh:mm:ss")
    {
        int sign = 1;
        int y = 0;
        int M = 1;
        int d = 1;
        int h = 0;
        int m = 0;
        int s = 0;
        int f = 0;
        size_t dtPos = 0;
        for (size_t fmtPos = 0; fmtPos < format.size(); ++fmtPos) {
            const auto count = internal::countIdenticalCharsFrom(fmtPos, format);
            if (internal::isPattern(format[fmtPos])) {
                if (!internal::isPattern(format[fmtPos], count)) {
                    return DateTime();
                }
            }
            if (format[fmtPos] == 'y') {
                y = parse(format[fmtPos], count, datetime, dtPos);
            } else if (format[fmtPos] == '#' || format[fmtPos] == 'E') {
                sign = parse(format[fmtPos], count, datetime, dtPos);
            } else if (format[fmtPos] == 'M') {
                M = parse(format[fmtPos], count, datetime, dtPos);
            } else if (format[fmtPos] == 'd') {
                if (count == 3) {
                    parse(format[fmtPos], count, datetime, dtPos);
                } else {
                    d = parse(format[fmtPos], count, datetime, dtPos);
                }
            } else if (format[fmtPos] == 'h' || format[fmtPos] == 'H') {
                h = parse(format[fmtPos], count, datetime, dtPos);
            } else if (format[fmtPos] == 'a' || format[fmtPos] == 'A') {
                int clock = parse(format[fmtPos], count, datetime, dtPos);
                h += clock == -12 && h >= 12 || clock == 12 && h < 12 ? clock : 0;
            } else if (format[fmtPos] == 'm') {
                m = parse(format[fmtPos], count, datetime, dtPos);
            } else if (format[fmtPos] == 's') {
                s = parse(format[fmtPos], count, datetime, dtPos);
            } else if (format[fmtPos] == 'f') {
                f = parse(format[fmtPos], count, datetime, dtPos) * std::pow(10, 9 - count);
            } else {
                dtPos += count;
            }
            if (dtPos == std::string::npos) {
                return DateTime();
            }
            fmtPos += count - 1;
        }
        return DateTime(Date(sign * y, M, d), Time(h, m, s, Nanoseconds(f)));
    }
 
    static DateTime fromJulianDay(double julianDay)
    {
        const long integer = static_cast<long>(julianDay);
        const double fraction = julianDay - integer;
        const long millisecondCount = static_cast<long>(static_cast<double>(Milliseconds(Days(1)).count()) * fraction);
        return DateTime(Date(Days(integer - 2440587))).subtractHours(12).addDuration(Milliseconds(millisecondCount));
    }
 
    static long long nanosecondsBetween(const DateTime& from, const DateTime& to)
    {
        return std::abs(std::chrono::duration_cast<Nanoseconds>((from.m_date.toStdDurationSinceEpoch() + from.m_time.toStdDurationSinceMidnight()) - (to.m_date.toStdDurationSinceEpoch() + to.m_time.toStdDurationSinceMidnight())).count());
    }
 
    static long long microsecondsBetween(const DateTime& from, const DateTime& to)
    {
        return std::abs(std::chrono::duration_cast<Microseconds>(from.toStdDurationSinceEpoch() - to.toStdDurationSinceEpoch()).count());
    }
 
    static long long millisecondsBetween(const DateTime& from, const DateTime& to)
    {
        return std::abs(std::chrono::duration_cast<Milliseconds>(from.toStdDurationSinceEpoch() - to.toStdDurationSinceEpoch()).count());
    }
 
    static long long secondsBetween(const DateTime& from, const DateTime& to)
    {
        return std::abs(std::chrono::duration_cast<Seconds>(from.toStdDurationSinceEpoch() - to.toStdDurationSinceEpoch()).count());
    }
 
    static long minutesBetween(const DateTime& from, const DateTime& to)
    {
        return std::abs(std::chrono::duration_cast<Minutes>(from.toStdDurationSinceEpoch() - to.toStdDurationSinceEpoch()).count());
    }
 
    static long hoursBetween(const DateTime& from, const DateTime& to)
    {
        return std::abs(std::chrono::duration_cast<Hours>(from.toStdDurationSinceEpoch() - to.toStdDurationSinceEpoch()).count());
    }
 
    static long daysBetween(const DateTime& from, const DateTime& to)
    {
        return std::abs(std::chrono::duration_cast<Days>(from.toStdDurationSinceEpoch() - to.toStdDurationSinceEpoch()).count());
    }
 
    static long weeksBetween(const DateTime& from, const DateTime& to)
    {
        return std::abs(std::chrono::duration_cast<Weeks>(from.toStdDurationSinceEpoch() - to.toStdDurationSinceEpoch()).count());
    }
 
 
private:
    std::string stringify(char flag, size_t count) const
    {
        std::stringstream output;
        output << std::setfill('0') << std::setw(count);
        if (flag == '#') {
            output << (year() < 0 ? "-" : "+");
        } else if (flag == 'E') {
            output << (year() < 0 ? "BCE" : "CE");
        } else if (flag == 'y') {
            const int y = std::abs(year());
            if (count == 1) {
                output << y;
            } else if (count == 2) {
                output << y - (y / 100 * 100);
            } else if (count == 4) {
                output << y - (y / 10000 * 10000);
            }
        } else if (flag == 'M') {
            if (count == 1 || count == 2) {
                output << month();
            } else if (count == 3) {
                output << internal::getShortMonthName(month());
            } else if (count == 4) {
                output << internal::getLongMonthName(month());
            }
        } else if (flag == 'd') {
            if (count == 1 || count == 2) {
                output << day();
            } else if (count == 3) {
                output << internal::getShortWeekdayName(dayOfWeek());
            } else if (count == 4) {
                output << internal::getLongWeekdayName(dayOfWeek());
            }
        } else if (flag == 'h') {
            output << hour();
        } else if (flag == 'H') {
            int h = hour();
            output << (h == 0 ? 12 : h > 12 ? h - 12
                                            : h);
        } else if (flag == 'm') {
            output << minute();
        } else if (flag == 's') {
            output << second();
        } else if (flag == 'f') {
            output << nanosecond() / static_cast<long>(std::pow(10, 9 - count));
        } else if (flag == 'a') {
            output << (hour() < 12 ? "am" : "pm");
        } else if (flag == 'A') {
            output << (hour() < 12 ? "AM" : "PM");
        }
        return output.str();
    }
 
    static int parse(char flag, size_t count, std::string input, size_t& pos)
    {
        if (flag == 'y' || (flag == 'M' || flag == 'd' || flag == 'h' || flag == 'H' || flag == 'm' || flag == 's') && count <= 2 || flag == 'f') {
            if (pos < input.size() && std::isdigit(input[pos])) {
                return internal::readIntAndAdvancePos(input, pos, flag == 'f' ? count : (flag == 'y' && count == 1 || count == 4 ? 4 : 2));
            }
        } else if (flag == '#') {
            if (pos < input.size() && (input[pos] == '-' || input[pos] == '+')) {
                return (input[pos++] == '-' ? -1 : 1);
            }
        } else if (flag == 'E') {
            if (pos + 2 < input.size() && input.substr(pos, 3) == "BCE") {
                pos += 3;
                return -1;
            } else if (pos + 1 < input.size() && input.substr(pos, 2) == "CE") {
                pos += 2;
                return 1;
            }
        } else if ((flag == 'M' || flag == 'd') && count <= 4 && pos + 2 < input.size()) {
            const auto& line = count == 3 ? input.substr(pos, 3) : input.substr(pos);
            if (flag == 'M') {
                const auto& monthNameArray = count == 3 ? internal::getShortMonthNameArray() : internal::getLongMonthNameArray();
                size_t index = internal::search(monthNameArray, line);
                if (index < monthNameArray.size()) {
                    pos += monthNameArray[index].size();
                    return index + 1;
                }
            } else {
                const auto& weekdayNameArray = count == 3 ? internal::getShortWeekdayNameArray() : internal::getLongWeekdayNameArray();
                size_t index = internal::search(weekdayNameArray, line);
                if (index < weekdayNameArray.size()) {
                    pos += weekdayNameArray[index].size();
                    return index + 1;
                }
            }
        } else if ((flag == 'a' || flag == 'A') && pos + 1 < input.size()) {
            if (flag == 'a' && input.substr(pos, 2) == "am" || input.substr(pos, 2) == "AM") {
                return -12;
            } else if (flag == 'a' && input.substr(pos, 2) == "pm" || input.substr(pos, 2) == "PM") {
                return 12;
            }
        }
        pos = std::string::npos;
        return std::numeric_limits<int>::min();
    }
 
    Date m_date;
    Time m_time;
};
 
std::ostream& operator<<(std::ostream& os, const DateTime& dt)
{
    os << dt.toString("yyyy-MM-ddThh:mm:ss.fff");
 
    return os;
}
 
std::istream& operator>>(std::istream& is, DateTime& dt)
{
    const int DateTimeFormatWidth = 23;
    char result[DateTimeFormatWidth];
    is.read(result, DateTimeFormatWidth);
    dt = DateTime::fromString(std::string(result, DateTimeFormatWidth), "yyyy-MM-ddThh:mm:ss.fff");
 
    return is;
}
 
 
}
 
#endif // XCLOX_DATE_TIME_HPP