#pragma once

/*                          MOUNT CONTROL COMPONENTS LIBRARY                            */


/*                          MCC LIBRARY DEFAULT IMPLEMENTATION OF SOME CLASSES                    */

// #include <compare>

#include "mcc_generics.h"

namespace mcc
{


/*                          DEFAULT TIME-RELATED CLASSES        */

typedef std::chrono::system_clock::time_point MccTimePoint;


typedef std::chrono::duration<double> MccTimeDuration;  // seconds as floating-point value

template <traits::mcc_time_duration_c DT>
static constexpr DT mcc_infinite_duration_v =
    std::floating_point<typename DT::rep> ? DT{std::numeric_limits<typename DT::rep>::infinity()}
                                          : DT{std::numeric_limits<typename DT::rep>::max()};


/*                          DEFAULT JULIAN DAY CLASS        */

struct MccJulianDay {
    static constexpr double MJD0 = 2400000.5;

    MccJulianDay() = default;

    MccJulianDay(double jd) : mjd(jd - MJD0) {}

    constexpr operator double() const
    {
        return MccJulianDay::MJD0 + mjd;
    }

    MccJulianDay& operator=(double jd)
    {
        mjd = jd - MJD0;

        return *this;
    }

    double MJD() const
    {
        return mjd;
    }

    constexpr auto operator<=>(const MccJulianDay&) const = default;

    constexpr auto operator<=>(double v) const
    {
        return v <=> (MccJulianDay::MJD0 + mjd);
    };

protected:
    double mjd{51544.5};  // J2000.0
};


/*                          DEFAULT CELESTIAL COORDINATES EPOCH CLASS               */

class MccCelestialCoordEpoch : public mcc_coord_epoch_interface_t
{
    inline static const std::regex dateTimeISO8601Rx{
        " *[0-9]{4}-[0,1][0-9]-[0-2][0-9]T[0-2][0-9]:[0-6][0-9]:[0-6][0-9](\\.[0-9]+)? *"};

    inline static const std::regex dateTimeJEpochRx{" *J[0-9]{4}(\\.[0-9]{1,})+ *"};
    inline static const std::regex dateTimeBEpochRx{" *B[0-9]{4}(\\.[0-9]{1,})+ *"};
    inline static const std::regex dateTimeMJDRx{" *([0-9]*[.])?[0-9]+([eE][-+]?[0-9]+)? *"};


    typedef std::chrono::duration<double, std::ratio<31556952>> year_fp_t;
    typedef std::chrono::duration<double, std::ratio<86400>> day_fp_t;

public:
    static constexpr auto J2000_UTC =
        std::chrono::sys_days(
            std::chrono::year_month_day(std::chrono::January / std::chrono::day(1) / std::chrono::year(2000))) +
        std::chrono::hours(11) + std::chrono::minutes(58) + std::chrono::milliseconds(55816);

    static constexpr double J2000_MJD = 51544.5;


    static MccCelestialCoordEpoch now()
    {
        MccCelestialCoordEpoch ep;
        ep.fromTimePoint(std::chrono::system_clock::now());

        return ep;
    }

    MccCelestialCoordEpoch() : _MJD(J2000_MJD), _UTC(J2000_UTC), _JEpoch(2000.0) {}

    template <traits::mcc_input_char_range IR>
    bool fromCharRange(IR&& str)
    {
        if constexpr (std::is_pointer_v<std::decay_t<IR>>) {
            return fromCharRange(std::string_view{str});
        }

        bool ret = false;

        std::string_view sv = utils::trimSpaces(std::forward<IR>(str));
        std::istringstream ist{std::string(sv)};

        // try ISO8601 date ...
        std::chrono::from_stream(ist, "%FT%T", _UTC);
        if (ist.fail()) {  // not ISO8601 date
            // try MJD (floating-point number) ...
            std::optional<double> mjd = utils::numFromStr<double>(sv);
            if (mjd) {
                _MJD = mjd.value();
                ret = fromMJD();
            } else {  // not MJD
                // try epoch (e.g. J2010.32)
                if (sv[0] == 'J') {
                    auto jep = utils::numFromStr<double>(sv.substr(1));
                    if (jep) {
                        _JEpoch = jep.value();
                        ret = fromJEpoch();
                    } else {  // ERROR!!!
                        ret = false;
                    }
                } else {  // ERROR!!!
                    ret = false;
                }
            }
        } else {
            ret = fromUTC();
        }

        return ret;
    }

    template <typename ClockT, typename DurT>
    bool fromTimePoint(std::chrono::time_point<ClockT, DurT>&& tp)
    {
        if constexpr (std::same_as<ClockT, std::chrono::system_clock>) {
            _UTC = std::chrono::time_point_cast<decltype(_UTC)::duration>(std::forward<decltype(tp)>(tp));
        } else if constexpr (std::same_as<ClockT, std::chrono::utc_clock>) {
            auto stp = std::chrono::utc_clock::to_sys(std::forward<decltype(tp)>(tp));
            _UTC = std::chrono::time_point_cast<decltype(_UTC)::duration>(std::forward<decltype(tp)>(stp));
        } else if constexpr (std::same_as<ClockT, std::chrono::tai_clock>) {
            return fromTimePoint(ClockT::to_utc(std::forward<decltype(tp)>(tp)));
        } else if constexpr (std::same_as<ClockT, std::chrono::gps_clock>) {
            return fromTimePoint(ClockT::to_utc(std::forward<decltype(tp)>(tp)));
        } else {
            static_assert(false, "UNSUPPORTED CLOCK!!!");
        }


        return fromUTC();
    }

    template <typename VT>
    bool fromMJD(VT&& mjd)
        requires std::is_arithmetic_v<VT>
    {
        _MJD = static_cast<double>(std::forward<VT>(mjd));

        return fromMJD();
    }

    template <traits::mcc_time_duration_c DT>
    MccCelestialCoordEpoch& operator+=(DT&& dt)
    {
        _UTC += std::chrono::duration_cast<decltype(_UTC)::duration>(std::forward<DT>(dt));

        _MJD += std::chrono::duration_cast<day_fp_t>(std::forward<DT>(dt)).count();

        _JEpoch += std::chrono::duration_cast<year_fp_t>(std::forward<DT>(dt)).count();

        return *this;
    }

    template <traits::mcc_time_duration_c DT>
    MccCelestialCoordEpoch& operator-=(DT&& dt)
    {
        _UTC -= std::chrono::duration_cast<decltype(_UTC)::duration>(std::forward<DT>(dt));

        _MJD -= std::chrono::duration_cast<day_fp_t>(std::forward<DT>(dt)).count();

        _JEpoch -= std::chrono::duration_cast<year_fp_t>(std::forward<DT>(dt)).count();

        return *this;
    }


    template <traits::mcc_time_duration_c DT>
    friend MccCelestialCoordEpoch operator+(const MccCelestialCoordEpoch& lhs, const DT& dt)
    {
        MccCelestialCoordEpoch ep;
        ep += dt;

        return ep;
    }
    template <traits::mcc_time_duration_c DT>
    friend MccCelestialCoordEpoch operator+(const DT& dt, const MccCelestialCoordEpoch& rhs)
    {
        return rhs + dt;
    }

    template <traits::mcc_time_duration_c DT>
    friend MccCelestialCoordEpoch operator-(const MccCelestialCoordEpoch& lhs, const DT& dt)
    {
        MccCelestialCoordEpoch ep;
        ep -= dt;

        return ep;
    }

    friend auto operator-(const MccCelestialCoordEpoch& lhs, const MccCelestialCoordEpoch& rhs)
    {
        return lhs._UTC - rhs._UTC;
    }


    template <typename VT>
        requires std::is_arithmetic_v<VT>
    VT MJD() const
    {
        return _MJD;
    }

    double MJD() const
    {
        return _MJD;
    }

    template <typename DT>
    std::chrono::sys_time<DT> UTC() const
    {
        return std::chrono::time_point_cast<DT>(_UTC);
    }

    std::chrono::system_clock::time_point UTC() const
    {
        return _UTC;
    }


    template <traits::mcc_output_char_range R>
    R JEpoch(uint8_t prec = 0) const
    {
        std::string prec_str{"J{:"};
        if (prec > 0) {
            prec_str += ".";
            prec_str += std::to_string(prec);
        }
        prec_str += "f}";

        std::string res = std::vformat(std::string_view{prec_str}, std::make_format_args(_JEpoch));

        if constexpr (std::same_as<R, std::string>) {
            return res;
        }

        R r;
        std::ranges::copy(res, std::back_inserter(r));

        return r;
    }

    std::string JEpoch(uint8_t prec = 0) const
    {
        return JEpoch<std::string>(prec);
    }

    auto operator<=>(const MccCelestialCoordEpoch& rhs) const
    {
        return _UTC <=> rhs._UTC;
    }

    auto operator==(const MccCelestialCoordEpoch& rhs) const
    {
        return _UTC == rhs._UTC;
    }

protected:
    std::chrono::system_clock::time_point _UTC;
    double _MJD;
    double _JEpoch;

    bool fromUTC()
    {
        // modified Julian date (based on ERFA eraCal2jd)
        auto dd = std::chrono::floor<std::chrono::days>(_UTC);
        std::chrono::year_month_day ymd{dd};

        static constexpr std::chrono::year MIN_YEAR{-4799};

        if (ymd.year() < MIN_YEAR) {
            return false;
        }
        if (!ymd.month().ok()) {
            return false;
        }

        int64_t im = (unsigned)ymd.month();
        int64_t id = (unsigned)ymd.day();
        int64_t iy = (int)ymd.year();

        int64_t my = (im - 14LL) / 12LL;
        int64_t iypmy = iy + my;

        // integer part of result MJD
        int64_t mjd_int = (1461LL * (iypmy + 4800LL)) / 4LL + (367LL * (im - 2LL - 12LL * my)) / 12LL -
                          (3LL * ((iypmy + 4900LL) / 100LL)) / 4LL + id - 2432076LL;

        _MJD = static_cast<double>(mjd_int) + std::chrono::duration_cast<day_fp_t>(_UTC - dd).count();

        _JEpoch = std::chrono::duration_cast<year_fp_t>(_UTC - J2000_UTC).count() + 2000.0;

        return true;
    }

    bool fromMJD(bool only_time_point = false)
    {
        // Gregorian date from modified Julian date (based on ERFS eraJd2cal)
        double f1 = -0.5;
        long jd = std::round(_MJD);
        double f2 = _MJD - jd;
        jd += 2400001.0;

        double s = 0.5, cs = 0.0;
        double v[] = {f1, f2};

        auto lmd = [&](double v) {
            // double x = v;
            // double t = s + x;
            // cs += std::fabs(s) >= std::fabs(x) ? (s - t) + x : (x - t) + s;
            double t = s + v;
            cs += std::fabs(s) >= std::fabs(v) ? (s - t) + v : (v - t) + s;
            s = t;
            if (s >= 1.0) {
                jd++;
                s -= 1.0;
            }
        };

        lmd(f1);
        lmd(f2);

        double f = s + cs;
        cs = f - s;

        if (f < 0.0) {
            f = s + 1.0;
            cs += (1.0 - f) + s;
            s = f;
            f = s + cs;
            cs = f - s;
            jd--;
        }


        if ((f - 1.0) >= -std::numeric_limits<double>::epsilon() / 4.0) {
            /* Compensated summation: assume that |s| <= 1.0. */
            double t = s - 1.0;
            cs += (s - t) - 1.0;
            s = t;
            f = s + cs;
            if (-std::numeric_limits<double>::epsilon() / 2.0 < f) {
                jd++;
                f = std::max(f, 0.0);
            }
        }

        long l = jd + 68569L;
        long n = (4L * l) / 146097L;
        l -= (146097L * n + 3L) / 4L;
        long i = (4000L * (l + 1L)) / 1461001L;
        l -= (1461L * i) / 4L - 31L;
        long k = (80L * l) / 2447L;

        auto day = std::chrono::day(l - (2447L * k) / 80L);
        l = k / 11L;
        auto month = std::chrono::month(k + 2L - 12L * l);
        auto year = std::chrono::year(100L * (n - 49L) + i + l);

        auto day_frac = day_fp_t(f);

        // _UTC = years + month + days + day_frac;
        _UTC = std::chrono::sys_days(std::chrono::year_month_day(month / day / year));
        _UTC += std::chrono::duration_cast<decltype(_UTC)::duration>(day_frac);

        if (!only_time_point) {
            _JEpoch = 2000.0 + (_MJD - J2000_MJD) / 365.25;
        }

        return true;
    }

    bool fromJEpoch()
    {
        _MJD = J2000_MJD + (_JEpoch - 2000.0) * 365.25;

        return fromMJD(true);
    }
};


static_assert(mcc_coord_epoch_c<MccCelestialCoordEpoch>, "!!!");


/*                          DEFAULT CELESTIAL POINT CLASS               */


template <mcc_angle_c CoordT>
struct MccGenericCelestialPoint {
    typedef CoordT coord_t;

    MccCoordPairKind pair_kind{MccCoordPairKind::COORDS_KIND_RADEC_ICRS};

    // MccTimePoint time_point{std::chrono::sys_days(std::chrono::year_month_day{std::chrono::January / 1 / 2000}) +
    //                         std::chrono::hours(12)};  // J2000.0

    MccTimePoint time_point{std::chrono::sys_days(std::chrono::year_month_day(
                                std::chrono::January / std::chrono::day(1) / std::chrono::year(2000))) +
                            std::chrono::hours(11) + std::chrono::minutes(58) +
                            std::chrono::milliseconds(55816)};  // J2000.0 UTC


    coord_t X{}, Y{};
};


typedef MccGenericCelestialPoint<double> MccCelestialPoint;


template <mcc_angle_c CoordT>
struct MccGenericEqtHrzCoords : MccGenericCelestialPoint<CoordT> {
    using typename MccGenericCelestialPoint<CoordT>::coord_t;

    using MccGenericCelestialPoint<CoordT>::time_point;

    coord_t RA_APP{}, DEC_APP{}, HA{}, AZ{}, ZD{}, ALT{};
};

typedef MccGenericEqtHrzCoords<MccCelestialPoint::coord_t> MccEqtHrzCoords;


template <mcc_angle_c CoordT>
struct MccGenericPointingTarget : MccGenericEqtHrzCoords<CoordT> {
    using typename MccGenericEqtHrzCoords<CoordT>::coord_t;

    coord_t RA_ICRS{}, DEC_ICRS{};
};


typedef MccGenericPointingTarget<MccCelestialPoint::coord_t> MccPointingTarget;



template <mcc_angle_c CoordT>
struct MccGenericPCMResult {
    CoordT pcmX, pcmY;
};


typedef MccGenericPCMResult<double> MccPCMResult;


/*                          DEFAULT TELEMETRY DATA CLASS               */

template <mcc_angle_c CoordT>
struct MccGenericTelemetryData : MccGenericEqtHrzCoords<CoordT> {
    using typename MccGenericEqtHrzCoords<CoordT>::coord_t;

    MccJulianDay JD;
    coord_t LST;  // local apparent sideral time

    MccGenericPointingTarget<coord_t> target{};

    coord_t speedX, speedY;

    coord_t pcmX, pcmY;

    coord_t refCorr;
};


typedef MccGenericTelemetryData<MccCelestialPoint::coord_t> MccTelemetryData;



template <mcc_ccte_c CCTE_T, mcc_hardware_c HARDWARE_T, mcc_PCM_c PCM_T>
struct MccPositionControls : CCTE_T, HARDWARE_T, PCM_T {
    virtual ~MccPositionControls() = default;
};


/*                      JUST CHECK FOR CONCEPT CONSISTENCY              */

static_assert(mcc_julday_c<MccJulianDay>, "");
static_assert(mcc_celestial_point_c<MccCelestialPoint>, "");
static_assert(mcc_telemetry_data_c<MccTelemetryData>, "");


}  // namespace mcc