/*
 * First draft of a Timer implementation to be used in any MSM
 *
 * by Albert Gil <albert.gil@upc.edu>
 */
#include <boost/msm/back/state_machine.hpp>
#include <boost/msm/front/state_machine_def.hpp>

#include <boost/msm/front/functor_row.hpp>   // to use the Row functor
#include <boost/msm/front/euml/operator.hpp> // for And_, Or_, Not_ operators

#include <iostream>


namespace msm   = boost::msm;
namespace mpl   = boost::mpl;
namespace front = boost::msm::front;

using namespace boost::msm::front;
using namespace msm::front::euml; // for And_, Or_, Not_ operators

using namespace std;


/*
 * Helper classes just for a better debugging/log
 */
struct NameVisitor : public std::vector<std::string>{};

struct BaseBaseState //: public boost::msm::front::state<>
{
    // signature of the accept function
    typedef boost::msm::back::args<void, NameVisitor* > accept_sig; // a reference do no work for substates
    // we also want polymorphic states
    virtual ~BaseBaseState() {}
    // default implementation for states who do not need to be visited
    //virtual std::string get_name() const { return "UndefinedStateName"; }
    void accept(NameVisitor* v) const { v->push_back("UndefinedStateName"); }

};

struct BaseState : public boost::msm::front::state<BaseBaseState>
{
    BaseState( const std::string& name = "AState" ) : name(name)      {}
    std::string name;

    template <class Event,class FSM>
    void on_entry(Event const& ,FSM& fsm) { std::cout << "--> " << name << " in state machine " << fsm.name << std::endl; }
    template <class Event,class FSM>
    void on_exit(Event const&,FSM& fsm)   { std::cout << "<-- " << name << " in state machine " << fsm.name << std::endl; }

    void accept(NameVisitor* v) const { v->push_back(name); }
    //std::string get_name() const{ return name; }
};

template<class Derived>
struct BaseStateMachine : public boost::msm::front::state_machine_def<Derived, BaseBaseState>
{
    BaseStateMachine( const std::string& name = "AStateMachine" ) : name(name)            {}
    std::string name;

    void accept(NameVisitor* v) const { v->push_back(name); }
    //std::string get_name() const{ return name; }


    /*
     * To activate deferred events
     */
    typedef int activate_deferred_events;

    template <class Event,class FSM>
    void on_entry(Event const& ,FSM& fsm) { std::cout << "--> " << name << " in state machine " << fsm.name << std::endl; }
    template <class Event,class FSM>
    void on_exit(Event const&,FSM& fsm )  { std::cout << "<-- " << name << " in state machine " << fsm.name << std::endl; }

    template <class FSM,class Event>
    void no_transition(Event const& e, FSM& fsm, int state)
    {
        NameVisitor names;
        fsm.visit_current_states( &names );

        std::cout << "Ignoring event " << e.name();

        std::cout << " in state(s)";
        for(std::size_t ii=0; ii<names.size(); ++ii) std::cout << " " << names[ii];

        std::cout << " while running the state machine " << fsm.name << std::endl;
    }
};


/*
 * The Timer class
 */
bool using_ugly_ptr = false;

struct Timer : public BaseState
{
    int  timer;
    bool paused; // it can be an extra state...

    Timer() : BaseState("Timer")  {}

    /*
     * To be implemented in the machine state to be used.
     * It is necessary because we can not send event from a submachine to the parent machine.
     * (the ugly pointer will be used inside...)
     */
    static
    void global_timer_start( int time );

    /*
     * Action
     */
    template< int Seconds = 5 >
    struct Reset
    {
        static std::string name() { return "Reset";    }

        template <class EVT,class FSM,class SourceState,class TargetState>
        void operator()(EVT const& evt,FSM& fsm,SourceState& src,TargetState& tgt)
        {
            std::cout << "Action Timer::Reset in state " << src.name << " in state machine  " << fsm.name << std::endl;

            if( using_ugly_ptr ) global_timer_start( Seconds );            // it works!!
            else                 fsm.process_event(Timer::Start(Seconds)); // it is not upper-forwarded...
        }
    };

    struct Start
    {
        Start( int time = 5 ) : time(time) {}
        int time;

        static std::string name() { return "Start";    }

        template <class EVT,class FSM, /*class SourceState,*/class TargetState>
        void operator()(EVT const& evt,FSM& fsm,/*SourceState&*/ Timer& src,TargetState& tgt)
        {
            src.timer  = evt.time;
            src.paused = false;

            std::cout << "Action Timer::Start: " << src.timer << " in state machine " << fsm.name << std::endl;
        }
    };

    struct Clock
    {
        static std::string name() { return "Clock";    }

        template <class EVT,class FSM,class SourceState,class TargetState>
        void operator()(EVT const& evt,FSM& fsm,SourceState& src,TargetState& tgt)
        {
            if(!src.paused)
            {
                --src.timer;
                std::cout << "Action Timer::Clock: " << src.timer << " in state machine " << fsm.name << std::endl;
                if( src.timer == 0)
                {
                    src.paused = true;
                    fsm.process_event(TimeOut());
                }
            }
            else
            {
                std::cout << "Action Timer::Clock is paused" << std::endl;
            }
        }
    };

    struct TimeOut { static std::string name() { return "TimeOut";    } };
};

/*
 * Events
 */
struct    Event { static std::string name() { return    "Event";    } };
struct SubEvent { static std::string name() { return "SubEvent";    } };

/*
 * Class to implement the front-end of the state machine
 */
struct MyStateMachine_ : public BaseStateMachine<MyStateMachine_>
{

    MyStateMachine_() : BaseStateMachine<MyStateMachine_>( "MyStateMachine" ) {}

    /*
     * States
     */
    struct State1 : public BaseState{ State1       () : BaseState("State1")       {} };
    struct State2 : public BaseState{ State2       () : BaseState("State2")       {} };

    /*
     * SubMachineSatates
     */
    struct State3_ : public BaseStateMachine<State3_>
    {
        State3_() : BaseStateMachine<State3_>( "State3" ) {}

        /*
         * States
         */
        struct SubState1 : public BaseState{ SubState1       () : BaseState("SubState1")       {} };
        struct SubState2 : public BaseState{ SubState2       () : BaseState("SubState2")       {} };

        /*
         * The initial state (must be defined)
         */
        typedef mpl::vector<SubState1> initial_state;

        struct transition_table : mpl::vector<
            //    SourceState   Event         TargetSate   Action                Guard
            //    +-----------+-------------+------------+---------------------+----------------------+
            Row < SubState1   , SubEvent    , SubState2  , Timer::Reset<>                             >,
            Row < SubState2   , SubEvent    , SubState1  , Timer::Reset<>                             >
            //    +-----------+-------------+------------+---------------------+----------------------+
        > {};
    };

    /*
     * Defining the back-end (the real) of the MenuMode state machine
     */
    typedef msm::back::state_machine<State3_, msm::back::AlwaysHistory > State3;

    /*
     * The initial state (must be defined)
     */
    typedef boost::mpl::vector<State1, Timer> initial_state;

    struct transition_table : mpl::vector<
        //    SourceState    Event            TargetSate     Action                Guard
        //  +--------------+----------------+--------------+---------------------+----------------------+
        Row < State1       , Event          , State2       , Timer::Reset<>                             >,
        Row < State2       , Event          , State3       , Timer::Reset<>                             >,
        Row < State2       , Timer::TimeOut , State1                                                    >,
        Row < State3       , Timer::TimeOut , State1                                                    >,
        //  +--------------+----------------+------------------------------------+----------------------+
        Row < Timer        , Timer::Start   , none         , Timer::Start                               >,
        Row < Timer        , Timer::Clock   , none         , Timer::Clock                               >
    > {};
};

/*
 * Defining the back-end (the real) of the MenuMode state machine
 */
typedef msm::back::state_machine<MyStateMachine_, msm::back::AlwaysHistory > MyStateMachine;

MyStateMachine* gfsm;
void Timer::global_timer_start( int time )
{
    gfsm->process_event(Timer::Start(time));
}

void test()
{
    MyStateMachine sm;

    //using_ugly_ptr = true; // uncommenting this line makes the Timer work
    gfsm = &sm;            // initializing the "ugly" pointer

    sm.start();
    sm.process_event(Event());        // tr. to State2 (Timer 5)

    // lets imagine there's no event for a while...
    sm.process_event(Timer::Clock()); // tr. to State2 (Timer 4)
    sm.process_event(Timer::Clock()); // tr. to State2 (Timer 3)
    sm.process_event(Timer::Clock()); // tr. to State2 (Timer 2)
    sm.process_event(Timer::Clock()); // tr. to State2 (Timer 1)
    sm.process_event(Timer::Clock()); // tr. to State1 (Timer Paused)
    sm.process_event(Timer::Clock()); // (Timer Paused)

    // and now events normally...
    sm.process_event(Event());        // tr. to State2         (Timer 5)
    sm.process_event(Timer::Clock()); // tr. to State2         (Timer 4)
    sm.process_event(Event());        // to State3 / SubState1 (Timer 5)
    sm.process_event(Timer::Clock()); // to State3 / SubState1 (Timer 4)

    sm.process_event(SubEvent());     // to State3 / SubState2 (Timer is not reset!!)
    sm.process_event(Timer::Clock()); // to State3 / SubState2 (Timer 3!!)
    sm.process_event(SubEvent());     // to State3 / SubState1 (Timer is not reset!!)
    sm.process_event(Timer::Clock()); // to State3 / SubState2 (Timer 2!!)
    sm.process_event(Timer::Clock()); // to State3 / SubState2 (Timer 1!!)
    sm.process_event(Timer::Clock()); // to State1  (Timer Paused!!)

    sm.process_event(Timer::Clock()); // (Timer Paused!!)
}

int main()
{
test();
return 0;
}