#pragma once

/*                          MOUNT CONTROL COMPONENTS LIBRARY                            */


/*                  MOUNT TELEMETRY OBJECT POSSIBLE GENERIC IMPLEMENTATION                  */

#include <list>
#include <mutex>

#include "mcc_mount_telemetry_astrom.h"

namespace mcc
{
enum class MccMountTelemetryErrorCode : int { ERROR_OK, ERROR_HARDWARE };

/*  error category definition  */

// error category
struct MccMountTelemetryCategory : public std::error_category {
    MccMountTelemetryCategory() : std::error_category() {}

    const char* name() const noexcept
    {
        return "ADC_GENERIC_DEVICE";
    }

    std::string message(int ec) const
    {
        MccMountTelemetryErrorCode err = static_cast<MccMountTelemetryErrorCode>(ec);

        switch (err) {
            case MccMountTelemetryErrorCode::ERROR_OK:
                return "OK";
            case MccMountTelemetryErrorCode::ERROR_HARDWARE:
                return "hardware request failed";
            default:
                return "UNKNOWN";
        }
    }

    static const MccMountTelemetryAstromTransformCategory& get()
    {
        static const MccMountTelemetryAstromTransformCategory constInst;
        return constInst;
    }
};


inline std::error_code make_error_code(MccMountTelemetryErrorCode ec)
{
    return std::error_code(static_cast<int>(ec), MccMountTelemetryCategory::get());
}



}  // namespace mcc


namespace std
{

template <>
class is_error_code_enum<mcc::MccMountTelemetryErrorCode> : public true_type
{
};

}  // namespace std

namespace mcc
{


/*  DEFAULT TELEMETRY DATA CLASS  */

template <traits::mcc_astrom_engine_c ASTROM_ENGINE_T, traits::mcc_mount_pec_c PEC_T>
struct MccMountTelemetryData {
    typedef typename ASTROM_ENGINE_T::coord_t coord_t;
    typedef typename ASTROM_ENGINE_T::time_point_t time_point_t;
    typedef typename ASTROM_ENGINE_T::juldate_t juldate_t;
    typedef typename ASTROM_ENGINE_T::sideral_time_t sideral_time_t;
    typedef typename ASTROM_ENGINE_T::pa_t pa_t;

    // time-related
    time_point_t time_point;   // time point of measurements, UTC
    juldate_t jd;              // Julian date
    sideral_time_t siderTime;  // local apperant sideral time

    // target sky point ICRS and current coordinates
    coord_t tagRA_ICRS, tagDEC_ICRS;
    coord_t tagRA, tagDEC;
    coord_t tagHA;
    coord_t tagAZ, tagALT;
    pa_t tagPA;

    // encoder-measured current mount coordinates
    coord_t mntRA, mntDEC;
    coord_t mntHA;
    coord_t mntAZ, mntALT;
    pa_t mntPA;

    // encoder-measured (non-corrected for PCS) current mount position and axes rates
    // X - HA, Y - DEC for equatorial-type mount; X - AZ, Y - ALT for horizontal-type one
    coord_t mntPosX, mntPosY;
    coord_t mntRateX, mntRateY;

    // current refraction coefficients
    typename PEC_T::pec_result_t currRefrCoeffs;

    // current refraction correction (for mntALT)
    coord_t currRefr;

    // PEC (pointing error correction):
    // X - HA, Y - DEC for equatorial-type mount; X - AZ, Y - ALT for horizontal-type one
    coord_t pecX, pecY;
};



/*  DEFAULT TELEMETRY MANAGER CLASS  */

template <traits::mcc_astrom_engine_c ASTROM_ENGINE_T,
          traits::mcc_mount_pec_c PEC_T,
          traits::mcc_mount_hardware_c HARDWARE_T,
          std::derived_from<MccMountTelemetryData<ASTROM_ENGINE_T, PEC_T>> DATA_T =
              MccMountTelemetryData<ASTROM_ENGINE_T, PEC_T>>
class MccMountTelemetry : public MccMountTelemetryAstromTransform<ASTROM_ENGINE_T, PEC_T>
{
    typedef MccMountTelemetryAstromTransform<ASTROM_ENGINE_T, PEC_T> base_t;

    struct point_t {
        MccCoordPairKind coordPairKind;
        typename ASTROM_ENGINE_T::coord_t x, y;
    };

public:
    typedef ASTROM_ENGINE_T astrom_engine_t;
    typedef PEC_T pec_t;
    typedef HARDWARE_T hardware_t;
    typedef DATA_T mount_telemetry_data_t;

    typedef std::error_code error_t;

    typedef std::function<void(mount_telemetry_data_t)> update_callback_func_t;
    typedef std::list<update_callback_func_t> update_callback_container_t;

    MccMountTelemetry(astrom_engine_t& astrom_engine, pec_t& pec, hardware_t& hardware)
        : base_t(astrom_engine, pec), _hardware(hardware)
    {
    }

    virtual ~MccMountTelemetry() = default;


    // set current target sky point coordinates (update all data)
    template <traits::mcc_celestial_point_c PointT>
    error_t setTarget(PointT tag_point)
    {
        std::lock_guard lock{_updateMutex};

        auto err = this->toICRS(tag_point, _data.utc, _data.tagRA_ICRS, _data.tagDEC_ICRS);
        if (!err) {
            err = update();
        }

        return err;
    }


    error_t update()
    {
        mount_telemetry_data_t current_data;

        typename hardware_t::axes_pos_t ax_pos;

        auto err = _hardware.getPos(ax_pos);
        if (err) {
            if constexpr (std::same_as<error_t, decltype(err)>) {
                return err;
            }
            return MccMountTelemetryErrorCode::ERROR_HARDWARE;
        }

        error_t res_err;
        typename astrom_engine_t::error_t ast_err{};

        // times
        current_data.utc = ax_pos.time_point;
        // Julian date
        ast_err = this->_astromEngine.greg2jul(current_data.time_point, current_data.jd);
        if (!ast_err) {
            // local apparent sideral time
            ast_err = this->_astromEngine.apparentSiderTime(current_data.jd, current_data.siderTime, true);
        }

        if (ast_err) {
            if constexpr (std::same_as<typename astrom_engine_t::error_t, error_t>) {
                return ast_err;
            }

            return MccMountTelemetryAstromTransformErrorCode::ERROR_ASTROMETRY_COMP;
        }


        // encoder coordinates
        current_data.mntPosX = static_cast<typename astrom_engine_t::coord_t>(ax_pos.x);
        current_data.mntPosY = static_cast<typename astrom_engine_t::coord_t>(ax_pos.y);
        current_data.mntRateX = static_cast<typename astrom_engine_t::coord_t>(ax_pos.xrate);
        current_data.mntRateY = static_cast<typename astrom_engine_t::coord_t>(ax_pos.yrate);



        // correction for PEC
        if constexpr (base_t::equatorialMount) {
            res_err = this->toApparent(point_t{.coordPairKind = MccCoordPairKind::COORDS_KIND_XY,
                                               .x = current_data.mntPosX,
                                               .y = current_data.mntPosY},
                                       current_data.utc, current_data.mntHA, current_data.mntDEC);
            if (!res_err) {
                ast_err = this->_astromEngine.hadec2azalt(current_data.mntHA, current_data.mntDEC, current_data.mntAZ,
                                                          current_data.mntALT);
            }
        } else if constexpr (base_t::altAzMount) {
            res_err = this->toApparent(point_t{.coordPairKind = MccCoordPairKind::COORDS_KIND_XY,
                                               .x = current_data.mntPosX,
                                               .y = current_data.mntPosY},
                                       current_data.utc, current_data.mntAZ, current_data.mntALT);
            if (!res_err) {
                ast_err = this->_astromEngine.azalt2hadec(current_data.mntAZ, current_data.mntALT, current_data.mntHA,
                                                          current_data.mntDEC);
            }
        } else {
            static_assert(false, "UNSUPPORTED MOUNT TYPE!");
        }

        if (res_err) {
            return res_err;
        }

        // PA angle
        if (!ast_err) {
            ast_err = this->_astromEngine.hadec2pa(current_data.mntHA, current_data.mntDEC, current_data.mntPA);
            if (!ast_err) {
                // target coordinates (assuming its ICRS RA-DEC are already given or computed)
                typename mount_telemetry_data_t::eo_t eo;
                ast_err = this->_astromEngine.icrs2obs(current_data.tagRA_ICRS, current_data.tagDEC_ICRS,
                                                       current_data.jd, current_data.tagRA, current_data.tagDEC,
                                                       current_data.tagHA, current_data.tagAZ, current_data.tagALT, eo);

                if (!ast_err) {
                    current_data.mntRA = current_data.siderTime - current_data.mntHA + eo;  // CIO based mount RA
                    ast_err = this->_astromEngine.hadec2pa(current_data.tagHA, current_data.tagDEC, current_data.tagPA);
                }
            }
        }

        if (ast_err) {
            if constexpr (std::same_as<typename astrom_engine_t::error_t, error_t>) {
                return ast_err;
            }

            return MccMountTelemetryAstromTransformErrorCode::ERROR_ASTROMETRY_COMP;
        }

        std::lock_guard lock{_updateMutex};

        _data = std::move(current_data);

        std::lock_guard cl_lock{_callbackMutex};

        // callbacks will be invoked with its own copy of telemetry data!
        for (auto& func : _callbackFuncs) {
            std::thread t([this, &func] {
                auto d = _data;
                func(std::move(d));
            });
            t.detach();
        }

        return MccMountTelemetryErrorCode::ERROR_OK;
    }


    update_callback_container_t::iterator addCallbackFunc(update_callback_func_t func)
    {
        std::lock_guard lock{_callbackMutex};

        return _callbackFuncs.emplace_back(std::move(func));
    }

    void delCallbackFunc(update_callback_container_t::iterator iter)
    {
        std::lock_guard lock{_callbackMutex};

        if (_callbackFuncs.size()) {
            _callbackFuncs.erase(iter);
        }
    }

    void clearCallbackFuncs()
    {
        std::lock_guard lock{_callbackMutex};

        _callbackFuncs.clear();
    }

    error_t data(mount_telemetry_data_t& data)
    {
        std::lock_guard lock{_updateMutex};

        data = std::move(_data);

        return MccMountTelemetryErrorCode::ERROR_OK;
    }

protected:
    mount_telemetry_data_t _data{};
    hardware_t& _hardware;
    update_callback_container_t _callbackFuncs{};

    std::mutex _updateMutex;
    std::mutex _callbackMutex;
};


}  // namespace mcc