GenericEventProxy.h

#pragma once

#include "ICallback.h"
#include "IEvent.h"
#include "IGenericEventProvider.h"

#include <type_traits>
#include <unordered_map>

namespace Eegeo
{
    namespace Helpers
    {
        template <typename TEvent>
        class GenericEventProxy : public TEvent::CallbackType, public IGenericEventProvider<TEvent, typename std::remove_const<typename TEvent::Param0>::type>
        {
        public:
            using typename IGenericEventProvider<TEvent, typename std::remove_const<typename TEvent::Param0>::type>::KeyType;
            using ParamType = typename TEvent::Param0;

            virtual TEvent& GetEvent(const typename GenericEventProxy::KeyType& key) override
            {
                auto itr = m_eventMap.find(key);
                if (itr == m_eventMap.end())
                {
                    itr = m_eventMap.emplace(std::piecewise_construct, std::forward_as_tuple(key), std::forward_as_tuple(*this, key)).first;
                }
                return itr->second;
            }

            virtual void operator()(ParamType& key) const override
            {
                auto itr = m_eventMap.find(key);
                if (itr != m_eventMap.end())
                {
                    itr->second.Raise(key);
                }
            }

        private:
            // For now, there's no TEvent2, so we don't need to deal with picking the right class.
            // Really, events should be variadic templates with perfect forwarding.
            struct  ConcreteEvent : public TEvent1<TEvent>
            {
                ConcreteEvent(GenericEventProxy<TEvent>& parent, const KeyType& key)
                    : parent(parent)
                    , key(key)
                {}

                void Unregister(typename TEvent::CallbackType& callback) override
                {
                    TEvent1<TEvent>::Unregister(callback);
                    if (this->m_callbacks.empty())
                    {
                        parent.m_eventMap.erase(key);
                    }
                }

                GenericEventProxy<TEvent>& parent;
                KeyType key;
            };

            std::unordered_map<typename GenericEventProxy::KeyType, ConcreteEvent> m_eventMap;
        };
    }
}