#pragma once

#include <map>
#include <list>
#include <set>
#include <initializer_list>
#include "task.hpp"
#include "types.hpp"
#include "object.hpp"
#include <functional>
#include <memory>
#include "priority.hpp"
#include "labelled.hpp"

namespace flat::core
{
    class signal : virtual public labelled, virtual public prioritized
    {
    
    public:

        struct package
        {
            package(void *data) : data(data) {}

            template<class T>
            T * get() {

                return reinterpret_cast<T*>(data);
            }

            void * data;
        };
    
        object *m_sender;
        package m_package;
    
        signal(object * sender, 
               const std::string& id = "", 
               void * data = 0,
               priority_t prior = priority_t::none);
    };
        
    /* Listener class */
    class listener
    {
    public:

        using callback = std::function<void(const object*, signal::package)>;
        using ptr = std::shared_ptr<listener>;

        listener(callback m_callback, const std::initializer_list<std::string>& filters = {});
        ~listener();

        void add_filter(const std::string&);
        void remove_filter(const std::string&);

        bool connect(const std::string&);
        bool disconnect(const std::string&);

        void invoke(const signal&);

        /* Allow to safely bind a functor */
        template<typename R, typename T>
        static ptr create(  R T::*mf,
                            T& obj,
                            const std::initializer_list<std::string>& filters = {}) {
            return std::make_shared<listener>(std::bind(mf, obj), filters);
        }

    private:

        callback m_callback;

        std::list<std::string> m_filters;
    
        bool check_in_filters(const std::string&) const;
    };

    /* Channel class */
    class channel : virtual public labelled, public std::enable_shared_from_this<channel>
    {
    private:
        /* Post processing signal stacking */
        queue<signal> m_stack;
    
        /* Listeners list */
        std::list<std::weak_ptr<listener>> m_listeners;
    
        /* Synchronous task checking for signals */
        task::ptr m_checker;
        
        /* Channel mapping */
        static std::map<std::string, std::weak_ptr<channel>> m_channels;

        bool m_mapped;
     
    public:

        using ptr = std::shared_ptr<channel>;
    
        channel(const std::string& id = "");
        ~channel();

        void start(priority_t task_priority = priority_t::none);
        bool map();
    
        void emit(const signal&);

        bool connect(listener::ptr l);
        void disconnect(listener::ptr l);

        bool connect(listener* l);
        void disconnect(listener* l);

        listener::ptr connect(listener::callback f,
            const std::initializer_list<std::string>& filters = {});

        template<typename R, typename T>
        inline listener::ptr connect(R T::*mf, T* obj,
            const std::initializer_list<std::string>& filters = {})
        {
            using namespace std::placeholders;
            return connect(std::bind(mf, obj, _1, _2), filters);
        }
       
        static ptr find(const std::string&); 

        static ptr create(const std::string& id, priority_t prior = priority_t::none);
    
        void check_and_call();
    };
}