// Copyright 2010 Christophe Henry
// henry UNDERSCORE christophe AT hotmail DOT com
// This is an extended version of the state machine available in the boost::mpl library
// Distributed under the same license as the original.
// Copyright for the original version:
// Copyright 2005 David Abrahams and Aleksey Gurtovoy. Distributed
// under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

#include <vector>
#include <set>
#include <string>
#include <iostream>
#define FUSION_MAX_VECTOR_SIZE 20

#include "boost/mpl/vector/vector50.hpp"
#include <boost/msm/back/state_machine.hpp>
#include <boost/msm/front/state_machine_def.hpp>

#include "Events.hpp"
#include "PlayingMode.hpp"
#include "MenuMode.hpp"

using namespace std;
namespace msm = boost::msm;

namespace  // Concrete FSM implementation
{
    struct iPod_;
    typedef msm::back::state_machine<iPod_, 
        ::boost::msm::back::favor_compile_time> iPod;

    // Concrete FSM implementation 
    struct iPod_ : public msm::front::state_machine_def<iPod_>
    {
        // The list of FSM states
        struct NotHolding : public msm::front::state<>
        {
            template <class Event,class FSM>
            void on_entry(Event const&,FSM& ) {std::cout << "starting: NotHolding" << std::endl;}
            template <class Event,class FSM>
            void on_exit(Event const&,FSM& ) {std::cout << "finishing: NotHolding" << std::endl;}
        };
        struct Holding : public msm::front::interrupt_state<NoHold>
        {
            template <class Event,class FSM>
            void on_entry(Event const&,FSM& ) {std::cout << "starting: Holding" << std::endl;}
            template <class Event,class FSM>
            void on_exit(Event const&,FSM& ) {std::cout << "finishing: Holding" << std::endl;}
        };
        struct NotPlaying : public msm::front::state<>
        {
            template <class Event,class FSM>
            void on_entry(Event const&,FSM& ) {std::cout << "starting: NotPlaying" << std::endl;}
            template <class Event,class FSM>
            void on_exit(Event const&,FSM& ) {std::cout << "finishing: NotPlaying" << std::endl;}
        };
        struct NoMenuMode : public msm::front::state<>
        {
            template <class Event,class FSM>
            void on_entry(Event const&,FSM& ) {std::cout << "starting: NoMenuMode" << std::endl;}
            template <class Event,class FSM>
            void on_exit(Event const&,FSM& ) {std::cout << "finishing: NoMenuMode" << std::endl;}
        };
        struct NoOnOffButton : public msm::front::state<>
        {
            template <class Event,class FSM>
            void on_entry(Event const&,FSM& ) {std::cout << "starting: NoOnOffButton" << std::endl;}
            template <class Event,class FSM>
            void on_exit(Event const&,FSM& ) {std::cout << "finishing: NoOnOffButton" << std::endl;}
        };
        struct OffDown : public msm::front::state<>
        {
            template <class Event,class FSM>
            void on_entry(Event const&,FSM& ) {std::cout << "starting: OffDown, start timer" << std::endl;}
            template <class Event,class FSM>
            void on_exit(Event const&,FSM& ) {std::cout << "finishing: OffDown, end timer" << std::endl;}
        };
        struct PlayerOff : public msm::front::state<>
        {
            template <class Event,class FSM>
            void on_entry(Event const&,FSM& ) {std::cout << "starting: PlayerOff" << std::endl;}
            template <class Event,class FSM>
            void on_exit(Event const&,FSM& ) {std::cout << "finishing: PlayerOff" << std::endl;}
        };
        struct CheckMiddleButton : public msm::front::state<>
        {
            template <class Event,class FSM>
            void on_entry(Event const&,FSM& ) {std::cout << "starting: CheckMiddleButton" << std::endl;}
            template <class Event,class FSM>
            void on_exit(Event const&,FSM& ) {std::cout << "finishing: CheckMiddleButton" << std::endl;}
        };      

        // the initial state of the player SM. Must be defined
        typedef mpl::vector5<NotHolding,NotPlaying,NoMenuMode,NoOnOffButton,CheckMiddleButton> 
                                    initial_state;
        // transition actions
        void send_ActivateMenu(EndPlay const&)
        {
            std::cout << "leaving Playing" << std::endl;
            // we need to activate the menu and simulate its button
            (static_cast<iPod*>(this))->process_event(MenuButton());
        }
        void send_StartSong(CloseMenu const&)
        {
            // we suppose the 5th song was selected
           (static_cast<iPod*>(this))->process_event(StartSong(5));
        }
        void send_PlayPause(SouthReleased const&)
        {
            // action using the message queue to generate another event
            (static_cast<iPod*>(this))->process_event(PlayPause());
        }
        void send_Off(OnOffTimer const&)
        {
            std::cout << "turning player off" << std::endl;
            (static_cast<iPod*>(this))->process_event(Off());
        }
        void send_PlayingMiddleButton(MiddleButton const&)
        {
            (static_cast<iPod*>(this))->process_event(PlayingMiddleButton());
        }
        void send_MenuMiddleButton(MiddleButton const&)
        {
            (static_cast<iPod*>(this))->process_event(MenuMiddleButton());
        }
        // guard conditions
        bool is_menu(MiddleButton const&)
        {
            return (static_cast<iPod*>(this))->is_flag_active<MenuActive>();
        }
        bool is_no_menu(MiddleButton const& evt)
        {
            return !is_menu(evt);
        }
        template <class EVENT>
        void switch_on(EVENT const&)
        {
            std::cout << "turning player on" << std::endl;
        }
        typedef iPod_ fsm; // makes transition table cleaner

        // Transition table for player
        struct transition_table : mpl::vector<
        //     Start               Event           Next                Action                           Guard
        //    +-------------------+---------------+-------------------+--------------------------------+----------------------+
        _row < NotHolding         , Hold          , Holding                                                                   >,
        _row < Holding            , NoHold        , NotHolding                                                                >,
        //    +-------------------+---------------+-------------------+--------------------------------+----------------------+
        _row < NotPlaying         , PlayPause     , PlayingMode                                                               >,
       a_row < PlayingMode::exit_pt<PlayingMode_::
                PlayingExit>       , EndPlay       , NotPlaying        , &fsm::send_ActivateMenu                               >,
        //    +-------------------+---------------+-------------------+--------------------------------+----------------------+
        _row < NoMenuMode         , MenuButton    , MenuMode                                                                  >,
       a_row < MenuMode::exit_pt<MenuMode_::
                MenuExit>          , CloseMenu     , NoMenuMode        , &fsm::send_StartSong                                  >,
        //    +-------------------+---------------+-------------------+--------------------------------+----------------------+
        _row < NoOnOffButton      , SouthPressed  , OffDown                                                                   >,
       a_row < OffDown            , SouthReleased , NoOnOffButton     , &fsm::send_PlayPause                                  >,
       a_row < OffDown            , OnOffTimer    , PlayerOff         , &fsm::send_Off                                        >,
       a_row < PlayerOff          , SouthPressed  , NoOnOffButton     , &fsm::switch_on                                       >,
       a_row < PlayerOff          , NoHold        , NoOnOffButton     , &fsm::switch_on                                       >,
       //     +-------------------+---------------+--------------------+--------------------------------+----------------------+
         row < CheckMiddleButton  , MiddleButton  , CheckMiddleButton , &fsm::send_PlayingMiddleButton  , &fsm::is_menu       >,
         row < CheckMiddleButton  , MiddleButton  , CheckMiddleButton , &fsm::send_MenuMiddleButton     , &fsm::is_no_menu    >
        //    +-------------------+---------------+--------------------+--------------------------------+----------------------+
        > {};
       
        // Replaces the default no-transition response.
        template <class FSM,class Event>
        void no_transition(Event const& e, FSM&,int state)
        {
            std::cout << "no transition from state " << state
                << " on event " << typeid(e).name() << std::endl;
        }
    };
   
    void test()
    {
        iPod sm;
        sm.start();
        // we first press Hold
        std::cout << "pressing hold" << std::endl;
        sm.process_event(Hold());
        // pressing a button is now ignored
        std::cout << "pressing a button" << std::endl;
        sm.process_event(SouthPressed());
        // or even one contained in a submachine
        sm.process_event(EastPressed());
        // no more holding
        std::cout << "no more holding, end interrupt event sent" << std::endl;
        sm.process_event(NoHold());
        std::cout << "pressing South button a short time" << std::endl;
        sm.process_event(SouthPressed());
        // we suppose a short pressing leading to playing a song
        sm.process_event(SouthReleased());
        // we move to the next song
        std::cout << "we move to the next song" << std::endl;
        sm.process_event(NextSong());
        // then back to no song => exit from playing, menu active
        std::cout << "we press twice the West button (simulated)=> end of playing" << std::endl;
        sm.process_event(PreviousSong());
        sm.process_event(PreviousSong());
        // even in menu mode, pressing play will start playing the first song
        std::cout << "pressing play/pause" << std::endl;
        sm.process_event(SouthPressed());
        sm.process_event(SouthReleased());
        // of course pausing must be possible
        std::cout << "pressing play/pause" << std::endl;
        sm.process_event(SouthPressed());
        sm.process_event(SouthReleased());
        std::cout << "pressing play/pause" << std::endl;
        sm.process_event(SouthPressed());
        sm.process_event(SouthReleased());
        // while playing, you can fast forward
        std::cout << "pressing East button a long time" << std::endl;
        sm.process_event(EastPressed());
        // let's suppose the timer just fired
        sm.process_event(ForwardTimer());
        sm.process_event(ForwardTimer());
        // end of fast forwarding
        std::cout << "releasing East button" << std::endl;
        sm.process_event(EastReleased());
        // we now press the middle button to set playing at a given position
        std::cout << "pressing Middle button, fast forwarding disabled" << std::endl;
        sm.process_event(MiddleButton());
        std::cout <<"pressing East button to fast forward" << std::endl;
        sm.process_event(EastPressed());
        // we switch off and on
        std::cout <<"switch off player" << std::endl;
        sm.process_event(SouthPressed());
        sm.process_event(OnOffTimer());
        std::cout <<"switch on player" << std::endl;    
        sm.process_event(SouthPressed());
    }
}

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