date.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_HPP
#define XCLOX_DATE_HPP
 
#include "internal.hpp"
 
namespace xclox {
 
namespace internal {
 
    inline Days ymdToDays(int year, int month, int day)
    {
        // Math from http://howardhinnant.github.io/date_algorithms.html
        auto const y = static_cast<int>(year) - (month <= 2) + (year < 1); // if the year is negative; i.e. before common era, add one year.
        auto const m = static_cast<unsigned>(month);
        auto const d = static_cast<unsigned>(day);
        auto const era = (y >= 0 ? y : y - 399) / 400;
        auto const yoe = static_cast<unsigned>(y - era * 400); // [0, 399]
        auto const doy = (153 * (m > 2 ? m - 3 : m + 9) + 2) / 5 + d - 1; // [0, 365]
        auto const doe = yoe * 365 + yoe / 4 - yoe / 100 + doy; // [0, 146096]
 
        return Days { era * 146097 + static_cast<long>(doe) - 719468 };
    }
 
    inline void daysToYmd(Days dys, int* year, int* month, int* day)
    {
        // Math from http://howardhinnant.github.io/date_algorithms.html
        auto const z = dys.count() + 719468;
        auto const era = (z >= 0 ? z : z - 146096) / 146097;
        auto const doe = static_cast<unsigned long>(z - era * 146097); // [0, 146096]
        auto const yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365; // [0, 399]
        auto const y = static_cast<Days::rep>(yoe) + era * 400;
        auto const doy = doe - (365 * yoe + yoe / 4 - yoe / 100); // [0, 365]
        auto const mp = (5 * doy + 2) / 153; // [0, 11]
        auto const m = mp < 10 ? mp + 3 : mp - 9; // [1, 12]
        auto const d = doy - (153 * mp + 2) / 5 + 1; // [1, 31]
        if (year) {
            *year = y + (m <= 2);
            *year = *year - (*year < 1); // if the year is negative; i.e. before common era, subtract one year.;
        }
        if (month)
            *month = static_cast<int>(m);
        if (day)
            *day = static_cast<int>(d);
    }
 
} // namespace internal
 
class Date {
public:
    using Days = internal::Days; 
    using Weeks = std::chrono::duration<long, std::ratio_multiply<std::ratio<7>, Days::period>>; 
 
 
    enum class Weekday {
        Monday = 1,
        Tuesday = 2,
        Wednesday = 3,
        Thursday = 4,
        Friday = 5,
        Saturday = 6,
        Sunday = 7
    };
 
    enum class Month {
        January = 1,
        February = 2,
        March = 3,
        April = 4,
        May = 5,
        June = 6,
        July = 7,
        August = 8,
        September = 9,
        October = 10,
        November = 11,
        December = 12
    };
 
 
    Date()
        : m_year(0)
        , m_month(0)
        , m_day(0)
    {
    }
 
    Date(const Date& other) = default;
 
    Date(Date&& other) = default;
 
    explicit Date(const Days& days)
    {
        internal::daysToYmd(days, &m_year, &m_month, &m_day);
    }
 
    explicit Date(int year, int month, int day)
        : m_year(year)
        , m_month(month)
        , m_day(day)
    {
    }
 
    ~Date() = default;
 
 
    Date& operator=(const Date& other) = default;
 
    Date& operator=(Date&& other) = default;
 
 
    bool operator<(const Date& other) const
    {
        return this->year() < other.year() || (this->year() == other.year() && this->month() < other.month()) || (this->year() == other.year() && this->month() == other.month() && this->day() < other.day());
    }
 
    bool operator<=(const Date& other) const
    {
        return this->operator<(other) || this->operator==(other);
    }
 
    bool operator>(const Date& other) const
    {
        return this->year() > other.year() || (this->year() == other.year() && this->month() > other.month()) || (this->year() == other.year() && this->month() == other.month() && this->day() > other.day());
    }
 
    bool operator>=(const Date& other) const
    {
        return this->operator>(other) || this->operator==(other);
    }
 
    bool operator==(const Date& other) const
    {
        return this->year() == other.year() && this->month() == other.month() && this->day() == other.day();
    }
 
    bool operator!=(const Date& other) const
    {
        return this->year() != other.year() || this->month() != other.month() || this->day() != other.day();
    }
 
 
    bool isValid() const
    {
        return m_year != 0 && (m_month > 0 && m_month < 13) && (m_day > 0 && m_day < (daysInMonthOfYear(m_year, m_month) + 1));
    }
 
    void getYearMonthDay(int* year, int* month, int* day) const
    {
        if (year)
            *year = m_year;
        if (month)
            *month = m_month;
        if (day)
            *day = m_day;
    }
 
    int day() const
    {
        return m_day;
    }
 
    int month() const
    {
        return m_month;
    }
 
    int year() const
    {
        return m_year;
    }
 
    int dayOfWeek() const
    {
        return (toDaysSinceEpoch() % 7 + 3) % 7 + 1;
    }
 
    int dayOfYear() const
    {
        return toDaysSinceEpoch() - internal::ymdToDays(year(), 1, 1).count() + 1;
    }
 
    int daysInMonth() const
    {
        return daysInMonthOfYear(year(), month());
    }
 
    int daysInYear() const
    {
        return (isLeapYear() ? 366 : 365);
    }
 
    bool isLeapYear() const
    {
        return isLeapYear(year());
    }
 
    int weekOfYear(int* weekYear = nullptr) const
    {
        static auto getFirstWeekDate = [](int year) {
            Date d(year, 1, 1);
            return d.addDays((11 - d.dayOfWeek()) % 7 - 3);
        };
        int y = year();
        Date currentDate = *this;
        Date firstWeekDate = getFirstWeekDate(y);
        if (currentDate < firstWeekDate) {
            // If the given date is earlier than the start of the first week of the year that contains it, then the date belongs to the last week of the previous year.
            --y;
            firstWeekDate = getFirstWeekDate(y);
        } else {
            Date nextYearFirstWeekDate = getFirstWeekDate(y + 1);
            if (currentDate >= nextYearFirstWeekDate) {
                // If the given date is on or after the start of the first week of the next year, then the date belongs to the first week of the next year.
                ++y;
                firstWeekDate = nextYearFirstWeekDate;
            }
        }
        int week = daysBetween(firstWeekDate, currentDate) / 7 + 1;
        if (weekYear)
            *weekYear = y;
        return week;
    }
 
    std::string dayOfWeekName(bool shortName = false) const
    {
        return shortName ? internal::getShortWeekdayName(dayOfWeek()) : internal::getLongWeekdayName(dayOfWeek());
    }
 
    std::string monthName(bool shortName = false) const
    {
        return shortName ? internal::getShortMonthName(month()) : internal::getLongMonthName(month());
    }
 
 
    Date addDays(int days) const
    {
        int y, m, d;
        internal::daysToYmd(Days(internal::ymdToDays(m_year, m_month, m_day) + Days(days)), &y, &m, &d);
        return Date(y, m, d);
    }
 
    Date subtractDays(int days) const
    {
        int y, m, d;
        internal::daysToYmd(Days(internal::ymdToDays(m_year, m_month, m_day) - Days(days)), &y, &m, &d);
        return Date(y, m, d);
    }
 
    Date addMonths(int months) const
    {
        if (months < 0)
            return subtractMonths(-months);
 
        const int totalMonths = m_month + months - 1;
        const int newYear = m_year + (totalMonths / 12);
        const int newMonth = (totalMonths % 12) + 1;
        const int newDaysInMonth = daysInMonthOfYear(newYear, newMonth);
        const int newDays = newDaysInMonth < m_day ? newDaysInMonth : m_day;
 
        return Date(newYear, newMonth, newDays);
    }
 
    Date subtractMonths(int months) const
    {
        if (months < 0)
            return addMonths(-months);
 
        const int newYear = m_year - (std::abs(m_month - months - 12) / 12);
        const int newMonth = ((11 + m_month - (months % 12)) % 12) + 1;
        const int newDaysInMonth = daysInMonthOfYear(newYear, newMonth);
        const int newDays = newDaysInMonth < m_day ? newDaysInMonth : m_day;
 
        return Date(newYear, newMonth, newDays);
    }
 
    Date addYears(int years) const
    {
        const int newYear = m_year + years;
        return Date(newYear > 0 ? newYear : newYear - 1, m_month, m_day);
    }
 
    Date subtractYears(int years) const
    {
        const int newYear = m_year - years;
        return Date(newYear > 0 ? newYear : newYear - 1, m_month, m_day);
    }
 
 
    long toDaysSinceEpoch() const
    {
        return internal::ymdToDays(year(), month(), day()).count();
    }
 
    Days toStdDurationSinceEpoch() const
    {
        return Days(toDaysSinceEpoch());
    }
 
    long toJulianDay() const
    {
        return toDaysSinceEpoch() + 2440588;
    }
 
    std::string toString(const std::string& format) const
    {
        if (!isValid())
            return std::string();
 
        std::stringstream output;
 
        for (size_t pos = 0; pos < format.size(); ++pos) {
            int y, m, d;
            getYearMonthDay(&y, &m, &d);
            y = std::abs(y);
 
            char currChar = format[pos];
            const int charCount = internal::countIdenticalCharsFrom(pos, format);
 
            if (currChar == '#') {
                output << (year() < 0 ? "-" : "+");
            } else if (currChar == 'y') {
                if (charCount == 1) {
                    output << y;
                } else if (charCount == 2) {
                    y = y - ((y / 100) * 100);
                    output << std::setfill('0') << std::setw(2) << y;
                } else if (charCount == 4) {
                    output << std::setfill('0') << std::setw(4) << y;
                }
                pos += charCount - 1; // skip all identical characters except the last.
            } else if (currChar == 'M') {
                if (charCount == 1) {
                    output << m;
                } else if (charCount == 2) {
                    output << std::setfill('0') << std::setw(2) << m;
                } else if (charCount == 3) {
                    output << monthName(true);
                } else if (charCount == 4) {
                    output << monthName(false);
                }
                pos += charCount - 1; // skip all identical characters except the last.
            } else if (currChar == 'd') {
                if (charCount == 1) {
                    output << d;
                } else if (charCount == 2) {
                    output << std::setfill('0') << std::setw(2) << d;
                } else if (charCount == 3) {
                    output << dayOfWeekName(true);
                } else if (charCount == 4) {
                    output << dayOfWeekName(false);
                }
                pos += charCount - 1; // skip all identical characters except the last.
            } else if (currChar == 'E') {
                output << (year() < 0 ? "BCE" : "CE");
            } else {
                output << currChar;
            }
        }
 
        return output.str();
    }
 
 
    static Date current()
    {
        return Date(std::chrono::duration_cast<Days>(std::chrono::system_clock::now().time_since_epoch()));
    }
 
    static Date epoch()
    {
        return Date(Days(0));
    }
 
    static Date fromString(const std::string& date, const std::string& format)
    {
        int _year = 1, _month = 1, _day = 1;
 
        for (size_t fmtPos = 0, datPos = 0; fmtPos < format.size() && datPos < date.size(); ++fmtPos) {
            const size_t charCount = static_cast<size_t>(internal::countIdenticalCharsFrom(fmtPos, format));
 
            if (format[fmtPos] == '#') {
                if (date[datPos] == '+') {
                    _year = 1;
                    ++datPos;
                } else if (date[datPos] == '-') {
                    _year = -1;
                    ++datPos;
                }
            } else if (format[fmtPos] == 'y') {
                if (charCount == 1) {
                    _year = _year * internal::readIntAndAdvancePos(date, datPos, 4);
                } else if (charCount == 2) {
                    _year = _year * std::stoi(date.substr(datPos, charCount));
                    _year += 2000;
                    datPos += charCount;
                } else if (charCount == 4) {
                    _year = _year * std::stoi(date.substr(datPos, charCount));
                    datPos += charCount;
                }
                fmtPos += charCount - 1; // skip all identical characters except the last.
            } else if (format[fmtPos] == 'E') {
                if (date.substr(datPos, 2) == "CE") {
                    _year = std::abs(_year);
                    datPos += 2;
                } else if (date.substr(datPos, 3) == "BCE") {
                    _year = -std::abs(_year);
                    datPos += 3;
                }
            } else if (format[fmtPos] == 'M') {
                if (charCount == 1) {
                    _month = internal::readIntAndAdvancePos(date, datPos, 4);
                } else if (charCount == 2) {
                    _month = std::stoi(date.substr(datPos, charCount));
                    datPos += charCount;
                } else if (charCount == 3) {
                    _month = internal::getShortMonthNumber(date.substr(datPos, charCount));
                    datPos += charCount;
                } else if (charCount == 4) {
                    size_t newPos = datPos;
                    while (newPos < date.size() && std::isalpha(date[newPos]))
                        ++newPos;
                    _month = internal::getLongMonthNumber(date.substr(datPos, newPos - datPos));
                    datPos = newPos;
                }
                fmtPos += charCount - 1; // skip all identical characters except the last.
            } else if (format[fmtPos] == 'd') {
                if (charCount == 1) {
                    _day = internal::readIntAndAdvancePos(date, datPos, 2);
                } else if (charCount == 2) {
                    _day = std::stoi(date.substr(datPos, charCount));
                    datPos += charCount;
                } else if (charCount == 3) {
                    // lets the format string and the date string be in sync.
                    datPos += charCount;
                } else if (charCount == 4) {
                    while (datPos < date.size() && std::isalpha(date[datPos]))
                        ++datPos;
                }
                fmtPos += charCount - 1; // skip all identical characters except the last.
            } else {
                // not a pattern, skip it in the date string.
                ++datPos;
            }
        }
 
        return Date(_year, _month, _day);
    }
 
    static Date fromJulianDay(long julianDay)
    {
        return Date(Days(julianDay - 2440588));
    }
 
    static long daysBetween(const Date& from, const Date& to)
    {
        return to.toDaysSinceEpoch() - from.toDaysSinceEpoch();
    }
 
    static long weeksBetween(const Date& from, const Date& to)
    {
        return daysBetween(from, to) / 7;
    }
 
 
    static bool isLeapYear(int year)
    {
        // no year 0 in the Gregorian calendar, the first year before the common era is -1 (year 1 BCE). So, -1, -5, -9 etc are leap years.
        if (year < 1)
            ++year;
 
        return (year % 4 == 0) && (year % 100 != 0 || year % 400 == 0);
    }
 
    static int daysInMonthOfYear(int year, int month)
    {
        switch (month) {
 
        case 1:
            return 31;
        case 2:
            return (isLeapYear(year) ? 29 : 28);
        case 3:
            return 31;
        case 4:
            return 30;
        case 5:
            return 31;
        case 6:
            return 30;
        case 7:
            return 31;
        case 8:
            return 31;
        case 9:
            return 30;
        case 10:
            return 31;
        case 11:
            return 30;
        case 12:
            return 31;
        }
 
        return -1;
    }
 
private:
    int m_year;
    int m_month;
    int m_day;
};
 
std::ostream& operator<<(std::ostream& os, const Date& d)
{
    os << d.toString("yyyy-MM-dd");
    return os;
}
 
std::istream& operator>>(std::istream& is, Date& d)
{
    const int DateFormatWidth = 10;
    char result[DateFormatWidth];
    is.read(result, DateFormatWidth);
    d = Date::fromString(std::string(result, DateFormatWidth), "yyyy-MM-dd");
 
    return is;
}
 
 
} // namespace xclox
 
#endif // XCLOX_DATE_HPP