#ifndef SOPHIAR2_SOPHIAR_MANAGER_H
#define SOPHIAR2_SOPHIAR_MANAGER_H

#include "utility/tiny_signal.hpp"
#include "utility/signal_muxer.hpp"
#include "utility/slot_demuxer.hpp"

#include <boost/asio/awaitable.hpp>

#include <fmt/format.h>

#include <nlohmann/json.hpp>

#include <cassert>
#include <exception>
#include <memory>
#include <string>
#include <type_traits>

namespace sophiar {

    class sophiar_obj;

    class sophiar_manager {
    public:

        using obj_factory_func_type = sophiar_obj *(*)();

        void build_from_config(const nlohmann::json &config);

        boost::asio::awaitable<bool> switch_mode(const std::string &mode_name);

        std::string get_object_name(sophiar_obj *obj) const;

        void notify_object_stop(sophiar_obj *obj);

        template<typename Derived>
        void register_object_type(const std::string &type_name) {
            static_assert(std::is_convertible_v<decltype(Derived::new_instance()), sophiar_obj *>);
            register_object_type_impl(type_name, &Derived::new_instance);
        }

        template<typename ...Args>
        void register_signal(sophiar_obj *obj,
                             const std::string &signal_name,
                             tiny_signal<Args...> &signal) {
            tiny_signal_base *base_ptr = &signal;
            register_signal_impl(obj, signal_name, base_ptr);
        }

        // 将套用 slot_demuxer
        template<typename ...Args>
        void register_slot(sophiar_obj *obj,
                           const std::string &slot_name,
                           typename tiny_signal<Args...>::slot_type &slot) {
            tiny_slot_base *slot_base = &slot;
            slot_demuxer_base *demuxer_base = new slot_demuxer<Args...>(slot);
            register_slot_impl(obj, slot_name, slot_base, demuxer_base);
        }

        sophiar_manager();

        ~sophiar_manager();

    private:

        struct impl;
        std::unique_ptr<impl> pimpl;

        void register_object_type_impl(const std::string &type_name, obj_factory_func_type func);

        // 记录 signal 的归属信息
        void register_signal_impl(sophiar_obj *obj,
                                  const std::string &signal_name,
                                  tiny_signal_base *signal_base);

        // 记录 slot 的归属信息
        void register_slot_impl(sophiar_obj *obj,
                                const std::string &slot_name,
                                tiny_slot_base *slot_base,
                                slot_demuxer_base *demuxer_base);

    };

    extern sophiar_manager global_sophiar_manager;

#define REGISTER_TYPE(DerivedT) \
    global_sophiar_manager.register_object_type<DerivedT>(#DerivedT)

}

#endif //SOPHIAR2_SOPHIAR_MANAGER_H