calendars/mtcore_calendars/core.hpp

Go to the documentation of this file.

/*
 
Copyright 2025 Matthew Tolman
 
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
 
   http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
 
*/
 
#ifndef MTCORE_CALENDARS_CORE_HPP
#define MTCORE_CALENDARS_CORE_HPP
 
#include "mtcore.hpp"
#include "mtcore_calendars.hpp"
#include "time.hpp"
#include "zoned.hpp"
 
namespace mtcore::calendars {
  using YearBase = i32;

  class AnnoDominiYear;

  class AstronomicalYear {
    YearBase year = 0;
 
  public:
    AstronomicalYear() = default;
    AstronomicalYear(const YearBase year) : year(year) { ensure(is_valid(year)); }
 
    explicit operator YearBase() const { return year; }
    explicit operator AnnoDominiYear() const;
 
    [[nodiscard]] AstronomicalYear operator+(YearBase years) const { return {year + years}; }
    [[nodiscard]] AstronomicalYear operator-(YearBase years) const { return {year - years}; }
    [[nodiscard]] YearBase difference(AstronomicalYear o) const { return year - o.year; }
    [[nodiscard]] auto operator<=>(const AstronomicalYear &o) const -> std::strong_ordering { return year <=> o.year; }
    [[nodiscard]] auto operator==(const AstronomicalYear &o) const -> bool { return year == o.year; }
    [[nodiscard]] auto operator!=(const AstronomicalYear &o) const -> bool { return year != o.year; }
    [[nodiscard]] auto operator<(const AstronomicalYear &o) const -> bool { return year < o.year; }
    [[nodiscard]] auto operator>(const AstronomicalYear &o) const -> bool { return year > o.year; }
    [[nodiscard]] auto operator>=(const AstronomicalYear &o) const -> bool { return year >= o.year; }
    [[nodiscard]] auto operator<=(const AstronomicalYear &o) const -> bool { return year <= o.year; }
 
    static bool is_valid(const YearBase year) { return year > std::numeric_limits<YearBase>::min(); }
  };
 
  class AnnoDominiYear {
    YearBase year = -1;
 
  public:
    AnnoDominiYear() = default;
    AnnoDominiYear(const YearBase year) : year(year) { ensure(is_valid(year)); }
    explicit operator YearBase() const {
      ensure(year != 0);
      return year;
    }
    explicit operator AstronomicalYear() const { return {year > 0 ? year : year + 1}; }
 
    [[nodiscard]] AnnoDominiYear operator+(YearBase years) const {
      return static_cast<AnnoDominiYear>(static_cast<AstronomicalYear>(*this) + years);
    }
    [[nodiscard]] AnnoDominiYear operator-(YearBase years) const { return *this + -years; }
    [[nodiscard]] YearBase difference(AnnoDominiYear o) const {
      return static_cast<AstronomicalYear>(*this).difference(static_cast<AstronomicalYear>(o));
    }
    [[nodiscard]] auto operator<=>(const AnnoDominiYear &o) const -> std::strong_ordering { return year <=> o.year; }
    [[nodiscard]] auto operator==(const AnnoDominiYear &o) const -> bool { return year == o.year; }
    [[nodiscard]] auto operator!=(const AnnoDominiYear &o) const -> bool { return year != o.year; }
    [[nodiscard]] auto operator<(const AnnoDominiYear &o) const -> bool { return year < o.year; }
    [[nodiscard]] auto operator>(const AnnoDominiYear &o) const -> bool { return year > o.year; }
    [[nodiscard]] auto operator>=(const AnnoDominiYear &o) const -> bool { return year >= o.year; }
    [[nodiscard]] auto operator<=(const AnnoDominiYear &o) const -> bool { return year <= o.year; }
 
    static bool is_valid(const YearBase year) { return year != 0; }
  };
 
  inline AstronomicalYear::operator AnnoDominiYear() const { return {year > 0 ? year : year - 1}; }

  enum class DayOfWeek {
    Sunday,
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday,
  };
}  // namespace mtcore::calendars
 
#include "mtcore_calendars/fixed.hpp"
#include "mtcore_calendars/traits.hpp"
 
namespace mtcore::calendars {
  template<IsDayCalendarSystem Calendar>
  struct CalDate {
    using CalendarSystem = Calendar;
    Calendar cal;
 
    CalDate()                           = default;
    CalDate(const CalDate &)            = default;
    CalDate(CalDate &&)                 = default;
    CalDate &operator=(const CalDate &) = default;
    CalDate &operator=(CalDate &&)      = default;
    CalDate(const Calendar &c) : cal(c) {}
 
    template<typename... Args>
    constexpr CalDate &init(Args... args) {
      if constexpr (is_initable<Calendar, Args...>) {
        cal.init(args...);
      }
      else {
        cal = Calendar{args...};
      }
      return *this;
    }
 
    template<typename... Args>
    constexpr static CalDate make(Args... args) {
      CalDate res;
      res.init(args...);
      return res;
    }
 
    template<IsDayCalendarSystem Other>
    [[nodiscard]] constexpr operator CalDate<Other>() const {
      return {Other::from_fixed(cal.to_fixed())};
    }

    template<IsDayCalendarSystem Other>
    [[nodiscard]] constexpr auto operator<=>(const CalDate<Other> &o) const {
      if constexpr (std::is_same_v<std::remove_cvref_t<Other>, std::remove_cvref_t<Calendar>>) {
        return cal <=> o.cal;
      }
      else {
        return cal.to_fixed() <=> o.cal.to_fixed();
      }
    }
    template<IsDayCalendarSystem Other>
    [[nodiscard]] constexpr auto operator==(const CalDate<Other> &o) const -> bool {
      auto cmp = *this <=> o;
      return cmp == decltype(cmp)::equivalent;
    }
    template<IsDayCalendarSystem Other>
    [[nodiscard]] constexpr auto operator!=(const CalDate<Other> &o) const -> bool {
      auto cmp = *this <=> o;
      return cmp != decltype(cmp)::equivalent;
    }
    template<IsDayCalendarSystem Other>
    [[nodiscard]] constexpr auto operator<=(const CalDate<Other> &o) const -> bool {
      auto cmp = *this <=> o;
      return cmp == decltype(cmp)::equivalent || cmp == decltype(cmp)::less;
    }
    template<IsDayCalendarSystem Other>
    [[nodiscard]] constexpr auto operator>=(const CalDate<Other> &o) const -> bool {
      auto cmp = *this <=> o;
      return cmp == decltype(cmp)::equivalent || cmp == decltype(cmp)::greater;
    }
    template<IsDayCalendarSystem Other>
    [[nodiscard]] constexpr auto operator<(const CalDate<Other> &o) const -> bool {
      auto cmp = *this <=> o;
      return cmp == decltype(cmp)::less;
    }
    template<IsDayCalendarSystem Other>
    [[nodiscard]] constexpr auto operator>(const CalDate<Other> &o) const -> bool {
      auto cmp = *this <=> o;
      return cmp == decltype(cmp)::greater;
    }

    [[nodiscard]] constexpr CalDate nearest_valid() const { return {Calendar::from_fixed(cal.to_fixed())}; }

    [[nodiscard]] constexpr bool is_valid() const { return *this == nearest_valid(); }

    [[nodiscard]] constexpr DayOfWeek day_of_week() const { return cal.to_fixed().day_of_week(); }

    [[nodiscard]] constexpr CalDate add_days(const i32 days) const {
      return {Calendar::from_fixed(cal.to_fixed().add_days(days))};
    }

    [[nodiscard]] constexpr CalDate sub_days(const i32 days) const {
      return {Calendar::from_fixed(cal.to_fixed().sub_days(days))};
    }

    template<IsDayCalendarSystem Other>
    [[nodiscard]] constexpr i32 day_difference(const CalDate<Other> &other) const {
      return cal.to_fixed().day_difference(other.cal.to_fixed());
    }

    [[nodiscard]] constexpr CalDate nth_week_day(const i32 n, const DayOfWeek k) const {
      return {Calendar::from_fixed(cal.to_fixed().nth_week_day(n, k))};
    }

    [[nodiscard]] constexpr CalDate day_of_week_before(const DayOfWeek k) const {
      return {Calendar::from_fixed(cal.to_fixed().day_of_week_before(k))};
    }

    [[nodiscard]] constexpr CalDate day_of_week_after(const DayOfWeek k) const {
      return {Calendar::from_fixed(cal.to_fixed().day_of_week_after(k))};
    }

    [[nodiscard]] constexpr CalDate day_of_week_nearest(const DayOfWeek k) const {
      return {Calendar::from_fixed(cal.to_fixed().day_of_week_nearest(k))};
    }

    [[nodiscard]] constexpr CalDate day_of_week_on_or_before(const DayOfWeek k) const {
      return {Calendar::from_fixed(cal.to_fixed().day_of_week_on_or_before(k))};
    }

    [[nodiscard]] constexpr CalDate day_of_week_on_or_after(const DayOfWeek k) const {
      return {Calendar::from_fixed(cal.to_fixed().day_of_week_on_or_after(k))};
    }

    [[nodiscard]] constexpr CalDate first_week_day(const DayOfWeek k) const {
      return {Calendar::from_fixed(cal.to_fixed().first_week_day(k))};
    }

    [[nodiscard]] constexpr CalDate last_week_day(const DayOfWeek k) const {
      return {Calendar::from_fixed(cal.to_fixed().last_week_day(k))};
    }

    template<IsDayCalendarSystem Other>
    [[nodiscard]] auto positions_in_range(Allocator &alloc, const CalDate<Other> &end, i32 pthMoment, i32 cDayCycle,
                                          i32 delta) const -> Result<ArrayList<CalDate>, AllocationError> {
      Result<ArrayList<Fixed>, AllocationError> fixedRes =
        cal.to_fixed().positions_in_range(alloc, end.cal.to_fixed(), pthMoment, cDayCycle, delta);
      if (fixedRes.is_error()) {
        return fixedRes.error();
      }
 
      auto fixedDates = fixedRes.value();
      mtdefer { fixedDates.deinit(alloc); };
      ArrayList<CalDate> res;
      if (const auto r = res.init(alloc, fixedDates.size()); r.is_error()) {
        return r.error();
      }
 
      auto iter = fixedDates.iter();
      Fixed cur = {};
      while (iter.next().copy_if_present(cur)) {
        ensure(res.push(CalDate{Calendar::from_fixed(cur)}).is_success());
      }
 
      return success(res);
    }

    [[nodiscard]] i32 day_of_m_cycle(i32 m, i32 offset) const { return cal.to_fixed().day_of_m_cycle(m, offset); }

    [[nodiscard]] auto kth_day_of_m_cycle_on_or_before(i32 k, i32 m, i32 offset) const noexcept -> CalDate {
      return {Calendar::from_fixed(cal.to_fixed().kth_day_of_m_cycle_on_or_before(k, m, offset))};
    }

    [[nodiscard]] auto kth_day_of_m_cycle_before(i32 k, i32 m, i32 offset) const noexcept -> CalDate {
      return {Calendar::from_fixed(cal.to_fixed().kth_day_of_m_cycle_before(k, m, offset))};
    }

    [[nodiscard]] auto kth_day_of_m_cycle_on_or_after(i32 k, i32 m, i32 offset) const noexcept -> CalDate {
      return {Calendar::from_fixed(cal.to_fixed().kth_day_of_m_cycle_on_or_after(k, m, offset))};
    }

    [[nodiscard]] auto kth_day_of_m_cycle_after(i32 k, i32 m, i32 offset) const noexcept -> CalDate {
      return {Calendar::from_fixed(cal.to_fixed().kth_day_of_m_cycle_after(k, m, offset))};
    }

    [[nodiscard]] auto kth_day_of_m_cycle_nearest(i32 k, i32 m, i32 offset) const noexcept -> CalDate {
      return {Calendar::from_fixed(cal.to_fixed().kth_day_of_m_cycle_nearest(k, m, offset))};
    }
  };

  template<typename C>
  struct CalDateTime;
 
  template<IsDayCalendarSystem Calendar>
  struct CalDateTime<Calendar> {
    using CalendarSystem = Calendar;
    Calendar cal;
    Segments time = {};
 
    [[nodiscard]] constexpr Segments time_segments() const { return time; }
 
    [[nodiscard]] constexpr operator CalDate<Calendar>() const noexcept { return CalDate<Calendar>{cal}; }

    [[nodiscard]] constexpr bool is_valid() const { return *this == nearest_valid(); }

    [[nodiscard]] constexpr CalDateTime nearest_valid() const {
      auto nearestDate = cal.to_fixed().day;
      auto frac        = time.to_fraction_unchecked();
      if (frac < 0) {
        nearestDate -= math::floor(frac - 1);
      }
      else if (frac > 1) {
        nearestDate += math::floor(frac + 1);
      }
      frac = frac - math::floor(frac);
      return CalDateTime{Calendar::from_fixed(Fixed{nearestDate}), static_cast<Segments>(DayFraction{frac})};
    }
 
    template<typename Other>
    [[nodiscard]] constexpr operator CalDateTime<Other>() const noexcept {
      if constexpr (IsDayCalendarSystem<Other>) {
        return {Other::from_fixed(cal.to_fixed()), time};
      }
      else {
        Moment t = {static_cast<f64>(cal.to_fixed().day) + time.to_fraction_unchecked()};
        return {Other::from_moment(t)};
      }
    }
 
    template<IsTimeCalendarSystem Other>
    [[nodiscard]] constexpr std::partial_ordering operator<=>(const CalDateTime<Other> &o) const {
      if constexpr (std::is_same_v<std::remove_cvref_t<Other>, std::remove_cvref_t<Calendar>>) {
        if (const std::partial_ordering cmp = cal <=> o.cal; cmp != std::partial_ordering::equivalent) {
          return cmp;
        }
        return time <=> o.time;
      }
      else {
        if (const std::partial_ordering cmp = cal.to_moment() <=> o.cal.to_moment();
            cmp != std::partial_ordering::equivalent) {
          return cmp;
        }
        return time <=> o.time;
      }
    }
 
    template<IsDayCalendarSystem Other>
    [[nodiscard]] constexpr std::partial_ordering operator<=>(const CalDateTime<Other> &o) const {
      if constexpr (std::is_same_v<std::remove_cvref_t<Other>, std::remove_cvref_t<Calendar>>) {
        if (const std::strong_ordering cmp = cal <=> o.cal; cmp != std::strong_ordering::equivalent) {
          return cmp;
        }
        return time <=> o.time;
      }
      else {
        if (const std::strong_ordering cmp = cal.to_fixed() <=> o.cal.to_fixed();
            cmp != std::strong_ordering::equivalent) {
          return cmp;
        }
        return time <=> o.time;
      }
    }
 
    template<typename Other>
    [[nodiscard]] constexpr auto operator==(const CalDateTime<Other> &o) const -> bool {
      auto cmp = *this <=> o;
      return cmp == decltype(cmp)::equivalent;
    }
    template<typename Other>
    [[nodiscard]] constexpr auto operator!=(const CalDateTime<Other> &o) const -> bool {
      auto cmp = *this <=> o;
      return cmp != decltype(cmp)::equivalent;
    }
    template<typename Other>
    [[nodiscard]] constexpr auto operator<=(const CalDateTime<Other> &o) const -> bool {
      auto cmp = *this <=> o;
      return cmp == decltype(cmp)::equivalent || cmp == decltype(cmp)::less;
    }
    template<typename Other>
    [[nodiscard]] constexpr auto operator>=(const CalDateTime<Other> &o) const -> bool {
      auto cmp = *this <=> o;
      return cmp == decltype(cmp)::equivalent || cmp == decltype(cmp)::greater;
    }
    template<typename Other>
    [[nodiscard]] constexpr auto operator<(const CalDateTime<Other> &o) const -> bool {
      auto cmp = *this <=> o;
      return cmp == decltype(cmp)::less;
    }
    template<typename Other>
    [[nodiscard]] constexpr auto operator>(const CalDateTime<Other> &o) const -> bool {
      auto cmp = *this <=> o;
      return cmp == decltype(cmp)::greater;
    }

    [[nodiscard]] constexpr DayOfWeek day_of_week() const { return cal.to_fixed().day_of_week(); }

    [[nodiscard]] constexpr CalDateTime add_days(const i32 days) const {
      return {Calendar::from_fixed(cal.to_fixed().add_days(days))};
    }

    [[nodiscard]] constexpr CalDateTime sub_days(const i32 days) const {
      return {Calendar::from_fixed(cal.to_fixed().sub_days(days))};
    }

    template<typename Other>
    [[nodiscard]] constexpr i32 day_difference(const CalDateTime<Other> &other) const {
      const auto om = static_cast<CalDateTime<Calendar>>(other);
      return cal.to_fixed().day_difference(om.cal.to_fixed());
    }

    [[nodiscard]] constexpr CalDateTime nth_week_day(const i32 n, const DayOfWeek k) const {
      return {Calendar::from_fixed(cal.to_fixed().nth_week_day(n, k))};
    }

    [[nodiscard]] constexpr CalDateTime day_of_week_before(const DayOfWeek k) const {
      return {Calendar::from_fixed(cal.to_fixed().day_of_week_before(k))};
    }

    [[nodiscard]] constexpr CalDateTime day_of_week_after(const DayOfWeek k) const {
      return {Calendar::from_fixed(cal.to_fixed().day_of_week_after(k))};
    }

    [[nodiscard]] constexpr CalDateTime day_of_week_nearest(const DayOfWeek k) const {
      return {Calendar::from_fixed(cal.to_fixed().day_of_week_nearest(k))};
    }

    [[nodiscard]] constexpr CalDateTime day_of_week_on_or_before(const DayOfWeek k) const {
      return {Calendar::from_fixed(cal.to_fixed().day_of_week_on_or_before(k))};
    }

    [[nodiscard]] constexpr CalDateTime day_of_week_on_or_after(const DayOfWeek k) const {
      return {Calendar::from_fixed(cal.to_fixed().day_of_week_on_or_after(k))};
    }

    [[nodiscard]] constexpr CalDateTime first_week_day(const DayOfWeek k) const {
      return {Calendar::from_fixed(cal.to_fixed().first_week_day(k))};
    }

    [[nodiscard]] constexpr CalDateTime last_week_day(const DayOfWeek k) const {
      return {Calendar::from_fixed(cal.to_fixed().last_week_day(k))};
    }

    template<typename Other>
    [[nodiscard]] auto positions_in_range(Allocator &alloc, const CalDateTime<Other> &end, i32 pthMoment, i32 cDayCycle,
                                          i32 delta) const -> Result<ArrayList<CalDateTime>, AllocationError> {
      Result<ArrayList<Fixed>, AllocationError> fixedRes = cal.to_fixed().positions_in_range(
        alloc, static_cast<CalDateTime<Fixed>>(end).cal.to_fixed(), pthMoment, cDayCycle, delta);
      if (fixedRes.is_error()) {
        return fixedRes.error();
      }
 
      auto fixedDates = fixedRes.value();
      mtdefer { fixedDates.deinit(alloc); };
      ArrayList<CalDateTime> res;
      if (const auto r = res.init(alloc, fixedDates.size()); r.is_error()) {
        return r.error();
      }
 
      auto iter = fixedDates.iter();
      Fixed cur = {};
      while (iter.next().copy_if_present(cur)) {
        ensure(res.push(CalDateTime{Calendar::from_fixed(cur), time}).is_success());
      }
 
      return success(res);
    }

    [[nodiscard]] i32 day_of_m_cycle(i32 m, i32 offset) const { return cal.to_fixed().day_of_m_cycle(m, offset); }

    [[nodiscard]] auto kth_day_of_m_cycle_on_or_before(i32 k, i32 m, i32 offset) const noexcept -> CalDateTime {
      return {Calendar::from_fixed(cal.to_fixed().kth_day_of_m_cycle_on_or_before(k, m, offset)), time};
    }

    [[nodiscard]] auto kth_day_of_m_cycle_before(i32 k, i32 m, i32 offset) const noexcept -> CalDateTime {
      return {Calendar::from_fixed(cal.to_fixed().kth_day_of_m_cycle_before(k, m, offset)), time};
    }

    [[nodiscard]] auto kth_day_of_m_cycle_on_or_after(i32 k, i32 m, i32 offset) const noexcept -> CalDateTime {
      return {Calendar::from_fixed(cal.to_fixed().kth_day_of_m_cycle_on_or_after(k, m, offset)), time};
    }

    [[nodiscard]] auto kth_day_of_m_cycle_after(i32 k, i32 m, i32 offset) const noexcept -> CalDateTime {
      return {Calendar::from_fixed(cal.to_fixed().kth_day_of_m_cycle_after(k, m, offset)), time};
    }

    [[nodiscard]] auto kth_day_of_m_cycle_nearest(i32 k, i32 m, i32 offset) const noexcept -> CalDateTime {
      return {Calendar::from_fixed(cal.to_fixed().kth_day_of_m_cycle_nearest(k, m, offset)), time};
    }
  };
 
  template<IsTimeCalendarSystem Calendar>
  struct CalDateTime<Calendar> {
    Calendar dateTime;

    [[nodiscard]] constexpr bool is_valid() const { return *this == nearest_valid(); }

    [[nodiscard]] constexpr CalDateTime nearest_valid() const {
      return CalDateTime{Calendar::from_moment(dateTime.to_moment())};
    }
 
    [[nodiscard]] constexpr Segments time_segments() const {
      const auto m  = dateTime.to_moment();
      const auto df = DayFraction{m - math::floor(m)};
      return static_cast<Segments>(df);
    }
 
    [[nodiscard]] constexpr operator CalDate<Fixed>() const noexcept {
      return CalDate<Fixed>{{math::floor(dateTime.dayAndTime)}};
    }
 
    template<typename Other>
    [[nodiscard]] constexpr operator CalDateTime<Other>() const noexcept {
      if constexpr (IsTimeCalendarSystem<Other>) {
        return {Other::from_moment(dateTime.to_moment()), time};
      }
      else {
        const auto m       = dateTime.to_moment();
        const i32 day      = math::floor(dateTime.dayAndTime);
        const auto dayFrac = DayFraction{m.dayAndTime - math::floor(dateTime.dayAndTime)};
        return {
          Other::from_fixed(Fixed{day}),
          static_cast<Segments>(dayFrac),
        };
      }
    }
 
    template<IsDayCalendarSystem Other>
    [[nodiscard]] constexpr std::partial_ordering operator<=>(const CalDateTime<Other> &o) const {
      const auto om = static_cast<CalDateTime<Calendar>>(o);
      return *this <=> om;
    }
 
    template<IsTimeCalendarSystem Other>
    [[nodiscard]] constexpr std::partial_ordering operator<=>(const CalDateTime<Other> &o) const {
      if constexpr (std::is_same_v<std::remove_cvref_t<Other>, std::remove_cvref_t<Calendar>>) {
        return dateTime <=> o.dateTime;
      }
      else {
        return dateTime.to_moment() <=> o.dateTime.to_moment();
      }
    }
 
    template<typename Other>
    [[nodiscard]] constexpr auto operator==(const CalDateTime<Other> &o) const -> bool {
      auto cmp = *this <=> o;
      return cmp == decltype(cmp)::equivalent;
    }
    template<typename Other>
    [[nodiscard]] constexpr auto operator!=(const CalDateTime<Other> &o) const -> bool {
      auto cmp = *this <=> o;
      return cmp != decltype(cmp)::equivalent;
    }
    template<typename Other>
    [[nodiscard]] constexpr auto operator<=(const CalDateTime<Other> &o) const -> bool {
      auto cmp = *this <=> o;
      return cmp == decltype(cmp)::equivalent || cmp == decltype(cmp)::less;
    }
    template<typename Other>
    [[nodiscard]] constexpr auto operator>=(const CalDateTime<Other> &o) const -> bool {
      auto cmp = *this <=> o;
      return cmp == decltype(cmp)::equivalent || cmp == decltype(cmp)::greater;
    }
    template<typename Other>
    [[nodiscard]] constexpr auto operator<(const CalDateTime<Other> &o) const -> bool {
      auto cmp = *this <=> o;
      return cmp == decltype(cmp)::less;
    }
    template<typename Other>
    [[nodiscard]] constexpr auto operator>(const CalDateTime<Other> &o) const -> bool {
      auto cmp = *this <=> o;
      return cmp == decltype(cmp)::greater;
    }

    [[nodiscard]] constexpr DayOfWeek day_of_week() const {
      return Moment::moment_to_fixed(dateTime.to_moment()).day_of_week();
    }

    [[nodiscard]] constexpr CalDateTime add_days(const i32 days) const {
      return {Calendar::from_moment(dateTime.to_moment().add_days(days))};
    }

    [[nodiscard]] constexpr CalDateTime sub_days(const i32 days) const {
      return {Calendar::from_moment(dateTime.to_moment().sub_days(days))};
    }

    template<typename Other>
    [[nodiscard]] constexpr i32 day_difference(const CalDateTime<Other> &other) const {
      const auto om = static_cast<CalDateTime<Calendar>>(other);
      return dateTime.to_moment().day_difference(om.dateTime.to_moment());
    }

    [[nodiscard]] constexpr CalDateTime nth_week_day(const i32 n, const DayOfWeek k) const {
      return {Calendar::from_moment(
        Moment::reconstruct(Moment::moment_to_fixed(dateTime.to_moment()).nth_week_day(n, k), dateTime.to_moment()))};
    }

    [[nodiscard]] constexpr CalDateTime day_of_week_before(const DayOfWeek k) const {
      return {Calendar::from_moment(Moment::reconstruct(
        Moment::moment_to_fixed(dateTime.to_moment()).day_of_week_before(k), dateTime.to_moment()))};
    }

    [[nodiscard]] constexpr CalDateTime day_of_week_after(const DayOfWeek k) const {
      return {Calendar::from_moment(
        Moment::reconstruct(Moment::moment_to_fixed(dateTime.to_moment()).day_of_week_after(k), dateTime.to_moment()))};
    }

    [[nodiscard]] constexpr CalDateTime day_of_week_nearest(const DayOfWeek k) const {
      return {Calendar::from_moment(Moment::reconstruct(
        Moment::moment_to_fixed(dateTime.to_moment()).day_of_week_nearest(k), dateTime.to_moment()))};
    }

    [[nodiscard]] constexpr CalDateTime day_of_week_on_or_before(const DayOfWeek k) const {
      return {Calendar::from_moment(Moment::reconstruct(
        Moment::moment_to_fixed(dateTime.to_moment()).day_of_week_on_or_before(k), dateTime.to_moment()))};
    }

    [[nodiscard]] constexpr CalDateTime day_of_week_on_or_after(const DayOfWeek k) const {
      return {Calendar::from_moment(Moment::reconstruct(
        Moment::moment_to_fixed(dateTime.to_moment()).day_of_week_on_or_after(k), dateTime.to_moment()))};
    }

    [[nodiscard]] constexpr CalDateTime first_week_day(const DayOfWeek k) const {
      return {Calendar::from_moment(
        Moment::reconstruct(Moment::moment_to_fixed(dateTime.to_moment()).first_week_day(k), dateTime.to_moment()))};
    }

    [[nodiscard]] constexpr CalDateTime last_week_day(const DayOfWeek k) const {
      return {Calendar::from_moment(
        Moment::reconstruct(Moment::moment_to_fixed(dateTime.to_moment()).last_week_day(k), dateTime.to_moment()))};
    }

    template<typename Other>
    [[nodiscard]] auto positions_in_range(Allocator &alloc, const CalDateTime<Other> &end, i32 pthMoment, i32 cDayCycle,
                                          i32 delta) const -> Result<ArrayList<CalDateTime>, AllocationError> {
      const auto moment = dateTime.to_moment();
 
      Result<ArrayList<Fixed>, AllocationError> fixedRes = Moment::moment_to_fixed(moment).positions_in_range(
        alloc, static_cast<CalDateTime<Fixed>>(end).cal.to_fixed(), pthMoment, cDayCycle, delta);
      if (fixedRes.is_error()) {
        return fixedRes.error();
      }
 
      auto fixedDates = fixedRes.value();
      mtdefer { fixedDates.deinit(alloc); };
      ArrayList<CalDateTime> res;
      if (const auto r = res.init(alloc, fixedDates.size()); r.is_error()) {
        return r.error();
      }
 
      auto iter = fixedDates.iter();
      Fixed cur = {};
      while (iter.next().copy_if_present(cur)) {
        ensure(res.push(CalDateTime{Calendar::from_moment(Moment::reconstruct(cur, moment))}).is_success());
      }
 
      return success(res);
    }

    [[nodiscard]] i32 day_of_m_cycle(i32 m, i32 offset) const {
      return Moment::moment_to_fixed(dateTime.to_moment()).day_of_m_cycle(m, offset);
    }

    [[nodiscard]] auto kth_day_of_m_cycle_on_or_before(i32 k, i32 m, i32 offset) const noexcept -> CalDateTime {
      return {Calendar::from_moment(
        Moment::reconstruct(Moment::moment_to_fixed(dateTime.to_moment()).kth_day_of_m_cycle_on_or_before(k, m, offset),
                            dateTime.to_moment()))};
    }

    [[nodiscard]] auto kth_day_of_m_cycle_before(i32 k, i32 m, i32 offset) const noexcept -> CalDateTime {
      return {Calendar::from_moment(Moment::reconstruct(
        Moment::moment_to_fixed(dateTime.to_moment()).kth_day_of_m_cycle_before(k, m, offset), dateTime.to_moment()))};
    }

    [[nodiscard]] auto kth_day_of_m_cycle_on_or_after(i32 k, i32 m, i32 offset) const noexcept -> CalDateTime {
      return {Calendar::from_moment(
        Moment::reconstruct(Moment::moment_to_fixed(dateTime.to_moment()).kth_day_of_m_cycle_on_or_after(k, m, offset),
                            dateTime.to_moment()))};
    }

    [[nodiscard]] auto kth_day_of_m_cycle_after(i32 k, i32 m, i32 offset) const noexcept -> CalDateTime {
      return {Calendar::from_moment(Moment::reconstruct(
        Moment::moment_to_fixed(dateTime.to_moment()).kth_day_of_m_cycle_after(k, m, offset), dateTime.to_moment()))};
    }

    [[nodiscard]] auto kth_day_of_m_cycle_nearest(i32 k, i32 m, i32 offset) const noexcept -> CalDateTime {
      return {Calendar::from_moment(Moment::reconstruct(
        Moment::moment_to_fixed(dateTime.to_moment()).kth_day_of_m_cycle_nearest(k, m, offset), dateTime.to_moment()))};
    }
  };

  template<typename Calendar>
  struct CalDateTimeZoned {
    static_assert(IsTimeCalendarSystem<Calendar> || IsDayCalendarSystem<Calendar>);
    using CalendarSystem = Calendar;
    CalDateTime<Calendar> dateTime;
    TimeZone zone = zone::utc();

    [[nodiscard]] constexpr bool is_valid() const {
      return zone.try_validate().is_success() && *this == nearest_valid();
    }

    [[nodiscard]] constexpr CalDateTimeZoned nearest_valid() const {
      auto nz              = zone;
      nz.offsetVal.hours   = std::max<i8>(-23, std::min<i8>(23, zone.offsetVal.hours));
      nz.offsetVal.minutes = std::max<i8>(-60, std::min<i8>(60, zone.offsetVal.minutes));
      nz.offsetVal.seconds = std::max<i8>(-60, std::min<i8>(60, zone.offsetVal.seconds));
      return CalDateTimeZoned{dateTime.nearest_valid(), nz};
    }
 
    [[nodiscard]] constexpr operator CalDate<Calendar>() const noexcept { return CalDate<Calendar>{dateTime}; }
    [[nodiscard]] constexpr operator CalDateTime<Calendar>() const noexcept { return dateTime; }
    [[nodiscard]] constexpr Segments time_segments() const noexcept { return dateTime.time_segments(); }
 
    template<typename Other>
    [[nodiscard]] constexpr operator CalDateTimeZoned<Other>() const noexcept {
      return {static_cast<CalDateTime<Calendar>>(dateTime), zone};
    }

    [[nodiscard]] constexpr CalDateTimeZoned to_utc() const noexcept {
      auto nano = static_cast<i64>(static_cast<NanoSeconds>(time_segments()).nano) - zone.offset_in_nanoseconds();
      auto c    = dateTime;
      if (nano < 0) {
        c    = dateTime.sub_days(1);
        nano = NANOS_PER_DAY - nano;
      }
      else if (nano >= NANOS_PER_DAY) {
        c    = dateTime.add_days(1);
        nano = nano - NANOS_PER_DAY;
      }
      ensure(nano >= 0);
      ensure(nano < NANOS_PER_DAY);
 
      if constexpr (IsDayCalendarSystem<Calendar>) {
        const auto segZoned = static_cast<Segments>(NanoSeconds{static_cast<u64>(nano)});
        return CalDateTimeZoned{
          CalDateTime<Calendar>{c.cal, segZoned},
          zone,
        };
      }
      else {
        const auto time   = static_cast<DayFraction>(NanoSeconds{static_cast<u64>(nano)});
        const auto moment = Moment::reconstruct(Moment::moment_to_fixed(c.dateTime.to_moment()), time);
        return CalDateTimeZoned{CalDateTime<Calendar>{Calendar::from_moment(moment)}, zone};
      }
    }

    [[nodiscard]] constexpr CalDateTimeZoned to_timezone(const TimeZone &tz) const noexcept {
      const auto utc = to_utc();
      auto nano = static_cast<i64>(static_cast<NanoSeconds>(utc.time_segments()).nano) + tz.offset_in_nanoseconds();
      auto c    = dateTime;
      if (nano < 0) {
        c    = dateTime.sub_days(1);
        nano = NANOS_PER_DAY - nano;
      }
      else if (nano >= NANOS_PER_DAY) {
        c    = dateTime.add_days(1);
        nano = nano - NANOS_PER_DAY;
      }
      ensure(nano >= 0);
      ensure(nano < NANOS_PER_DAY);
 
      if constexpr (IsDayCalendarSystem<Calendar>) {
        const auto segZoned = static_cast<Segments>(NanoSeconds{static_cast<u64>(nano)});
        return CalDateTimeZoned{
          CalDateTime<Calendar>{c, segZoned},
          zone,
        };
      }
      else {
        const auto time   = static_cast<DayFraction>(NanoSeconds{static_cast<u64>(nano)});
        const auto moment = Moment::reconstruct(Moment::moment_to_fixed(c.to_moment()), time);
        return CalDateTimeZoned{CalDateTime<Calendar>{Calendar::from_moment(moment)}, zone};
      }
    }
 
    template<typename Other>
    [[nodiscard]] constexpr std::partial_ordering operator<=>(const CalDateTimeZoned<Other> &o) const {
      const auto utc  = to_utc();
      const auto outc = o.to_utc();
      return utc.dateTime <=> outc.dateTime;
    }
 
    template<typename Other>
    [[nodiscard]] constexpr auto operator==(const CalDateTimeZoned<Other> &o) const -> bool {
      auto cmp = *this <=> o;
      return cmp == decltype(cmp)::equivalent;
    }
    template<typename Other>
    [[nodiscard]] constexpr auto operator!=(const CalDateTimeZoned<Other> &o) const -> bool {
      auto cmp = *this <=> o;
      return cmp != decltype(cmp)::equivalent;
    }
    template<typename Other>
    [[nodiscard]] constexpr auto operator<=(const CalDateTimeZoned<Other> &o) const -> bool {
      auto cmp = *this <=> o;
      return cmp == decltype(cmp)::equivalent || cmp == decltype(cmp)::less;
    }
    template<typename Other>
    [[nodiscard]] constexpr auto operator>=(const CalDateTimeZoned<Other> &o) const -> bool {
      auto cmp = *this <=> o;
      return cmp == decltype(cmp)::equivalent || cmp == decltype(cmp)::greater;
    }
    template<typename Other>
    [[nodiscard]] constexpr auto operator<(const CalDateTimeZoned<Other> &o) const -> bool {
      auto cmp = *this <=> o;
      return cmp == decltype(cmp)::less;
    }
    template<typename Other>
    [[nodiscard]] constexpr auto operator>(const CalDateTimeZoned<Other> &o) const -> bool {
      auto cmp = *this <=> o;
      return cmp == decltype(cmp)::greater;
    }

    [[nodiscard]] constexpr DayOfWeek day_of_week() const { return dateTime.day_of_week(); }

    [[nodiscard]] constexpr CalDateTimeZoned add_days(const i32 days) const { return {dateTime.add_days(days), zone}; }

    [[nodiscard]] constexpr CalDateTimeZoned sub_days(const i32 days) const { return {dateTime.sub_days(days), zone}; }

    template<typename Other>
    [[nodiscard]] constexpr i32 day_difference(const CalDateTimeZoned<Other> &other) const {
      return dateTime.day_difference(other.dateTime);
    }

    [[nodiscard]] constexpr CalDateTimeZoned nth_week_day(const i32 n, const DayOfWeek k) const {
      return {dateTime.nth_week_day(n, k), zone};
    }

    [[nodiscard]] constexpr CalDateTimeZoned day_of_week_before(const DayOfWeek k) const {
      return {dateTime.day_of_week_before(k), zone};
    }

    [[nodiscard]] constexpr CalDateTimeZoned day_of_week_after(const DayOfWeek k) const {
      return {dateTime.day_of_week_after(k), zone};
    }

    [[nodiscard]] constexpr CalDateTimeZoned day_of_week_nearest(const DayOfWeek k) const {
      return {dateTime.day_of_week_nearest(k), zone};
    }

    [[nodiscard]] constexpr CalDateTimeZoned day_of_week_on_or_before(const DayOfWeek k) const {
      return {dateTime.day_of_week_on_or_before(k), zone};
    }

    [[nodiscard]] constexpr CalDateTimeZoned day_of_week_on_or_after(const DayOfWeek k) const {
      return {dateTime.day_of_week_on_or_after(k), zone};
    }

    [[nodiscard]] constexpr CalDateTimeZoned first_week_day(const DayOfWeek k) const {
      return {dateTime.first_week_day(k), zone};
    }

    [[nodiscard]] constexpr CalDateTimeZoned last_week_day(const DayOfWeek k) const {
      return {dateTime.last_week_day(k), zone};
    }

    template<typename Other>
    [[nodiscard]] auto positions_in_range(Allocator &alloc, const CalDateTime<Other> &end, i32 pthMoment, i32 cDayCycle,
                                          i32 delta) const -> Result<ArrayList<CalDateTimeZoned>, AllocationError> {
      Result<ArrayList<Fixed>, AllocationError> pos = dateTime.positions_in_range(
        alloc, static_cast<CalDateTime<Fixed>>(end).cal.to_fixed(), pthMoment, cDayCycle, delta);
      if (pos.is_error()) {
        return pos.error();
      }
 
      auto dates = pos.value();
      mtdefer { dates.deinit(alloc); };
      ArrayList<CalDateTimeZoned> res;
      if (const auto r = res.init(alloc, dates.size()); r.is_error()) {
        return r.error();
      }
 
      auto iter                 = dates.iter();
      CalDateTime<Calendar> cur = {};
      while (iter.next().copy_if_present(cur)) {
        ensure(res.push(CalDateTimeZoned{cur, zone}).is_success());
      }
 
      return success(res);
    }

    [[nodiscard]] i32 day_of_m_cycle(i32 m, i32 offset) const { return dateTime.day_of_m_cycle(m, offset); }

    [[nodiscard]] auto kth_day_of_m_cycle_on_or_before(i32 k, i32 m, i32 offset) const noexcept -> CalDateTimeZoned {
      return {dateTime.kth_day_of_m_cycle_on_or_before(k, m, offset), zone};
    }

    [[nodiscard]] auto kth_day_of_m_cycle_before(i32 k, i32 m, i32 offset) const noexcept -> CalDateTimeZoned {
      return {dateTime.kth_day_of_m_cycle_before(k, m, offset), zone};
    }

    [[nodiscard]] auto kth_day_of_m_cycle_on_or_after(i32 k, i32 m, i32 offset) const noexcept -> CalDateTimeZoned {
      return {dateTime.kth_day_of_m_cycle_on_or_after(k, m, offset), zone};
    }

    [[nodiscard]] auto kth_day_of_m_cycle_after(i32 k, i32 m, i32 offset) const noexcept -> CalDateTimeZoned {
      return {dateTime.kth_day_of_m_cycle_after(k, m, offset), zone};
    }

    [[nodiscard]] auto kth_day_of_m_cycle_nearest(i32 k, i32 m, i32 offset) const noexcept -> CalDateTimeZoned {
      return {dateTime.kth_day_of_m_cycle_nearest(k, m, offset), zone};
    }
  };
 
  static_assert(IsTimeCalendarSystem<Moment>);
  static_assert(IsDayCalendarSystem<Fixed>);

  template<typename DateType>
  struct Range {
    DateType start;
    DateType end;

    struct Iter {
      DateType cur;
      DateType end;
 
      Optional<DateType> next() {
        if (cur >= end) {
          return nullopt;
        }
        mtdefer { cur = cur.add_days(1); };
        return cur;
      }
    };

    auto iter() const { return Iter{start, end}; }

    auto size() const {
      if (end <= start) {
        return 0;
      }
      return end.day_difference(start);
    }
  };
}  // namespace mtcore::calendars
 
#endif  // MTCORE_CALENDARS_CORE_HPP