/*******************************************************************************
 * 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
 *
 * Created on: 1 déc. 2011
 *
 * Contributors:
 *  Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr
 *   - Initial API and implementation
 ******************************************************************************/

#ifndef COMMON_RUNNABLEELEMENT_H_
#define COMMON_RUNNABLEELEMENT_H_

#include <common/NamedElement.h>
#include <common/SerializerFeature.h>


namespace sep
{


enum ExecCmdStatus
{
	EXEC_CMD_UNKNOWN,
	EXEC_CMD_OK,
	EXEC_CMD_EXIT,
	EXEC_CMD_FAILED
};


class WObject;


class RunnableElement :
		public NamedElement,
		public SerializerFeature,
		AVM_INJECT_INSTANCE_COUNTER_CLASS( RunnableElement )
{


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

	enum {
		RUNNABLE_UNDEFINED_STATE       = 0x0000,


		RUNNABLE_CONFIGURED_STATE      = 0x0001,

		RUNNABLE_INITIALIZED_STATE     = 0x0002,

		RUNNABLE_STARTED_STATE         = 0x0004,

		RUNNABLE_RELEASED_STATE        = 0x0008,


		RUNNABLE_READY_STATE           = 0x0010,

		RUNNABLE_STANDBY_STATE         = 0x0020,


		RUNNABLE_IDLE_STATE            = 0x0040,

		RUNNABLE_RUNNING_STATE         = 0x0080,


		RUNNABLE_WAITING_STATE         = 0x0100,

		RUNNABLE_SUSPENDED_STATE       = 0x0200,


		RUNNABLE_STOPPED_STATE         = 0x0400,

		RUNNABLE_EXITED_STATE          = 0x0800,

		// ALIASES
		RUNNABLE_STATIC_READY_STATE    = RUNNABLE_INITIALIZED_STATE
		                               | RUNNABLE_STARTED_STATE
		                               | RUNNABLE_READY_STATE,

		RUNNABLE_DYNAMIC_READY_STATE   = RUNNABLE_IDLE_STATE
		                               | RUNNABLE_RUNNING_STATE,

		RUNNABLE_ACTIVE_STATE          = RUNNABLE_STARTED_STATE
		                               | RUNNABLE_READY_STATE
		                               | RUNNABLE_IDLE_STATE
		                               | RUNNABLE_RUNNING_STATE
		                               | RUNNABLE_WAITING_STATE
		                               | RUNNABLE_SUSPENDED_STATE,

		RUNNABLE_INACTIVE_STATE        = RUNNABLE_STANDBY_STATE
		                               | RUNNABLE_STOPPED_STATE
		                               | RUNNABLE_RELEASED_STATE
		                               | RUNNABLE_EXITED_STATE
	};


	struct AutoRunningIdleSwitcher
	{
		RunnableElement & mRunnableElement;

		AutoRunningIdleSwitcher(RunnableElement & aRunnableElement)
		:mRunnableElement( aRunnableElement )
		{
			mRunnableElement.setLifecycleRunning();
		}

		~AutoRunningIdleSwitcher()
		{
			mRunnableElement.setLifecycleIdle();
		}
	};


protected:
	/**
	 * ATTRIBUTE
	 */
	WObject * mParameterWObject;

	//Indicateur du bon déroulement de la procédure << configure() >>
	bool mConfigFlag;

	//Indicateur pour afficher un rapport final
	bool mReportPrintFlag;

	lifecycle_status_t mStartupLifecycleStatus;

	lifecycle_status_t mStaticLifecycleStatus;

	lifecycle_status_t mDynamicLifecycleStatus;


public:
	/**
	 * CONSTRUCTOR
	 * Default
	 */
	RunnableElement(WObject * wfParameterObject);

	RunnableElement(class_kind_t aClassKind, WObject * wfParameterObject);

	/**
	 * CONSTRUCTOR
	 * Copy
	 * Abstract pur
	 */
	RunnableElement(const RunnableElement & aRunnable)
	: NamedElement( aRunnable ),
	SerializerFeature( aRunnable ),
	mParameterWObject( aRunnable.mParameterWObject ),
	mConfigFlag( aRunnable.mConfigFlag ),

	mReportPrintFlag( aRunnable.mReportPrintFlag ),

	mStartupLifecycleStatus( aRunnable.mStartupLifecycleStatus ),
	mStaticLifecycleStatus ( aRunnable.mStaticLifecycleStatus  ),
	mDynamicLifecycleStatus( aRunnable.mDynamicLifecycleStatus )
	{
		//!! NOTHING
	}

	/**
	 * DESTRUCTOR
	 */
	virtual ~RunnableElement()
	{
		//!! NOTHING
	}


	/**
	 * GETTER - SETTER
	 * mParameterWObject
	 */
	inline WObject * getParameterWObject() const
	{
		return( mParameterWObject );
	}

	inline bool hasParameterWObject() const
	{
		return( mParameterWObject != NULL /*WObject::_NULL_*/ );
	}

	void setParameterWObject(WObject * wfParameterObject);


	////////////////////////////////////////////////////////////////////////////
	// RUNNABLE LIFECYCLE API
	////////////////////////////////////////////////////////////////////////////

	/**
	 * GETTER - SETTER
	 * mStaticLifecycleStatus
	 */
	inline bool isLifecycleConfigured() const
	{
		return( (mStaticLifecycleStatus & RUNNABLE_CONFIGURED_STATE) != 0 );
	}

	inline void setLifecycleConfigured()
	{
		mStaticLifecycleStatus = RUNNABLE_CONFIGURED_STATE;
	}


	inline bool isLifecycleInitialized() const
	{
		return( (mStaticLifecycleStatus & RUNNABLE_INITIALIZED_STATE) != 0 );
	}

	inline void setLifecycleInitialized()
	{
		mStaticLifecycleStatus = RUNNABLE_INITIALIZED_STATE;
	}


	inline bool isLifecycleStarted() const
	{
		return( (mStaticLifecycleStatus & RUNNABLE_STARTED_STATE) != 0 );
	}

	inline void setLifecycleStarted()
	{
		mStaticLifecycleStatus = RUNNABLE_STARTED_STATE;
	}


	inline bool isLifecycleReleased() const
	{
		return( (mStaticLifecycleStatus & RUNNABLE_RELEASED_STATE) != 0 );
	}

	inline void setLifecycleReleased()
	{
		mStaticLifecycleStatus = RUNNABLE_RELEASED_STATE;
	}


	inline bool isLifecycleStopped() const
	{
		return( (mStaticLifecycleStatus & RUNNABLE_STOPPED_STATE) != 0 );
	}

	inline void setLifecycleStopped()
	{
		mStaticLifecycleStatus = RUNNABLE_STOPPED_STATE;
	}


	inline bool isLifecycleExited() const
	{
		return( (mStaticLifecycleStatus & RUNNABLE_EXITED_STATE) != 0 );
	}

	inline void setLifecycleExited()
	{
		mStaticLifecycleStatus = RUNNABLE_EXITED_STATE;
	}


	inline bool isLifecycleReady() const
	{
		return( (mStaticLifecycleStatus & RUNNABLE_READY_STATE) != 0 );
	}

	inline void setLifecycleReady()
	{
		mStaticLifecycleStatus = RUNNABLE_READY_STATE;
	}


	inline bool isLifecycleStandby() const
	{
		return( (mStaticLifecycleStatus & RUNNABLE_STANDBY_STATE) != 0 );
	}

	inline void setLifecycleStandby()
	{
		mStaticLifecycleStatus = RUNNABLE_STANDBY_STATE;
	}


	/**
	 * GETTER - SETTER
	 * mStaticLifecycleStatus
	 */
	inline bool isLifecycleIdle() const
	{
		return( (mDynamicLifecycleStatus & RUNNABLE_IDLE_STATE) != 0 );
	}

	inline void setLifecycleIdle()
	{
		mDynamicLifecycleStatus = RUNNABLE_IDLE_STATE;
	}


	inline bool isLifecycleRunning() const
	{
		return( (mDynamicLifecycleStatus & RUNNABLE_RUNNING_STATE) != 0 );
	}

	inline void setLifecycleRunning()
	{
		mDynamicLifecycleStatus = RUNNABLE_RUNNING_STATE;
	}


	inline bool isLifecycleWaiting() const
	{
		return( (mDynamicLifecycleStatus & RUNNABLE_WAITING_STATE) != 0 );
	}

	inline void setLifecycleWaiting()
	{
		mDynamicLifecycleStatus = RUNNABLE_WAITING_STATE;
	}


	inline bool isLifecycleSuspended() const
	{
		return( (mDynamicLifecycleStatus & RUNNABLE_SUSPENDED_STATE) != 0 );
	}

	inline void setLifecycleSuspended()
	{
		mDynamicLifecycleStatus = RUNNABLE_SUSPENDED_STATE;
	}


	/**
	 * TESTER
	 * LifecycleStatus
	 */
	inline bool isLifecycleActive() const
	{
		return( (mStaticLifecycleStatus & RUNNABLE_ACTIVE_STATE) != 0 );
	}

	inline bool isLifecycleInactive() const
	{
		return( (mStaticLifecycleStatus & RUNNABLE_INACTIVE_STATE) != 0 );
	}


	inline virtual bool isLifecycleRunnable()const
	{
		return( ((mDynamicLifecycleStatus & RUNNABLE_DYNAMIC_READY_STATE) != 0)
			&& ((mStaticLifecycleStatus & RUNNABLE_STATIC_READY_STATE) != 0) );
	}


	////////////////////////////////////////////////////////////////////////////
	// START / STOP / KILL / SUSPEND / RESUME  API
	////////////////////////////////////////////////////////////////////////////

//	virtual int start()
//	{
//		//!! NOTHING
//		return( true );
//	}

	inline virtual int stop()
	{
		setLifecycleStopped();

		//!! NOTHING
		return( 0 );
	}


	inline virtual int kill()
	{
		setLifecycleStopped();

		//!! NOTHING
		return( 0 );
	}


	inline virtual bool suspend()
	{
		setLifecycleSuspended();

		//!! NOTHING
		return( true );
	}

	inline virtual bool resume()
	{
		setLifecycleIdle();

		//!! NOTHING
		return( true );
	}


	////////////////////////////////////////////////////////////////////////////
	// CONFIGURE API
	////////////////////////////////////////////////////////////////////////////

	virtual bool configure();

	bool configureLifecycleState();

	virtual void configureDebug();


	////////////////////////////////////////////////////////////////////////////
	// INIT API
	////////////////////////////////////////////////////////////////////////////

	virtual bool initImpl() = 0;

	inline virtual bool init()
	{
		if( initImpl() )
		{
			setLifecycleInitialized();

			return( true );
		}

		return( false );
	}


	////////////////////////////////////////////////////////////////////////////
	// EXIT API
	////////////////////////////////////////////////////////////////////////////

	virtual bool exitImpl() = 0;

	inline virtual bool exit()
	{
		if( exitImpl() )
		{
			setLifecycleExited();

			return( true );
		}

		return( false );
	}


	////////////////////////////////////////////////////////////////////////////
	// REPORT API
	////////////////////////////////////////////////////////////////////////////

	inline virtual void report(OutStream & os) const
	{
		if( mReportPrintFlag )
		{
			AVM_VERBOSITY_SWITCH_SILENT

				reportSilent(os);

			AVM_VERBOSITY_SWITCH_CASE_MINIMUM

				reportMinimum(os);

			AVM_VERBOSITY_SWITCH_CASE_MEDIUM

				reportMedium(os);

			AVM_VERBOSITY_SWITCH_CASE_MAXIMUM

				reportMaximum(os);

			AVM_VERBOSITY_SWITCH_END
		}
	}

	inline virtual void report(PairOutStream & os) const
	{
		report( os.OS1 );
		report( os.OS2 );
	}

	inline virtual void report(TripleOutStream & os) const
	{
		report( os.OS1 );
		report( os.OS2 );
		report( os.OS3 );
	}


	inline virtual void reportSilent(OutStream & os) const
	{
		reportMinimum(os);
	}

	inline virtual void reportMinimum(OutStream & os) const
	{
		reportDefault(os);
	}

	inline virtual void reportMedium(OutStream & os) const
	{
		reportDefault(os);
	}

	inline virtual void reportMaximum(OutStream & os) const
	{
		reportDefault(os);
	}

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


	////////////////////////////////////////////////////////////////////////////
	// PROCESS API
	////////////////////////////////////////////////////////////////////////////

	inline virtual bool preprocess()
	{
		//!! NOTHING
		return( true );
	}

	inline virtual bool postprocess()
	{
		//!! NOTHING
		return( true );
	}


	////////////////////////////////////////////////////////////////////////////
	// SERIALIZATION API
	////////////////////////////////////////////////////////////////////////////

	static std::string strLifecycle(lifecycle_status_t aLifecycleStatus);

	static lifecycle_status_t toLifecycle(std::string aLifecycle);

	inline std::string strDynamicLifecycleStatus() const
	{
		return( strLifecycle(mDynamicLifecycleStatus) );
	}

	inline std::string strStaticLifecycleStatus() const
	{
		return( strLifecycle(mStaticLifecycleStatus) );
	}

	inline OutStream & strLifecycleStatus(OutStream & os) const
	{
		os << "< dynamic:" << strLifecycle(mStaticLifecycleStatus)
			<< " , static:" << strLifecycle(mDynamicLifecycleStatus) << " >";

		return( os );
	}

	virtual std::string strUniqId() const;

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

};


} /* namespace sep */

#endif /* COMMON_RUNNABLEELEMENT_H_ */