//////////////////////////////////////////////////////////////////////////////

// Copyright 2005-2008 Andreas Huber Doenni

// Distributed under the Boost Software License, Version 1.0. (See accompany-

// ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//////////////////////////////////////////////////////////////////////////////

#include <boost/test/test_tools.hpp>

#include <boost/statechart/asynchronous_state_machine.hpp>

#include <boost/statechart/fifo_scheduler.hpp>

#include <boost/statechart/event.hpp>

#include <boost/statechart/simple_state.hpp>

#include <boost/statechart/termination.hpp>

#include <boost/statechart/custom_reaction.hpp>

#include <boost/mpl/list.hpp>

#include <boost/bind.hpp>

#include <boost/ref.hpp>

#include <stdexcept>

namespace sc = boost::statechart;

namespace mpl = boost::mpl;

struct EvCheckCtorArgs : sc::event< EvCheckCtorArgs >

{

  public:

    EvCheckCtorArgs( int expectedArgs ) : expectedArgs_( expectedArgs ) {}

    const int expectedArgs_;

  private:

    // avoids C4512 (assignment operator could not be generated)

    EvCheckCtorArgs & operator=( const EvCheckCtorArgs & );

};

struct EvTerminate : sc::event< EvTerminate > {};

struct EvFail : sc::event< EvFail > {};

struct Initial;

struct FifoSchedulerTest :

  sc::asynchronous_state_machine< FifoSchedulerTest, Initial >

{

  public:

    //////////////////////////////////////////////////////////////////////////

    FifoSchedulerTest( my_context ctx ) :

      my_base( ctx ),

      ctorArgs_( 0 )

    {

    }

    FifoSchedulerTest( my_context ctx, int arg1 ) :

      my_base( ctx ),

      ctorArgs_( arg1 )

    {

    }

    FifoSchedulerTest( my_context ctx, int arg1, int arg2 ) :

      my_base( ctx ),

      ctorArgs_( arg1 * 10 + arg2 )

    {

    }

    FifoSchedulerTest( my_context ctx, int arg1, int arg2, int arg3 ) :

      my_base( ctx ),

      ctorArgs_( ( arg1 * 10 + arg2 ) * 10 + arg3 )

    {

    }

    FifoSchedulerTest(

      my_context ctx,

      int arg1, int arg2, int arg3, int arg4

    ) :

      my_base( ctx ),

      ctorArgs_( ( ( arg1 * 10 + arg2 ) * 10 + arg3 ) * 10 + arg4 )

    {

    }

    FifoSchedulerTest(

      my_context ctx,

      int arg1, int arg2, int arg3, int arg4, int arg5

    ) :

      my_base( ctx ),

      ctorArgs_( ( ( ( arg1 * 10 + arg2 ) * 10 +

        arg3 ) * 10 + arg4 ) * 10 + arg5 )

    {

    }

    FifoSchedulerTest(

      my_context ctx,

      int arg1, int arg2, int arg3, int arg4, int arg5, int arg6

    ) :

      my_base( ctx ),

      ctorArgs_( ( ( ( ( arg1 * 10 + arg2 ) * 10 +

        arg3 ) * 10 + arg4 ) * 10 + arg5 ) * 10 + arg6 )

    {

    }

    int CtorArgs()

    {

      return ctorArgs_;

    }

  private:

    //////////////////////////////////////////////////////////////////////////

    const int ctorArgs_;

};

boost::intrusive_ptr< const sc::event_base > MakeEvent(

  const sc::event_base * pEvent )

{

  return boost::intrusive_ptr< const sc::event_base >( pEvent );

}

struct Initial : sc::simple_state< Initial, FifoSchedulerTest >

{

  typedef mpl::list<

    sc::custom_reaction< EvCheckCtorArgs >,

    sc::termination< EvTerminate >,

    sc::custom_reaction< EvFail >

  > reactions;

  sc::result react( const EvCheckCtorArgs & ev )

  {

    BOOST_REQUIRE( ev.expectedArgs_ == outermost_context().CtorArgs() );

    outermost_context_type & machine = outermost_context();

    machine.my_scheduler().queue_event(

      machine.my_handle(), MakeEvent( new EvTerminate() ) );

    return discard_event();

  }

  sc::result react( const EvFail & )

  {

    BOOST_FAIL( "State machine is unexpectedly still running." );

    return discard_event();

  }

};

struct UnexpectedEventCount : public std::runtime_error

{

  UnexpectedEventCount() : std::runtime_error( "" ) {}

};

void RunScheduler(

  sc::fifo_scheduler<> & scheduler, unsigned long expectedEventCount )

{

  // Workaround: For some reason MSVC has a problem with BOOST_REQUIRE here

  // (C1055: compiler limit: out of keys)

  if ( scheduler() != expectedEventCount )

  {

    throw UnexpectedEventCount();

  }

}

static int refArg1;

static int refArg2;

static int refArg3;

static int refArg4;

static int refArg5;

static int refArg6;

void Check(

  sc::fifo_scheduler<> & scheduler,

  const sc::fifo_scheduler<>::processor_handle & processor,

  int ctorArgs )

{

  refArg1 = 6;

  refArg2 = 5;

  refArg3 = 4;

  refArg4 = 3;

  refArg5 = 2;

  refArg6 = 1;

  // Make sure the processor has been created

  RunScheduler( scheduler, 1UL );

  refArg1 = refArg2 = refArg3 = refArg4 = refArg5 = refArg6 = 0;

  scheduler.initiate_processor( processor );

  // This event triggers the queueing of another event, which itself

  // terminates the machine ...

  scheduler.queue_event(

    processor, MakeEvent( new EvCheckCtorArgs( ctorArgs ) ) );

  // ... that's why 3 instead of two events must have been processed

  RunScheduler( scheduler, 3UL );

  // Since the machine has been terminated, this event will be ignored

  scheduler.queue_event( processor, MakeEvent( new EvFail() ) );

  RunScheduler( scheduler, 1UL );

  // Check that we can reinitiate the machine

  scheduler.initiate_processor( processor );

  scheduler.queue_event(

    processor, MakeEvent( new EvCheckCtorArgs( ctorArgs ) ) );

  RunScheduler( scheduler, 3UL );

  // Check that we are terminated again

  scheduler.queue_event( processor, MakeEvent( new EvFail() ) );

  RunScheduler( scheduler, 1UL );

  scheduler.destroy_processor( processor );

  // The following will simply be ignored because the processor has already

  // be destroyed

  scheduler.initiate_processor( processor );

  scheduler.queue_event(

    processor, MakeEvent( new EvCheckCtorArgs( ctorArgs ) ) );

  RunScheduler( scheduler, 3UL );

}

void SetToTrue( bool & value )

{

  value = true;

}

int test_main( int, char* [] )

{

  try

  {

    sc::fifo_scheduler<> scheduler;

    Check( scheduler, scheduler.create_processor< FifoSchedulerTest >(), 0 );

    Check(

      scheduler, scheduler.create_processor< FifoSchedulerTest >( 1 ), 1 );

    Check(

      scheduler,

      scheduler.create_processor< FifoSchedulerTest >(

        boost::cref( refArg1 ) ),

      6 );

    Check(

      scheduler,

      scheduler.create_processor< FifoSchedulerTest >( 1, 2 ),

      12 );

    Check(

      scheduler,

      scheduler.create_processor< FifoSchedulerTest >(

        boost::cref( refArg1 ), boost::cref( refArg2 ) ),

      65 );

    Check(

      scheduler,

      scheduler.create_processor< FifoSchedulerTest >( 1, 2, 3 ),

      123 );

    Check(

      scheduler,

      scheduler.create_processor< FifoSchedulerTest >(

        boost::cref( refArg1 ), boost::cref( refArg2 ),

        boost::cref( refArg3 ) ),

      654 );

    Check(

      scheduler,

      scheduler.create_processor< FifoSchedulerTest >( 1, 2, 3, 4 ),

      1234 );

    Check(

      scheduler,

      scheduler.create_processor< FifoSchedulerTest >(

        boost::cref( refArg1 ), boost::cref( refArg2 ),

        boost::cref( refArg3 ), boost::cref( refArg4 ) ),

      6543 );

    Check(

      scheduler,

      scheduler.create_processor< FifoSchedulerTest >( 1, 2, 3, 4, 5 ),

      12345 );

    Check(

      scheduler,

      scheduler.create_processor< FifoSchedulerTest >(

        boost::cref( refArg1 ), boost::cref( refArg2 ),

        boost::cref( refArg3 ), boost::cref( refArg4 ),

        boost::cref( refArg5 ) ),

      65432 );

    Check(

      scheduler,

      scheduler.create_processor< FifoSchedulerTest >( 1, 2, 3, 4, 5, 6 ),

      123456 );

    Check(

      scheduler,

      scheduler.create_processor< FifoSchedulerTest >(

        boost::cref( refArg1 ), boost::cref( refArg2 ),

        boost::cref( refArg3 ), boost::cref( refArg4 ),

        boost::cref( refArg5 ), boost::cref( refArg6 ) ),

      654321 );

    RunScheduler( scheduler, 0UL );

    bool workItem1Processed = false;

    scheduler.queue_work_item(

      boost::bind( &SetToTrue, boost::ref( workItem1Processed ) ) );

    RunScheduler( scheduler, 1UL );

    BOOST_REQUIRE( workItem1Processed );

    scheduler.terminate();

    RunScheduler( scheduler, 1UL );

    BOOST_REQUIRE( scheduler.terminated() );

    RunScheduler( scheduler, 0UL );

    bool workItem2Processed = false;

    scheduler.queue_work_item(

      boost::bind( &SetToTrue, boost::ref( workItem2Processed ) ) );

    // After being terminated, a call to operator() must not process any more

    // events

    RunScheduler( scheduler, 0UL );

    BOOST_REQUIRE( !workItem2Processed );

  }

  catch ( const UnexpectedEventCount & )

  {

    BOOST_FAIL( "Unexpected event count." );

  }

  return 0;

}