/*******************************************************************************
 * Copyright (c) 2016 CEA LIST.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *  Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr
 *   - Initial API and implementation
 ******************************************************************************/
#ifndef EXECUTIONQUEUE_H_
#define EXECUTIONQUEUE_H_

#include <fam/api/AbstractProcessorUnit.h>
#include <sew/SymbexEventManager.h>

#include "WaitingStrategy.h"

#include <collection/Typedef.h>

#include <fml/runtime/ExecutionContext.h>

#include <stack>


namespace sep
{

class AbstractProcessorUnit;
class ExecutionContext;
class SymbexControllerUnitManager;


class ExecutionQueue :
		public AutoRegisteredProcessorUnit< ExecutionQueue >,
		public IHandlerEventDestroyCtx
{

	AVM_DECLARE_CLONABLE_CLASS( ExecutionQueue )

	/**
	 * MAIN PROCESSOR FACTORY
	 * for automatic registration in the processor repository
	 * the [ [ FULLY ] QUALIFIED ] NAME ID
	 */
	AVM_INJECT_AUTO_REGISTER_QUALIFIED_ID_KEY_3(
			"symbex.queue",
			"avm::processor.EXECUTION_QUEUE",
			"avm::core.EXECUTION_QUEUE" )
	// end registration


public:
	/**
	 * TYPEDEF
	 */
	typedef avm_uint16_t             ENUM_STRATEGY_T;

	enum
	{
		STRATEGY_UNDEFINED            = 0x0000,

		// Basic Strategy Family
		STRATEGY_BFS                  = 0x0001,

		STRATEGY_DFS                  = 0x0002,

		STRATEGY_RFS                  = 0x0004,
		STRATEGY_XFS                  = 0x0008,

		STRATEGY_BEST                 = 0x0010,
		STRATEGY_FIRST                = 0x0020,
		STRATEGY_LAST                 = 0x0040,

		STRATEGY_ORDER                = 0x0080,

		STRATEGY_FAMILY_BASIC         = STRATEGY_BFS   | STRATEGY_DFS
		                              | STRATEGY_RFS   | STRATEGY_XFS
		                              | STRATEGY_BEST  | STRATEGY_ORDER
		                              | STRATEGY_FIRST | STRATEGY_LAST,

		// for popTo ReadyQueue
		STRATEGY_ALL                  = 0x0100,

		STRATEGY_FAMILY_BASIC_ALL     = STRATEGY_FAMILY_BASIC
		                              | STRATEGY_ALL,


		// Block Strategy
		STRATEGY_BLOCK                = 0x0200,

		// Weight Strategy
		STRATEGY_WEIGHT               = 0x0400,

	};

	/**
	 * DEFAULT QUEUE COUNT
	 */
	static const avm_uint8_t DEFAULT_QUEUE_COUNT = 8;


protected:
	/**
	 * ATTRIBUTES
	 */
	// les contextes qui attendent sagement qu'on les initialise afin
	// qu'ils puissent étre mis dans la waiting!!!!
	// Il n'y a pas de raison qu'on en traite qu'un seul à la fois!!!!!
	ListOfExecutionContext mInitQueue;

	////////////////////////////////////////////////////////////////////////////
	// the waiting queue strategy & behavour
	////////////////////////////////////////////////////////////////////////////
	// les contextes qui attendent sagement qu'on s'intéresse à eux pour passer
	// l'audition conduisant à l'exécution !!!
	WaitingStrategy * mWaitingStrategy;
	std::stack< WaitingStrategy * > mWaitingStrategyStack;

	// les contextes pres pour l'exécution: ils ont réussi l'audition des filtres...
	// Il n'y a pas de raison qu'on en traite qu'un seul à la fois!!!
	ListOfExecutionContext mReadyQueue;

	// les contextes mis en réserve volontairement par un processeur,
	// et pourraient faire l'objet d'une récupération futur....
	ListOfExecutionContext mReserveQueue;

	// les contextes ayant échoué à l'épreuve des filtres,
	// et pourraient faire l'objet d'une épreuve de récupération futur...
	ListOfExecutionContext mFailedQueue;

	// les contextes venant d'etre exécutés
	// Il n'y a pas de raison qu'on en traite qu'un seul à la fois!!!
	ListOfExecutionContext mResultQueue;


	/**
	 * Strategy
	 * DFS | BFS | RFS
	 * BLOCK_??? | WEIGHT_??? | TARGET_FORMULA_???
	 * STRATEGY_ORDER
	 */
	ENUM_STRATEGY_T mStrategy;


public:
	/**
	 * CONSTRUCTOR
	 * Default
	 */
	ExecutionQueue(SymbexControllerUnitManager & aControllerUnitManager,
			WObject * wfParameterObject = NULL)
	: AutoRegisteredProcessorUnit( aControllerUnitManager ,
			wfParameterObject , PRECEDENCE_OF_MAIN_PROCESSOR),
	mInitQueue(),

	mWaitingStrategy( NULL ),
	mWaitingStrategyStack( ),

	mReadyQueue(),

	mReserveQueue(),
	mFailedQueue(),

	mResultQueue(),

	mStrategy( STRATEGY_DFS )
	{
		//!! NOTHING
	}

	/**
	 * DESTRUCTOR
	 */
	virtual ~ExecutionQueue();


	/**
	 * CONFIGURE
	 */
	virtual bool configureImpl();

	void configureWaitingBasicStrategy();

	void configureWaitingBasicStrategyAll();

	void configureWaitingBlockStrategy(
			avm_size_t aBlockHeightPeriod, avm_size_t aBlockWidthPeriod,
			avm_size_t aBlockHeight, avm_size_t aBlockWidth,
			avm_size_t aHeightLimit, avm_size_t aWidthLimit);

	void configureWaitingWeightStrategy(avm_uint8_t maxWeight);
	void configureWaitingWeightStrategyAll(avm_uint8_t maxWeight);


	/**
	 * RECONFIGURATION
	 */
	bool reconfigure(ENUM_STRATEGY_T newStrategy,
			avm_uint8_t queueCount = DEFAULT_QUEUE_COUNT);

	bool reconfigureBlock(ENUM_STRATEGY_T newStrategy,
			avm_size_t aBlockHeightPeriod, avm_size_t aBlockWidthPeriod,
			avm_size_t aBlockHeight, avm_size_t aBlockWidth,
			avm_size_t aHeightLimit, avm_size_t aWidthLimit);


	/**
	 * REPORT TRACE
	 */

	inline virtual void reportSilent(OutStream & os) const
	{
		// SILENT => NOTHING
	}

	inline virtual void reportMinimum(OutStream & os) const
	{
		//!! NOTHING
	}

	virtual void reportDefault(OutStream & os) const;


	/**
	 * GETTER - SETTER
	 * mInitQueue
	 */
	inline void appendInit(ExecutionContext * anEC)
	{
		mInitQueue.append(anEC);
	}

	inline void appendInit(const ListOfExecutionContext & listOfEC)
	{
		mInitQueue.append(listOfEC);
	}

	inline ListOfExecutionContext & getInitQueue()
	{
		return( mInitQueue );
	}

	inline bool hasInit() const
	{
		return( mInitQueue.nonempty() );
	}

	inline void traceInit(OutStream & os)
	{
		traceQueue(os, mInitQueue, "EXECUTION INIT QUEUE");
	}


	/**
	 * GETTER - SETTER
	 * mWaitingStrategy
	 */
	inline WaitingStrategy * getWaitingStrategy()
	{
		return( mWaitingStrategy );
	}

	inline WaitingStrategy & refWaitingStrategy()
	{
		return( *mWaitingStrategy );
	}

	inline bool hasWaitingStrategy() const
	{
		return( mWaitingStrategy != NULL );
	}

	inline void setWaitingStrategy(WaitingStrategy * aWaitingStrategy)
	{
		mWaitingStrategy = aWaitingStrategy;
	}


	/**
	 * GETTER - SETTER
	 * mWaitingStrategy
	 * mWaitingStrategyStack
	 */
	bool pushWaitingStrategy(WaitingStrategy * aWaitingStrategy,
			bool spliceContainedFlag = true);

	bool popWaitingStrategy(bool spliceContainedFlag = true,
			bool destroyCurrentFlag = false);


	/**
	 * hasWork()
	 */
	inline bool hasWork() const
	{
		return( hasWaiting() || hasReady() );
	}

	/**
	 * GETTER - SETTER
	 * mWaitingQueue
	 */

	inline void clearWaiting()
	{
		mWaitingStrategy->clearQueueTable();
	}

	inline void getWaiting(ListOfExecutionContext & alisOfEC)
	{
		mWaitingStrategy->getQueueTable( alisOfEC );
	}

	inline ListOfExecutionContext & getWaitingQueue()
	{
		return( mWaitingStrategy->getQueue() );
	}

	inline ListOfExecutionContext & getWaitingQueueCache()
	{
		return( mWaitingStrategy->getCache() );
	}


	inline bool hasWaiting() const
	{
		return( mWaitingStrategy->hasWaiting() );
	}

	inline bool hasWaitingCache() const
	{
		return( mWaitingStrategy->getCache().nonempty() );
	}


	inline ExecutionContext * topWaiting()
	{
		return( mWaitingStrategy->top() );
	}

	inline ExecutionContext * popWaiting()
	{
		return( mWaitingStrategy->pop() );
	}

	inline void popWaiting2Ready()
	{
		mWaitingStrategy->popTo( mReadyQueue );
	}

	inline void pushWaitingCache(ExecutionContext * anEC)
	{
		mWaitingStrategy->pushCache( anEC );
	}

	inline void spliceWaitingCache(ListOfExecutionContext & listOfEC)
	{
		while( listOfEC.nonempty() )
		{
			mWaitingStrategy->pushCache( listOfEC.pop_first() );
		}
	}

	inline void pushWaiting(ExecutionContext * anEC)
	{
		mWaitingStrategy->push( anEC );
	}

	inline void pushWaiting(const ListOfExecutionContext & listOfEC)
	{
		mWaitingStrategy->push( listOfEC );
	}

	inline void pushInit2Waiting()
	{
		while( mInitQueue.nonempty() )
		{
			mWaitingStrategy->push( mInitQueue.pop_first() );
		}
	}


	inline void pushWaitingChild(const ListOfExecutionContext & childEC)
	{
		mWaitingStrategy->pushChild( childEC );
	}


	inline avm_size_t sizeWaiting()
	{
		return( mWaitingStrategy->sizeWaiting() );
	}


	inline void traceWaiting(OutStream & os)
	{
		mWaitingStrategy->trace(os, "EXECUTION WAITING QUEUE");
	}


	/**
	 * GETTER - SETTER
	 * mReadyQueue
	 */
	inline void appendReady(ExecutionContext * anEC)
	{
		mReadyQueue.append(anEC);
	}

	inline void appendReady(ListOfExecutionContext & listOfEC)
	{
		mReadyQueue.append(listOfEC);
	}

	inline void spliceReady(ListOfExecutionContext & listOfEC)
	{
		mReadyQueue.splice(listOfEC);
	}

	inline void clearReady()
	{
		mReadyQueue.clear();
	}

	inline ListOfExecutionContext & getReadyQueue()
	{
		return( mReadyQueue );
	}

	inline bool hasReady() const
	{
		return( mReadyQueue.nonempty() );
	}

	inline bool hasReadyWork() const
	{
		return( mReadyQueue.nonempty() );
	}


	inline void traceReady(OutStream & os)
	{
		traceQueue(os, mReadyQueue, "EXECUTION READY QUEUE");
	}


	/**
	 * GETTER - SETTER
	 * mReserveQueue
	 */
	inline void appendReserve(ExecutionContext * anEC)
	{
		mReserveQueue.append(anEC);
	}

	inline void appendReserve(ListOfExecutionContext & listOfEC)
	{
		mReserveQueue.append(listOfEC);
	}

	inline void spliceReserve(ListOfExecutionContext & listOfEC)
	{
		mReserveQueue.splice(listOfEC);
	}

	inline ListOfExecutionContext & getReserveQueue()
	{
		return( mReserveQueue );
	}

	inline bool hasReserve() const
	{
		return( mReserveQueue.nonempty() );
	}


	inline void traceReserve(OutStream & os)
	{
		traceQueue(os, mReserveQueue, "EXECUTION LAST CHANCE QUEUE");
	}


	/**
	 * GETTER - SETTER
	 * mFailedQueue
	 */
	inline void appendFailed(ExecutionContext * anEC)
	{
		mFailedQueue.append(anEC);
	}

	inline void appendFailed(ListOfExecutionContext & listOfEC)
	{
		mFailedQueue.append(listOfEC);
	}

	inline void spliceFailed(ListOfExecutionContext & listOfEC)
	{
		mFailedQueue.splice(listOfEC);
	}

	inline ListOfExecutionContext & getFailedQueue()
	{
		return( mFailedQueue );
	}

	inline bool hasFailed() const
	{
		return( mFailedQueue.nonempty() );
	}


	inline void traceFailed(OutStream & os)
	{
		traceQueue(os, mFailedQueue, "EXECUTION FAILED QUEUE");
	}


	/**
	 * GETTER - SETTER
	 * mResultQueue
	 */
	inline void appendResult(ExecutionContext * anEC)
	{
		mResultQueue.append(anEC);
	}

	inline void appendResult(ListOfExecutionContext & listOfEC)
	{
		mResultQueue.append(listOfEC);
	}

	inline void spliceResult(ListOfExecutionContext & listOfEC)
	{
		mResultQueue.splice(listOfEC);
	}

	inline ListOfExecutionContext & getResultQueue()
	{
		return( mResultQueue );
	}

	inline bool hasResult() const
	{
		return( mResultQueue.nonempty() );
	}


	inline void traceResult(OutStream & os)
	{
		traceQueue(os, mResultQueue, "EXECUTION RESULT QUEUE");
	}


	/**
	 * TRACE Queue
	 */
	static void traceQueue(OutStream & os, ListOfExecutionContext & aQueue,
			const std::string & aMessage);


	/**
	 * IHandlerEventDestroyCtx API
	 * Destroy Execution Context
	 */
	inline virtual void handleEventDestroyCtx(ExecutionContext * anEC)
	{
		removeFailed(anEC);
		removeInit(anEC);
		removeWaiting(anEC);
		removeReady(anEC);
		removeReserve(anEC);
		removeResult(anEC);
	}

	inline void removeFailed(ExecutionContext * anEC)
	{
		getFailedQueue().remove(anEC);
	}

	inline void removeInit(ExecutionContext * anEC)
	{
		getInitQueue().remove(anEC);
	}

	inline void removeWaiting(ExecutionContext * anEC)
	{
		mWaitingStrategy->remove(anEC);
	}

	inline void removeReady(ExecutionContext * anEC)
	{
		getReadyQueue().remove(anEC);
	}

	inline void removeReserve(ExecutionContext * anEC)
	{
		getReserveQueue().remove(anEC);
	}

	inline void removeResult(ExecutionContext * anEC)
	{
		getResultQueue().remove(anEC);
	}


	/**
	 * HEURISTIC
	 * BLOCK_DFS strategy
	 */
	ExecutionContext * pop_BLOCK_DFS();
	void push_BLOCK_DFS(ExecutionContext * anEC);
	bool resetWaiting_BLOCK();


	/**
	 * HEURISTIC
	 * BLOCK_BFS strategy
	 */
	ExecutionContext * pop_BLOCK_BFS();
	void push_BLOCK_BFS(ExecutionContext * anEC);


	/**
	 * HEURISTIC
	 * BLOCK_BFS strategy
	 */
	ExecutionContext * pop_BLOCK_XFS();
	void push_BLOCK_XFS(ExecutionContext * anEC);


	/**
	 * HEURISTIC
	 * ORDER strategy
	 */
	ExecutionContext * pop_ORDER();
	void push_ORDER(ExecutionContext * anEC);


	/**
	 * HEURISTIC
	 * TARGET_FORMULA strategy
	 */
	ExecutionContext * pop_TARGET_FORMULA();


	////////////////////////////////////////////////////////////////////////////
	// PROCESSOR REQUEST API
	////////////////////////////////////////////////////////////////////////////

	/**
	 * STOP  | RELEASE
	 * RESET | RESTART | CONTINUE
	 * REQUEUE_WAITING | REQUEUE_RESERVE
	 * HEURISTIC | GOAL_ACHIEVED
	 */
	inline void handleRequestStop()
	{
		clearReady();

		clearWaiting();
	}

	inline void handleRequestRelease()
	{
		//!! NOTHING
	}


	inline void handleRequestReset()
	{
		//!! NOTHING
	}

	inline void handleRequestRestart()
	{
		//!! NOTHING
	}

	inline void handleRequestContinue()
	{
		//!! NOTHING
	}


	inline void handleRequestRequeueWaiting(AbstractProcessorUnit * aRequestor)
	{
		mWaitingStrategy->handleRequestRequeueWaiting(aRequestor);
	}

	inline void handleRequestRequeueReserve(AbstractProcessorUnit * aRequestor)
	{
		mWaitingStrategy->handleRequestRequeueReserve(aRequestor, getReserveQueue());
	}


	/**
	 * Serialization
	 */
	std::string strStrategy() const;

	inline void toStreamWaiting(OutStream & os) const
	{
		mWaitingStrategy->toStream(os);
	}

	virtual void toStream(OutStream & os) const;

	virtual void toStream(const ListOfExecutionContext & aQueue, OutStream & os) const;

};


}

#endif /*EXECUTIONQUEUE_H_*/