#pragma once

/*                          MOUNT CONTROL COMPONENTS LIBRARY                            */


/*                          GENERIC MOUNT REFERENCE IMPLEMENTATION                          */


#include "mcc_generics.h"


namespace mcc
{

enum class MccGenericMountErrorCode : int { ERROR_OK, ERROR_HW_INIT, ERROR_HW_STOP, ERROR_HW_GETSTATE };

}  // namespace mcc


namespace std
{

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

}  // namespace std



namespace mcc
{

template <mcc_hardware_c HardwareT,
          mcc_telemetry_c TelemetryT,
          mcc_pzone_container_c PZoneContT,
          mcc_slewing_model_c SlewModelT,
          mcc_tracking_model_c TrackModelT,
          mcc_guiding_model_c GuidingModelT,
          mcc_logger_c LoggerT = MccNullLogger>
class MccGenericMount : public HardwareT,
                        public TelemetryT,
                        public PZoneContT,
                        public SlewModelT,
                        public TrackModelT,
                        public GuidingModelT,
                        public LoggerT
{
public:
    typedef std::error_code error_t;

    using LoggerT::logDebug;
    using LoggerT::logError;
    using LoggerT::logInfo;
    using LoggerT::logWarn;


    using typename GuidingModelT::guiding_params_t;
    using typename SlewModelT::slewing_params_t;
    using typename TrackModelT::tracking_params_t;

    MccGenericMount(HardwareT hardware,
                    TelemetryT telemetry,
                    PZoneContT pzone_cont,
                    SlewModelT slew_model,
                    TrackModelT track_model,
                    GuidingModelT guiding_model,
                    LoggerT logger = MccNullLogger{})
        : HardwareT(std::move(hardware)),
          TelemetryT(std::move(telemetry)),
          PZoneContT(std::move(pzone_cont)),
          SlewModelT(std::move(slew_model)),
          TrackModelT(std::move(track_model)),
          GuidingModelT(std::move(guiding_model)),
          LoggerT(std::move(logger))
    {
    }

    virtual ~MccGenericMount() = default;

    error_t stopMount()
    {
        logInfo("stop any movements ...");

        this->stopGuidingTarget();
        this->stopTracking();
        this->stopSlewing();

        auto hw_err = this->hardwareStop();
        if (hw_err) {
            return mcc_deduce_error(hw_err, MccGenericMountErrorCode::ERROR_HW_STOP);
        }

        // poll hardware till stopped-state detected ...

        logInfo("mount was stopped");

        return MccGenericMountErrorCode::ERROR_OK;
    }

    error_t initMount()
    {
        auto hw_err = this->hardwareInit();
        if (hw_err) {
            return mcc_deduce_error(hw_err, MccGenericMountErrorCode::ERROR_HW_STOP);
        }

        return MccGenericMountErrorCode::ERROR_OK;
    }
};


/*                          GENERIC FINITE-STATE-MOCHINE MOUNT REFERENCE IMPLEMENTATION                          */


template <mcc_hardware_c HardwareT,
          mcc_telemetry_c TelemetryT,
          mcc_pzone_container_c PZoneContT,
          mcc_slewing_model_c SlewModelT,
          mcc_tracking_model_c TrackModelT,
          mcc_guiding_model_c GuidingModelT,
          mcc_logger_c LoggerT = MccNullLogger>
class MccGenericMountFSM
    : public fsm::MccFiniteStateMachine,
      public MccGenericMount<HardwareT, TelemetryT, PZoneContT, SlewModelT, TrackModelT, GuidingModelT, LoggerT>
{
protected:
    typedef MccGenericMount<HardwareT, TelemetryT, PZoneContT, SlewModelT, TrackModelT, GuidingModelT, LoggerT>
        base_gmount_t;

public:
    typedef typename base_gmount_t::error_t error_t;

    /*                          EVENTS AND STATES DEFINITION                            */


    /*  base class for events  */

    struct MccGenericMountBaseEvent {
        virtual ~MccGenericMountBaseEvent() = default;

        MccGenericMountFSM& mount() const
        {
            return _mount;
        }

    protected:
        MccGenericMountFSM& _mount;

        MccGenericMountBaseEvent(MccGenericMountFSM& mount) : _mount(mount) {}
    };

    // to IDLE state
    struct MccGenericMountEventIDLE : MccGenericMountBaseEvent {
        static constexpr std::string_view ID = "MCC-MOUNT-IDLE-EVENT";

        // CTAD does not work for clang++ (at least till v. 20 and -std=c++23)!
        // so, one must explicitly define constructor here
        MccGenericMountEventIDLE(MccGenericMountFSM& mount) : MccGenericMountBaseEvent(mount) {}
    };


    // to error state
    struct MccGenericMountEventError : MccGenericMountBaseEvent {
        static constexpr std::string_view ID = "MCC-MOUNT-ERROR-EVENT";

        MccGenericMountEventError(MccGenericMountFSM& mount, const error_t& err)
            : MccGenericMountBaseEvent(mount), _error(err)
        {
        }


        error_t eventData() const
        {
            return _error;
        }

    protected:
        error_t _error;
    };


    // to INIT state
    struct MccGenericMountEventInit : MccGenericMountBaseEvent {
        static constexpr std::string_view ID = "MCC-MOUNT-INIT-EVENT";

        MccGenericMountEventInit(MccGenericMountFSM& mount) : MccGenericMountBaseEvent(mount) {}
    };


    // to slewing state
    struct MccGenericMountEventSlew : MccGenericMountBaseEvent {
        static constexpr std::string_view ID = "MCC-MOUNT-SLEWING-EVENT";

        MccGenericMountEventSlew(MccGenericMountFSM& mount) : MccGenericMountBaseEvent(mount) {}
    };


    // to tracking state
    struct MccGenericMountEventTrack : MccGenericMountBaseEvent {
        static constexpr std::string_view ID = "MCC-MOUNT-TRACKING-EVENT";

        MccGenericMountEventTrack(MccGenericMountFSM& mount) : MccGenericMountBaseEvent(mount) {}
    };


    // to guiding state
    struct MccGenericMountEventGuiding : MccGenericMountBaseEvent {
        static constexpr std::string_view ID = "MCC-MOUNT-GUIDING-EVENT";

        MccGenericMountEventGuiding(MccGenericMountFSM& mount) : MccGenericMountBaseEvent(mount) {}
    };


    // to stoping state
    struct MccGenericMountEventStop : MccGenericMountBaseEvent {
        static constexpr std::string_view ID = "MCC-MOUNT-STOP-EVENT";

        MccGenericMountEventStop(MccGenericMountFSM& mount) : MccGenericMountBaseEvent(mount) {}
    };



    /*  base class for states  */

    struct MccGenericMountBaseState {
        virtual ~MccGenericMountBaseState() = default;

    protected:
        MccGenericMountBaseState() = default;

        template <std::derived_from<MccGenericMountBaseEvent> EvT>
        void exitLog(this auto&& self, EvT& event)
        {
            using self_t = std::remove_cvref_t<decltype(self)>;

            event.mount().logDebug(std::format("Exit from '{}' state due to '{}' event ...", self_t::ID, EvT::ID));
        }

        template <std::derived_from<MccGenericMountBaseEvent> EvT>
        void enterLog(this auto&& self, EvT& event)
        {
            using self_t = std::remove_cvref_t<decltype(self)>;
            event.mount().logDebug(std::format("Enter to '{}' state due to '{}' event ...", self_t::ID, EvT::ID));
        }
    };

    // forward declarations
    struct MccGenericMountStateInit;
    struct MccGenericMountStateIDLE;
    struct MccGenericMountStateError;
    struct MccGenericMountStateSlew;
    struct MccGenericMountStateTrack;
    struct MccGenericMountStateGuiding;
    struct MccGenericMountStateStopping;

    struct MccGenericMountStateUninit : MccGenericMountBaseState {
        // from uninitialized state only INIT-event is permitted!
        using transition_t = fsm::fsm_transition_table_t<std::pair<MccGenericMountEventInit, MccGenericMountStateInit>>;

        template <std::derived_from<MccGenericMountBaseEvent> EvT>
        void exit(EvT& event)
        {
            this->exitLog(event);
        }

        template <std::derived_from<MccGenericMountBaseEvent> EvT>
        void enter(EvT& event)
        {
            this->enterLog(event);
        }
    };

    struct MccGenericMountStateInit : MccGenericMountBaseState {
        using transition_t =
            fsm::fsm_transition_table_t<std::pair<MccGenericMountEventIDLE, MccGenericMountStateIDLE>,
                                        std::pair<MccGenericMountEventError, MccGenericMountStateError>>;
        // fsm::fsm_transition_table_t<std::pair<MccGenericMountEventInit, MccGenericMountStateInit>,
        //                             std::pair<MccGenericMountEventIDLE, MccGenericMountStateIDLE>,
        //                             std::pair<MccGenericMountEventError, MccGenericMountStateError>,
        //                             std::pair<MccGenericMountEventStop, MccGenericMountStateInit>,
        //                             std::pair<MccGenericMountEventSlew, MccGenericMountStateInit>,
        //                             std::pair<MccGenericMountEventTrack, MccGenericMountStateInit>,
        //                             std::pair<MccGenericMountEventGuiding, MccGenericMountStateInit>>;

        template <std::derived_from<MccGenericMountBaseEvent> EvT>
        void exit(EvT& event)
        {
            this->exitLog(event);
        }

        template <std::derived_from<MccGenericMountBaseEvent> EvT>
        void enter(EvT& event)
        {
            this->enterLog(event);

            error_t err = event.mount()._initMount();
            if (err) {
                event.mount().dispatchEvent(MccGenericMountEventError{event.mount(), err});
            } else {
                event.mount().dispatchEvent(MccGenericMountEventIDLE{event.mount()});
            }
        }
    };

    struct MccGenericMountStateIDLE : MccGenericMountBaseState {
        using transition_t =
            fsm::fsm_transition_table_t<std::pair<MccGenericMountEventInit, MccGenericMountStateInit>,
                                        std::pair<MccGenericMountEventError, MccGenericMountStateError>,
                                        std::pair<MccGenericMountEventStop, MccGenericMountStateStopping>,
                                        std::pair<MccGenericMountEventSlew, MccGenericMountStateSlew>,
                                        std::pair<MccGenericMountEventTrack, MccGenericMountStateTrack>>;

        template <std::derived_from<MccGenericMountBaseEvent> EvT>
        void exit(EvT& event)
        {
            this->exitLog(event);
        }

        template <std::derived_from<MccGenericMountBaseEvent> EvT>
        void enter(EvT& event)
        {
            this->enterLog(event);
        }
    };


    struct MccGenericMountStateStopping : MccGenericMountBaseState {
        using transition_t =
            fsm::fsm_transition_table_t<std::pair<MccGenericMountEventIDLE, MccGenericMountStateIDLE>,
                                        std::pair<MccGenericMountEventError, MccGenericMountStateError>>;

        template <std::derived_from<MccGenericMountBaseEvent> EvT>
        void exit(EvT& event)
        {
            this->exitLog(event);
        }

        template <std::derived_from<MccGenericMountBaseEvent> EvT>
        void enter(EvT& event)
        {
            this->enterLog(event);

            error_t err = event.mount()._stopMount();
            if (err) {
                event.mount().dispatchEvent(MccGenericMountEventError{event.mount(), err});
            } else {
                event.mount().dispatchEvent(MccGenericMountEventIDLE{event.mount()});
            }
        }
    };


    struct MccGenericMountStateSlew : MccGenericMountBaseState {
        using transition_t =
            fsm::fsm_transition_table_t<std::pair<MccGenericMountEventIDLE, MccGenericMountStateIDLE>,
                                        std::pair<MccGenericMountEventStop, MccGenericMountStateStopping>,
                                        std::pair<MccGenericMountEventError, MccGenericMountStateError>,
                                        std::pair<MccGenericMountEventTrack, MccGenericMountStateTrack>>;

        template <std::derived_from<MccGenericMountBaseEvent> EvT>
        void exit(EvT& event)
        {
            error_t err = event.mount()._stopSlewingMount();
            if (err) {
                event.mount().dispatchEvent(MccGenericMountEventError{event.mount(), err});
            }

            this->exitLog(event);
        }

        template <std::derived_from<MccGenericMountBaseEvent> EvT>
        void enter(EvT& event)
        {
            this->enterLog(event);

            error_t err = event.mount()._slewMount();
            if (err) {
                event.mount().dispatchEvent(MccGenericMountEventError{event.mount(), err});
            } else {
                auto slew_pars = event.mount().getSlewingParams();

                if (slew_pars.slewAndStop) {
                    event.mount().dispatchEvent(MccGenericMountEventIDLE{event.mount()});
                } else {
                    event.mount().dispatchEvent(MccGenericMountEventTrack{event.mount()});
                }
            }
        }
    };


    struct MccGenericMountStateTrack : MccGenericMountBaseState {
        using transition_t =
            fsm::fsm_transition_table_t<std::pair<MccGenericMountEventStop, MccGenericMountStateStopping>,
                                        std::pair<MccGenericMountEventError, MccGenericMountStateError>,
                                        std::pair<MccGenericMountEventGuiding, MccGenericMountStateGuiding>>;

        template <std::derived_from<MccGenericMountBaseEvent> EvT>
        void exit(EvT& event)
        {
            error_t err = event.mount()._stopTrackingMount();
            if (err) {
                event.mount().dispatchEvent(MccGenericMountEventError{event.mount(), err});
            }

            this->exitLog(event);
        }

        template <std::derived_from<MccGenericMountBaseEvent> EvT>
        void enter(EvT& event)
        {
            this->enterLog(event);

            error_t err = event.mount()._trackMount();
            if (err) {
                event.mount().dispatchEvent(MccGenericMountEventError{event.mount(), err});
            }
        }
    };


    struct MccGenericMountStateGuiding : MccGenericMountBaseState {
        using transition_t =
            fsm::fsm_transition_table_t<std::pair<MccGenericMountEventStop, MccGenericMountStateStopping>,
                                        std::pair<MccGenericMountEventError, MccGenericMountStateError>,
                                        std::pair<MccGenericMountEventTrack, MccGenericMountStateTrack>>;

        template <std::derived_from<MccGenericMountBaseEvent> EvT>
        void exit(EvT& event)
        {
            error_t err = event.mount()._stopGuidingMount();
            if (err) {
                event.mount().dispatchEvent(MccGenericMountEventError{event.mount(), err});
            }

            this->exitLog(event);
        }

        template <std::derived_from<MccGenericMountBaseEvent> EvT>
        void enter(EvT& event)
        {
            this->enterLog(event);

            error_t err = event.mount()._startGuidingMount();
            if (err) {
                event.mount().dispatchEvent(MccGenericMountEventError{event.mount(), err});
            }
        }
    };


    /*  CONSTRUCTORS AND DESTRUCTOR  */

    MccGenericMountFSM(HardwareT hardware,
                       TelemetryT telemetry,
                       PZoneContT pzone_cont,
                       SlewModelT slew_model,
                       TrackModelT track_model,
                       GuidingModelT guiding_model,
                       LoggerT logger = MccNullLogger{})
        : fsm::MccFiniteStateMachine(MccGenericMountStateUninit{}),
          base_gmount_t(std::move(hardware),
                        std::move(telemetry),
                        std::move(pzone_cont),
                        std::move(slew_model),
                        std::move(track_model),
                        std::move(guiding_model),
                        std::move(logger))
    {
    }


    virtual ~MccGenericMountFSM() = default;

    // reimplementation of base-class methods to adapt it to FSM-behavior
    auto initMount()
    {
        this->dispatchEvent(MccGenericMountEventInit{*this});
    }

    auto stopMount()
    {
        this->dispatchEvent(MccGenericMountEventStop{*this});
    }

    auto slewToTarget()
    {
        this->dispatchEvent(MccGenericMountEventSlew{*this});
    }

    auto stopSlewing()
    {
        this->dispatchEvent(MccGenericMountEventStop{*this});
    }

    auto trackTarget()
    {
        this->dispatchEvent(MccGenericMountEventTrack{*this});
    }


    auto stopTracking()
    {
        this->dispatchEvent(MccGenericMountEventIDLE{*this});
    }

    auto startGuidingTarget()
    {
        this->dispatchEvent(MccGenericMountEventGuiding{*this});
    }

    auto stopGuidingTarget()
    {
        this->dispatchEvent(MccGenericMountEventTrack{*this});
    }

protected:
    // wrappers

    auto _initMount()
    {
        return base_gmount_t::initMount();
    }


    auto _stopMount()
    {
        return base_gmount_t::stopMount();
    }

    auto _slewToTarget()
    {
        return base_gmount_t::slewToTarget();
    }


    auto _trackTarget()
    {
        return base_gmount_t::trackTarget();
    }


    auto _startGuidingTarget()
    {
        return base_gmount_t::startGuidingTarget();
    }

    auto _stopGuidingTarget()
    {
        return base_gmount_t::stopGuidingTarget();
    }
};


}  // namespace mcc