#pragma once

/*  MOUNT CONTROL COMPONENTS LIBRARY  */

/*
 *  BASIC EVENTS AND MOUNT STATES DEFINITIONS (POSSIBLE IMPLEMENTATION)
 *
 */

#include <format>

#include "mcc_mount_concepts.h"

namespace mcc
{


/*  MOUNT STATE MACHINE STATES  */


// a base class for mount state machine events

template <traits::mcc_fsm_log_mount_c MountT>
class MccMountEventBase
{
public:
    typedef MountT mount_t;

    virtual ~MccMountEventBase() = default;

    mount_t& mount() const { return _mount; }

protected:
    MccMountEventBase(mount_t& mount) : _mount(mount) {}

    mount_t& _mount;
};


// transit to IDLE state

template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountEventIDLE : public MccMountEventBase<MountT> {
    typedef MccMountEventBase<MountT> base_t;

    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
    MccMountEventIDLE(MountT& mount) : base_t(mount) {}
};


// transit to initialization state

template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountEventInit : public MccMountEventBase<MountT> {
    typedef MccMountEventBase<MountT> base_t;

    static constexpr std::string_view ID = "MCC-MOUNT-INIT-EVENT";

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


// transit to error state

template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountEventError : public MccMountEventBase<MountT> {
    typedef MccMountEventBase<MountT> base_t;

    static constexpr std::string_view ID = "MCC-MOUNT-ERROR-EVENT";

    using event_data_t = std::error_code;

    event_data_t eventData() const { return _error; }

    MccMountEventError(MountT& mount, const event_data_t& error) : base_t(mount), _error(error) {}

protected:
    event_data_t _error;
};


// transit to slew state

template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountEventSlew : public MccMountEventBase<MountT> {
    typedef MccMountEventBase<MountT> base_t;

    static constexpr std::string_view ID = "MCC-MOUNT-SLEW-EVENT";

    using event_data_t = typename MountT::slew_model_t::slew_point_t;

    event_data_t eventData() const { return _eventData; }

    MccMountEventSlew(MountT& mount, const event_data_t& ev_data) : base_t(mount), _eventData(ev_data) {}

protected:
    event_data_t _eventData;
};


// transit to guiding state

template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountEventGuiding : public MccMountEventBase<MountT> {
    typedef MccMountEventBase<MountT> base_t;

    static constexpr std::string_view ID = "MCC-MOUNT-GUIDING-EVENT";

    using event_data_t = typename MountT::guiding_model_t::guiding_point_t;

    event_data_t eventData() const { return _eventData; }

    MccMountEventGuiding(MountT& mount, const event_data_t& ev_data) : base_t(mount), _eventData(ev_data) {}

protected:
    event_data_t _eventData;
};


// transit to stop state

template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountEventStop : public MccMountEventBase<MountT> {
    typedef MccMountEventBase<MountT> base_t;

    static constexpr std::string_view ID = "MCC-MOUNT-STOP-EVENT";

    enum event_data_t {
        EVENT_STOP_CLIENT,  // software stop (mount client)
        EVENT_STOP_BUTTON   // hardware button
    };

    event_data_t eventData() const { return _reason; }

    std::string_view reason() const
    {
        return _reason == EVENT_STOP_BUTTON   ? "Hardware stop-button"
               : _reason == EVENT_STOP_CLIENT ? "Stop from client"
                                              : "UNKNOWN";
    }

    MccMountEventStop(MountT& mount, event_data_t reason) : base_t(mount), _reason(reason) {}

protected:
    event_data_t _reason;
};


// transit to shutdown state

template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountEventShutdown : public MccMountEventBase<MountT> {
    typedef MccMountEventBase<MountT> base_t;

    static constexpr std::string_view ID = "MCC-MOUNT-SHUTDOWN-EVENT";

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


/*  MOUNT STATE MACHINE STATES  */

template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountStateBase {
    // template <std::derived_from<MccMountEventBase<MountT>> EvT>
    // void exit(this auto&& self, EvT& event)
    // {
    //     using self_t = std::remove_cvref_t<decltype(self)>;

    //     std::forward<decltype(self)>(self).exitImpl(event);

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

    // template <std::derived_from<MccMountEventBase<MountT>> EvT>
    // void enter(this auto&& self, EvT& event)
    // {
    //     using self_t = std::remove_cvref_t<decltype(self)>;

    //     event.mount().logDebug("Enter to '{}' state due to '{}' event ...", self_t::ID, EvT::ID);

    //     std::forward<decltype(self)>(self).enterImpl(event);
    // }

protected:
    // template <std::derived_from<MccMountEventBase<MountT>> EvT>
    // void exitImpl(EvT& event)
    // {
    //     event.mount().logWarn("Call an empty MccMountStateBase::exitImpl method!!! Event type is '{}'", EvT::ID);
    // }

    // template <std::derived_from<MccMountEventBase<MountT>> EvT>
    // void enterImpl(EvT& event)
    // {
    //     event.mount().logWarn("Call an empty MccMountStateBase::enterImpl method!!! Event type is '{}'", EvT::ID);
    // }

    // MccMountStateBase() = default;

    template <std::derived_from<MccMountEventBase<MountT>> 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<MccMountEventBase<MountT>> 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));
    }
};



// just forward declarations
template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountStateIDLE;

template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountStateInit;

template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountStateError;

template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountStateSlew;

template <traits::mcc_fsm_log_mount_c MountT, fsm::traits::fsm_event_c TrEvT = MccMountEventStop<MountT>>
struct MccMountStateStop;

template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountStateGuiding;

template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountStateShutdown;


// stop state

template <traits::mcc_fsm_log_mount_c MountT, fsm::traits::fsm_event_c TrEvT>
struct MccMountStateStop : MccMountStateBase<MountT> {
    static constexpr std::string_view ID = "MCC-MOUNT-STOP-STATE";

    using transition_t = fsm::fsm_transition_table_t<std::pair<MccMountEventIDLE<MountT>, MccMountStateIDLE<MountT>>>;

    // protected:
    void exit(MccMountEventIDLE<MountT>& event)
    {
        // normal exit from the state
        this->exitLog(event);
    }

    // normal behavior (transit to IDLE state after stopping)
    // void enter(MccMountEventStop<MountT>& event)
    // {
    //     this->enterLog(event);

    //     auto mount = event.mount();
    //     mount.stopMount();

    //     // switch to IDLE state
    //     mount.template dispatchEvent<MccMountEventIDLE<MountT>>({mount});
    // }

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

        auto mount = event.mount();

        // should one check current state (slewing, guiding)?
        mount.slewModel.stop();
        mount.guidingModel.stop();
        mount.hardware.stop();

        if constexpr (std::same_as<EvT, MccMountEventStop<MountT>>) {
            mount.logInfo(std::format("Stop reason: {}", event.reason()));

            // normal behavior (transit to IDLE state after stopping)
            mount.template dispatchEvent<MccMountEventIDLE<MountT>>({mount});
        } else {
            mount.logInfo("Stop reason: special state");
            mount.dispatchEvent(event);
        }
    }
};

// initialization state

template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountStateInit : MccMountStateBase<MountT> {
    static constexpr std::string_view ID = "MCC-MOUNT-INIT-STATE";

    using transition_t = fsm::fsm_transition_table_t<std::pair<MccMountEventIDLE<MountT>, MccMountStateIDLE<MountT>>>;

    // protected:
    void exit(MccMountEventIDLE<MountT>& event)
    {
        // normal exit from the state
        this->exitLog(event);
    }

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

        MountT& mount = event.mount();
        mount.initMount();

        // switch to IDLE state
        mount.template dispatchEvent<MccMountEventIDLE<MountT>>({mount});
    }
};


// error state

template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountStateError : MccMountStateBase<MountT> {
    static constexpr std::string_view ID = "MCC-MOUNT-ERROR-STATE";

    using transition_t = fsm::fsm_transition_table_t<
        std::pair<MccMountEventIDLE<MountT>, MccMountStateIDLE<MountT>>,  // ???? after error correction?
        std::pair<MccMountEventInit<MountT>, MccMountStateInit<MountT>>,
        std::pair<MccMountEventError<MountT>, MccMountStateError<MountT>>,
        std::pair<MccMountEventSlew<MountT>, MccMountStateError<MountT>>,
        std::pair<MccMountEventGuiding<MountT>, MccMountStateError<MountT>>,
        std::pair<MccMountEventStop<MountT>, MccMountStateError<MountT>>,
        std::pair<MccMountEventShutdown<MountT>, MccMountStateShutdown<MountT>>>;

    // protected:
    template <std::derived_from<MccMountEventBase<MountT>> EvT>
    void exit(EvT& event)
    {
        this->exitLog(event);

        event.mount().logWarn(std::format(
            "The mount is in the error state!!! One must correct it before transit to any states! Event type is '{}'",
            EvT::ID));
    }

    void exit(MccMountEventIDLE<MountT>& event)
    {
        this->exitLog(event);

        event.mount().logWarn("Suppose the error was corrected!");
    }

    void exit(MccMountEventInit<MountT>& event)
    {
        // normal exit from the state
        this->exitLog(event);
    }

    void enter(MccMountEventError<MountT>& event)
    {
        this->enterLog(event);

        auto err = event.eventData();

        event.mount().logError(std::format("The mount is in the error state: code = {}, category = {}, message = '{}'",
                                           err.value(), err.category().name(), err.message()));
    }
    // template <std::derived_from<MccMountEventBase<MountT>> EvT>
    // void enter(EvT& event)
    // {
    //     this->enterLog(event);

    //     auto err = event.eventData();

    //     event.mount().logError("The mount is in the error state: code = {}, category = {}, message = '{}'",
    //     err.value(),
    //                            err.category().name(), err.message());
    // }
};


// IDLE state

template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountStateIDLE : MccMountStateBase<MountT> {
    static constexpr std::string_view ID = "MCC-MOUNT-IDLE-STATE";

    using transition_t =
        fsm::fsm_transition_table_t<std::pair<MccMountEventInit<MountT>, MccMountStateInit<MountT>>,
                                    std::pair<MccMountEventError<MountT>, MccMountStateError<MountT>>,
                                    std::pair<MccMountEventSlew<MountT>, MccMountStateSlew<MountT>>,
                                    std::pair<MccMountEventGuiding<MountT>, MccMountStateGuiding<MountT>>,
                                    std::pair<MccMountEventStop<MountT>, MccMountStateIDLE<MountT>>,
                                    std::pair<MccMountEventShutdown<MountT>, MccMountStateShutdown<MountT>>>;

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

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


// shutdown state

template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountStateShutdown : MccMountStateBase<MountT> {
    static constexpr std::string_view ID = "MCC-MOUNT-SHUTDOWN-STATE";

    // only initialization
    using transition_t = fsm::fsm_transition_table_t<std::pair<MccMountEventInit<MountT>, MccMountStateInit<MountT>>>;

    // protected:
    void exit(MccMountEventInit<MountT>& event)
    {
        // normal exit from the state
        this->exitLog(event);
    }

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

        event.mount().shutdownMount();
    }
};


// slew state
// WARNING: It must be a friend to 'MountT' class if it inherits it base class mount_controls_t
//          as protected or private!!!
template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountStateSlew : MccMountStateBase<MountT> {
    static constexpr std::string_view ID = "MCC-MOUNT-SLEW-STATE";

    // only initialization
    using transition_t =
        fsm::fsm_transition_table_t<std::pair<MccMountEventInit<MountT>, MccMountStateInit<MountT>>,
                                    std::pair<MccMountEventError<MountT>, MccMountStateStop<MountT>>,
                                    // std::pair<MccMountEventSlew<MountT>, MccMountStateSlew<MountT>>,
                                    std::pair<MccMountEventGuiding<MountT>, MccMountStateStop<MountT>>,
                                    std::pair<MccMountEventStop<MountT>, MccMountStateStop<MountT>>,
                                    std::pair<MccMountEventShutdown<MountT>, MccMountStateStop<MountT>>>;

    // protected:
    template <std::derived_from<MccMountEventBase<MountT>> EvT>
    void exit(EvT& event)
    {
        this->exitLog(event);
    }

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

        auto slew_err = event.mount().slewModel.slew(event.eventData());
        if (slew_err) {
            if constexpr (std::same_as<decltype(slew_err), std::error_code>) {
                event.mount().dispatchEvent(MccMountEventError<MountT>{event.mount(), slew_err});
            } else {
                // ...
            }
            return;
        }

        // switch to IDLE state
        event.mount().template dispatchEvent<MccMountEventIDLE<MountT>>({event.mount()});
    }
};



// guiding state

template <traits::mcc_fsm_log_mount_c MountT>
struct MccMountStateGuiding : MccMountStateBase<MountT> {
    static constexpr std::string_view ID = "MCC-MOUNT-GUIDING-STATE";

    // only initialization
    using transition_t =
        fsm::fsm_transition_table_t<std::pair<MccMountEventInit<MountT>, MccMountStateInit<MountT>>,
                                    std::pair<MccMountEventError<MountT>, MccMountStateStop<MountT>>,
                                    // std::pair<MccMountEventSlew<MountT>, MccMountStateSlew<MountT>>,
                                    std::pair<MccMountEventGuiding<MountT>, MccMountStateStop<MountT>>,
                                    std::pair<MccMountEventStop<MountT>, MccMountStateStop<MountT>>,
                                    std::pair<MccMountEventShutdown<MountT>, MccMountStateStop<MountT>>>;

    // protected:
    template <std::derived_from<MccMountEventBase<MountT>> EvT>
    void exit(EvT& event)
    {
        this->exitLog(event);
    }

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

        auto err = event.mount().guidingModel.guiding(event.eventData());
        if (err) {
            if constexpr (std::same_as<decltype(err), std::error_code>) {
                event.mount().dispatchEvent(MccMountEventError<MountT>{event.mount(), err});
            } else {
                // ...
            }
        }

        // switch to IDLE state
        event.mount().template dispatchEvent<MccMountEventIDLE<MountT>>({event.mount()});
    }
};

}  // namespace mcc