/*******************************************************************************
 * 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: 14 déc. 2016
 *
 * Contributors:
 *  Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr
 *   - Initial API and Implementation
 ******************************************************************************/

#ifndef FML_WORKFLOW_CONFIGURATION_H_
#define FML_WORKFLOW_CONFIGURATION_H_

#include <common/NamedElement.h>

#include <fml/infrastructure/System.h>

#include <fml/executable/ExecutableSystem.h>

#include <fml/runtime/ExecutionContext.h>
#include <fml/runtime/RuntimeID.h>

#include <fml/workflow/WObject.h>

#include <printer/OutStream.h>



namespace sep
{

class APExecutionData;

class ExecutableSystem;

class SymbexEngine;

class Workflow;


/**
 * TYPEDEF
 */
typedef Vector< RuntimeID >  TableOfRuntimeID_T;



class Configuration  :  public NamedElement
{

	AVM_DECLARE_UNCLONABLE_CLASS(Configuration)

public:
	/**
	 * ATTRIBUTES
	 * GLOBAL
	 */
	static const std::string SPECIFICATION_FILE_EXTENSION;

	static const std::string EXECUTABLE_FILE_EXTENSION;

	static const std::string SYMBEX_GRAPH_FILE_EXTENSION;

	static const std::string SYMBEX_SCENARII_FILE_EXTENSION;

	static const std::string GRAPHVIZ_FILE_EXTENSION;


protected :
	/**
	 * ATTRIBUTES
	 */
	SymbexEngine & mSymbexEngine;
	Workflow & mWorkflow;

	WObjectManager mWObjectManager;

	std::string mProjectSourceLocation;
	std::string mSpecificationFileLocation;

	bool mOwnedSpecificationFlag;

	std::string mOutputFilenamePattern;
	std::string mDebugFilenamePattern;

	bool mOutputExecutableEnabledGenerationFlag;
	std::string mOutputExecutableFileLocation;

	bool mOutputSymbexGraphEnabledGenerationFlag;
	std::string mOutputSymbexGraphFileLocation;

	bool mOutputSymbexScenariiEnabledGenerationFlag;
	std::string mOutputSymbexScenariiFileLocation;

	bool mDebugStageEnabledFlag;
	bool mDebugParsingStageEnabledFlag;
	bool mDebugCompilingStageEnabledFlag;
	bool mDebugLoadingStageEnabledFlag;
	bool mDebugComputingEnabledFlag;

	// Symbex Threading config
	bool mMultitaskingFlag;
	avm_uint8_t mThreadCount;

	// Shell config
	std::string mInconditionalStopMarkerLocation;


	AvmPointer< System           , DestroyElementPolicy > mSpecification;

	AvmPointer< ExecutableSystem , DestroyElementPolicy > mExecutableSystem;

	TableOfRuntimeID_T  mTableOfRID;

	ExecutionContext mMainExecutionContext;

	ListOfExecutionContext mInputContext;

	ListOfExecutionContext mTrace;


public :
	/**
	 * CONSTRUCTOR
	 * Default
	 */
	Configuration(SymbexEngine & aSymbexEngine, Workflow & aWorkflow);

	/**
	 * DESTRUCTOR
	 */
	virtual ~Configuration();

	void destroy();


	/**
	 * GETTER
	 * mSymbexEngine
	 */
	inline SymbexEngine & getSymbexEngine() const
	{
		return( mSymbexEngine );
	}

	/**
	 * GETTER
	 * mWObjectManager
	 */
	inline  WObjectManager & getWObjectManager()
	{
		return( mWObjectManager );
	}


	/**
	 * CONFIGURE
	 */
	bool configure(WObject * wfConfiguration, Configuration * prevConfiguration);

	bool configure_shell_symbex(WObject * wfConfiguration);

	bool configureFormatter(WObject * FORMAT,
			std::string & formatPattern, const std::string & id);


	/*
	 * GETTER
	 * mWorkflow
	 */
	Workflow & getWorkflow()
	{
		return( mWorkflow );
	}


	/**
	 * Symbex Threading config
	 */
	inline bool isMultitasking() const
	{
		return( mMultitaskingFlag );
	}

	inline avm_uint8_t getThreadCount() const
	{
		return( mThreadCount );
	}

	/**
	 * GETTER
	 * mInconditionalStopMarkerLocation
	 */
	const std::string & getInconditionalStopMarkerLocation() const
	{
		return( mInconditionalStopMarkerLocation );
	}


	/**
	 * mSpecificationFileLocation
	 */
	inline bool hasOwnedSpecification() const
	{
		return( mOwnedSpecificationFlag );
	}

	/**
	 * mSpecificationFileLocation
	 */
	inline const std::string & getSpecificationFileLocation() const
	{
		return( mSpecificationFileLocation );
	}

	/**
	 * GETTER
	 * OUTPUT / DEBIG FILE LOCATION
	 */
	std::string formatFileLocation(
			const std::string & aFilenamePattern, const std::string & strID,
			const std::string & strExtension = "") const;

	inline std::string formatFileLocation(bool isDebug,
			const std::string & strID, const std::string & strExtension) const
	{
		return( formatFileLocation(
				(isDebug ? mDebugFilenamePattern : mOutputFilenamePattern),
				strID, strExtension) );
	}

	inline std::string formatOutputFileLocation(
			const std::string & strID, const std::string & strExtension) const
	{
		return( formatFileLocation(
				mOutputFilenamePattern, strID, strExtension) );
	}

	inline std::string formatDebugFileLocation(
			const std::string & strID, const std::string & strExtension) const
	{
		return( formatFileLocation(
				mDebugFilenamePattern, strID, strExtension) );
	}


	/**
	 * GETTER
	 * mDebugStageEnabledFlag
	 * mDebugParsingStageEnabledFlag
	 * mDebugCompilingStageEnabledFlag
	 * mDebugLoadingEnabledFlag
	 * mDebugComputingEnabledFlag
	 */
	inline bool isDebugStageEnabled() const
	{
		return( mDebugStageEnabledFlag );
	}

	inline bool isDebugParsingStageEnabled() const
	{
		return( mDebugParsingStageEnabledFlag );
	}

	inline bool isDebugCompilingStageEnabled() const
	{
		return( mDebugCompilingStageEnabledFlag );
	}

	inline bool isDebugLoadingStageEnabled() const
	{
		return( mDebugLoadingStageEnabledFlag );
	}

	inline bool isDebugComputingStageEnabled() const
	{
		return( mDebugComputingEnabledFlag );
	}


	/*
	 * GETTER - SETTER
	 * mSpecification
	 */
	inline System & getSpecification()
	{
		return( *mSpecification );
	}

	inline const System & getSpecification() const
	{
		return( *mSpecification );
	}

	inline bool hasSpecification() const
	{
		return( mSpecification.valid() );
	}

	inline void setSpecification(System * aSpecification)
	{
		mSpecification = aSpecification;
	}


	/*
	 * GETTER - SETTER
	 * mExecutableSystem
	 */
	inline ExecutableSystem & getExecutableSystem()
	{
		return( *mExecutableSystem );
	}

	inline const ExecutableSystem & getExecutableSystem() const
	{
		return( *mExecutableSystem );
	}

//	inline bool hasExecutableSystem() const
//	{
//		return( mExecutableSystem.valid() );
//	}

	inline void setExecutableSystem(ExecutableSystem * anExecutableSystem)
	{
		mExecutableSystem = anExecutableSystem;
	}


	/**
	 * GETTER - SETTER
	 * mTableOfRID
	 */
	inline void appendRID(const RuntimeID & aRID)
	{
		mTableOfRID.append(aRID);
	}

	void destroyRIDRunningCode();

	inline const TableOfRuntimeID_T & getTableOfRID() const
	{
		return( mTableOfRID );
	}


	/*
	 * GETTER - SETTER
	 * mMainExecutionContext
	 */
	inline ExecutionContext & getMainExecutionContext()
	{
		return( mMainExecutionContext );
	}

	inline const ExecutionContext & getMainExecutionContext() const
	{
		return( mMainExecutionContext );
	}

	inline const ExecutionData & getMainExecutionData() const
	{
		return( mMainExecutionContext.refExecutionData() );
	}


	inline bool hasMainExecutionContext() const
	{
		return( mMainExecutionContext.hasExecutionData() );
	}


	inline void setMainExecutionContext(
			const ExecutionContext & anExecutionContext)
	{
		mMainExecutionContext.initialize( anExecutionContext );
	}

	inline void setMainExecutionData(const APExecutionData & anExecutionData)
	{
		mMainExecutionContext.initialize( anExecutionData , 0 , 1 );
	}


	/*
	 * GETTER - SETTER
	 * mInputContext
	 */
	inline const ListOfExecutionContext & getInputContext() const
	{
		return( mInputContext );
	}

	inline ListOfExecutionContext & getInputContext()
	{
		return( mInputContext );
	}

	inline bool hasInputContext() const
	{
		return( mInputContext.nonempty() );
	}

	inline void appendInputContext(ExecutionContext * anInputContext)
	{
		mInputContext.append( anInputContext );
	}

	/*
	 * GETTER - SETTER
	 * mTrace
	 */
	inline const ListOfExecutionContext & getTrace() const
	{
		return( mTrace );
	}

	inline ExecutionContext * getFirstTrace() const
	{
		AVM_OS_ASSERT_FATAL_ERROR_EXIT( mTrace.nonempty() )
				<< "Expected a non-empty Symbex Root Execution Context List !!!"
				<< SEND_EXIT;

		return( mTrace.first() );
	}

	inline const ExecutionContext & refFirstTrace() const
	{
		AVM_OS_ASSERT_FATAL_ERROR_EXIT( mTrace.nonempty() )
				<< "Expected a non-empty Symbex Root Execution Context List !!!"
				<< SEND_EXIT;

		return( *( mTrace.first() ) );
	}

	inline bool hasTrace() const
	{
		return( mTrace.nonempty() );
	}

	inline bool noTrace() const
	{
		return( mTrace.empty() );
	}

	inline void appendTrace(ExecutionContext * aTrace)
	{
		mTrace.append( aTrace );
	}

	inline void appendTrace(const ListOfExecutionContext & aTrace)
	{
		mTrace.append( aTrace );
	}


	/*
	 * SETTER
	 * mSpecification
	 * mExecutableSystem
	 * mMainExecutionContext
	 * mTrace
	 */
	void set(Configuration & aConfiguration)
	{
		mSpecification = aConfiguration.mSpecification;

		mExecutableSystem = aConfiguration.mExecutableSystem;

		setMainExecutionContext( aConfiguration.mMainExecutionContext );

		AVM_OS_ASSERT_FATAL_ERROR_EXIT( aConfiguration.mInputContext.nonempty() )
				<< "Expected a non-empty Symbex Input Execution Context List !!!"
				<< SEND_EXIT;

		mInputContext = aConfiguration.mInputContext;

		mTrace = aConfiguration.mTrace;
	}


	/**
	 * SAVING
	 */
	void saveSpecification(bool isDebug, const std::string & strID = "");
	void saveSymbexGraph(bool isDebug, const std::string & strID = "");
	void saveSymbexScenarii(bool isDebug, const std::string & strID = "");


//	static void saveSpecificationAfterCompilationStep(
//			const std::string & strPrefixName = "");
//
//
//	static void saveExecutableSpecification(
//			const std::string & strPrefixName = "");

	static void saveElementTextualView(OutStream & logger,
			const Element & anElement, const std::string & saveFileURL);

	inline static void saveElementTextualView(OutStream & logger,
			const Element * anElement, const std::string & saveFileURL)
	{
		AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( anElement )
				<< "Element !!!"
				<< SEND_EXIT;

		if( anElement != NULL )
		{
			saveElementTextualView(logger, (* anElement), saveFileURL);
		}
	}

	// Jose Projection:
//	void saveProjection(const std::string & strPrefixName = "");
//	void saveProjectionScenarii(const std::string & strPrefixName = "");


	////////////////////////////////////////////////////////////////////////////
	// SERIALIZATION API
	////////////////////////////////////////////////////////////////////////////

	void serializeDebugExecutable(const std::string & strID);

	void serializeTextualExecutable();

	void serializeGraphizExecutable();


	void serializeTextualSymbexGraph();

	void serializeGraphizSymbexGraph();


	void serializeScenarii();


	void serializeBuildingResult();

	void serializeComputingResult();


	virtual void toStream(OutStream & os) const;

};


} /* namespace sep */

#endif /* FML_WORKFLOW_CONFIGURATION_H_ */