/*******************************************************************************
 * 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 REDUNDANCYFILTER_H_
#define REDUNDANCYFILTER_H_

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

#include <common/BF.h>

#include <fml/builtin/Identifier.h>


namespace sep
{

class BaseConfigurationComparator;
class BaseDataComparator;
class BasePathScopeIterator;

class SymbexControllerUnitManager;


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

	AVM_DECLARE_CLONABLE_CLASS( RedundancyFilter )


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


protected:
	/**
	 * ATTRIBUTES
	 */
	bool mTrivialLoopDetectionFlag;


	bool mRedundancyConfigurationFlag;
	bool mRedundancyEnabledFlag;

	BaseConfigurationComparator * mConfigurationComparator;

	BasePathScopeIterator       * mPathScopeIterator;

	BaseDataComparator          * mExecutionDataComparator;

	avm_size_t mTrivialLoopTest;
	avm_size_t mTrivialLoopCount;

	avm_size_t mRedundancyTest;
	avm_size_t mRedundancyCount;

	////////////////////////////////////////////////////////////////////////////
	// Computing Variable
	const ExecutionContext * mCandidateEC;


public:

	/**
	 * CONSTRUCTOR
	 */
	RedundancyFilter(SymbexControllerUnitManager & aControllerUnitManager,
			WObject * wfParameterObject = NULL)
	: RegisteredProcessorUnit(aControllerUnitManager, wfParameterObject,
			AVM_PRE_FILTERING_STAGE, PRECEDENCE_OF_REDUNDANCY),
	mTrivialLoopDetectionFlag( false ),
	mRedundancyConfigurationFlag( false ),
	mRedundancyEnabledFlag( false ),

	mConfigurationComparator( NULL ),
	mPathScopeIterator( NULL ),
	mExecutionDataComparator( NULL ),

	mTrivialLoopTest( 0 ),
	mTrivialLoopCount( 0 ),

	mRedundancyTest( 0 ),
	mRedundancyCount( 0 ),

	////////////////////////////////////////////////////////////////////////////
	// Computing Variable
	mCandidateEC( NULL )
	{
		//!! NOTHING
	}

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

	void destroy();

	/**
	 * mRedundancyEnabledFlag
	 * mTrivialLoopDetectionFlag
	 */
	inline void setEnabledRedundancyDetection(bool bEnabled = true )
	{
		// Enabling only if it was configured,
		// i.e. mRedundancyConfigurationFlag is true !
		mRedundancyEnabledFlag = (bEnabled && mRedundancyConfigurationFlag);
	}

	inline void setEnabledTrivialLoopDetection(bool bEnabled = true )
	{
		mTrivialLoopDetectionFlag = bEnabled;
	}


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


	/**
	 * REPORT TRACE
	 */
	virtual void reportDefault(OutStream & os) const;


	////////////////////////////////////////////////////////////////////////////
	// NON-REGRESSION TEST API
	////////////////////////////////////////////////////////////////////////////

	virtual void tddRegressionReportImpl(OutStream & os);

	/**
	 * preFilter
	 * Every pre filter has to implement this method
	 */
	virtual bool prefilter();

	virtual bool prefilter(ExecutionContext & anEC);

	bool trivialLoopDetection(ExecutionContext & anEC);


	/* GETTER - SETTER
	 * mConfigurationComparator
	 */
	inline BaseConfigurationComparator * getConfigurationComparator()
	{
		return( mConfigurationComparator );
	}

	inline bool hasConfigurationComparator() const
	{
		return( mConfigurationComparator != NULL );
	}

	inline void setConfigurationComparator(
			BaseConfigurationComparator * aConfigurationComparator)
	{
		mConfigurationComparator = aConfigurationComparator;
	}


	/* GETTER - SETTER
	 * mPathScopeIterator
	 */
	inline BasePathScopeIterator * getPathScopeIterator()
	{
		return( mPathScopeIterator );
	}

	inline bool hasPathScopeIterator() const
	{
		return( mPathScopeIterator != NULL );
	}

	inline void setPathScopeIterator(BasePathScopeIterator * aPathScopeIterator)
	{
		mPathScopeIterator = aPathScopeIterator;
	}


	/* GETTER - SETTER
	 * mExecutionDataComparator
	 */
	inline BaseDataComparator * getExecutionDataComparator()
	{
		return( mExecutionDataComparator );
	}

	inline bool hasExecutionDataComparator() const
	{
		return( mExecutionDataComparator != NULL );
	}

	inline void setExecutionDataComparator(
			BaseDataComparator * anExecutionDataComparator)
	{
		mExecutionDataComparator = anExecutionDataComparator;
	}


	/**
	 * IHandlerEventDestroyCtx API
	 * Destroy Execution Context
	 */
	virtual void handleEventDestroyCtx(ExecutionContext * anEC);

};


}

#endif /*REDUNDANCYFILTER_H_*/