// Written by Alexander Nasonov alnsn@yandex.ru

#include <boost/mpl/arg.hpp>
#include <boost/mpl/size.hpp>
#include <boost/mpl/find.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/for_each.hpp>
#include <boost/mpl/distance.hpp>
#include <boost/mpl/begin_end.hpp>

#include <boost/ref.hpp>
#include <boost/variant/get.hpp>
#include <boost/variant/variant.hpp>

#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/add_pointer.hpp>

#include <iostream>

template<class Fsm, class Event>
struct add_transition
{
    typedef void (*transition_fn)(Fsm&, Event);

    transition_fn* m_transitions;

    add_transition(transition_fn* transitions)
        : m_transitions(transitions)
    {}

    template<class State>
    void operator()(State*) const
    {
        typedef typename Fsm::states states;
        typedef typename boost::mpl::begin<states>::type begin;
        typedef typename boost::mpl::end<states>::type end;
        typedef typename boost::mpl::find<states,State>::type iter;
        typedef typename boost::mpl::distance<begin,iter>::type index;

        BOOST_STATIC_ASSERT(( !boost::is_same<iter,end>::value ));

        m_transitions[index::value] = &add_transition::do_transition<State>;
    }

    template<class State>
    static void do_transition(Fsm& fsm, Event event)
    {
        fsm.m_states = fsm(boost::get<State>(fsm.m_states), event);
    }
};

template<class Fsm, class Event>
struct fsm_dispatcher
{
    typedef typename Fsm::states states;
    typedef typename boost::mpl::size<states>::type state_count;

    typedef void (*transition_fn)(Fsm&, Event);

    transition_fn m_transitions[state_count::value];

    fsm_dispatcher()
    {
        using boost::mpl::_1;
        add_transition<Fsm,Event> adder(m_transitions);
        boost::mpl::for_each<states, boost::add_pointer<_1> >(adder);
    }

    void operator()(Fsm& fsm, Event event) const
    {
        m_transitions[fsm.m_states.which()](fsm, event);
    }
};

struct Active {};
struct Stopped : Active {};
struct Running : Active {};

struct EvStartStop {};
struct EvReset {};

struct Fsm
{
    typedef boost::mpl::vector<Stopped,Running> states;
    typedef boost::make_variant_over<states>::type state_variant;

    state_variant m_states;

    template<class InitialState>
    Fsm(InitialState state) : m_states(state) {}

    Stopped operator()( Running, EvStartStop )
    {
        std::cout << "Running --> (EvStartStop) --> Stopped\n";
        return Stopped();
    }

    Running operator()( Stopped, EvStartStop )
    {
        std::cout << "Stopped --> (EvStartStop) --> Running\n";
        return Running();
    }

    Stopped operator()( Active, EvReset )
    {
        std::cout << "Active --> (EvReset) --> Stopped\n";
        return Stopped();
    }

    template<class Event>
    void process_event(Event event)
    {
        static fsm_dispatcher<Fsm,Event> d;
        d(*this, event);
    }
};

int main()
{
    Stopped initial;
    EvReset evReset;
    EvStartStop evStartStop;

    Fsm fsm(initial);

    fsm.process_event(evStartStop);
    fsm.process_event(evReset);

    fsm.process_event(evStartStop);
    fsm.process_event(evStartStop);
    fsm.process_event(evReset);
}