#include <iostream>
#include <utility>

#include <boost/fusion/container/map.hpp>
#include <boost/fusion/sequence/intrinsic/at_key.hpp>
#include <boost/fusion/sequence/intrinsic/value_at_key.hpp>
#include <boost/optional.hpp>
#include <boost/signals2.hpp>
#include <boost/utility/in_place_factory.hpp>

//*****************************************************************************
// EventSource mixin
//*****************************************************************************

// event source traits base
template<typename ConcreteEventSource> struct Events;

// event source mixin (using CRTP)
template<typename ConcreteEventSource> class EventSource {
public:
  typedef ::Events<ConcreteEventSource> Events;

private:
  typedef typename Events::EventTable EventTable;

  // helper type generator
  template<typename Event> struct GetType {
    // boost::optional type
    typedef typename boost::fusion::result_of::
      value_at_key<EventTable, Event>::type SignalWrapper;

    // boost::signal type for particular boost::optional type
    typedef typename SignalWrapper::value_type Signal;

    // slot return type for particular boost::signal type
    typedef typename Signal::result_type SignalReturnType;
  };

public:
  // connect event handler
  template<typename Event, typename Handler>
  void Connect(Handler&& handler) {
    GetSignal<Event>()->connect(std::move(handler));
  }

protected:
  // generate nullary signal
  template<typename Event>
  typename GetType<Event>::SignalReturnType FireEvent() {
    return GetSignal<Event>()->operator()();
  }
  // generate unary signal
  template<typename Event, typename Arg1>
  typename GetType<Event>::SignalReturnType FireEvent(Arg1 arg1) {
    return GetSignal<Event>()->operator()(arg1);
  }
  // ... more overloads (MSVC does not support variadic templates)

private:
  // creates signal if not exists, returns reference to it
  template<typename Event>
  typename GetType<Event>::SignalWrapper& GetSignal() {
    auto& signal = boost::fusion::at_key<Event>(signals_);
    if (!signal)
      signal = boost::in_place();
    return signal;
  }

  EventTable signals_;
};

//*****************************************************************************
// Concrete EventSource example
//*****************************************************************************

// concrete event source traits specialization
template<> struct Events<class ConcreteEventSource> {
  struct Show;
  struct Close;
  typedef boost::fusion::map<
    boost::fusion::pair<Show, boost::optional<boost::signals2::signal<void()>>>,
    boost::fusion::pair<Close, boost::optional<boost::signals2::signal<int(int)>>>
    > EventTable;
};

// concrete event source
class ConcreteEventSource: public EventSource<ConcreteEventSource> {
public:
  // event emitters
  void Show() {
    std::cout << "Show signal generated." << std::endl;
    FireEvent<Events::Show>();
  }

  int Close() {
    int foo = 3;
    std::cout << "Close signal generated. foo = " << foo << std::endl;
    int bar = *FireEvent<Events::Close>(foo);
    std::cout << "Close signal processed. bar = " << bar << std::endl;
    return bar;
  }
};

//*****************************************************************************
// Event listener
//*****************************************************************************

class EventListener {
public:
  // event handlers
  void OnShow() {
    std::cout << "OnShow handler called." << std::endl;
  }

  int OnClose(int foo) {
    std::cout << "OnClose handler called. foo = " << foo << std::endl;
    return foo * 2;
  }
};

//*****************************************************************************
// main
//*****************************************************************************

int main() {
  ConcreteEventSource event_source;
  EventListener event_listener;

  // connect event handlers
  event_source.Connect<ConcreteEventSource::Events::Show>([&](){
    event_listener.OnShow();
  });
  event_source.Connect<ConcreteEventSource::Events::Close>([&](int foo){
    return event_listener.OnClose(foo);
  });

  // fire events
  event_source.Show();
  event_source.Close();
}