/*******************************************************************************
 * 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: 27 janv. 2015
 *
 * Contributors:
 *  Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr
 *   - Initial API and implementation
 ******************************************************************************/

#ifndef IDEBUGPROCESSORPROVIDER_H_
#define IDEBUGPROCESSORPROVIDER_H_

#include <util/avm_string.h>

#include <collection/Typedef.h>

#include <fam/api/AbstractProcessorUnit.h>

#include <fml/runtime/ExecutionData.h>

#include <fml/trace/TracePoint.h>
#include <fml/trace/TraceSequence.h>

#include <sew/Configuration.h>

#include <fstream>


namespace sep
{

class Configuration;

class ExecutionContext;

class InstanceOfData;

class RuntimeForm;

class TraceFactory;


class IDebugProcessorProvider
{


protected:
	/**
	 * ATTRIBUTES
	 */
	AbstractProcessorUnit * mDebugProcessor;
	Configuration & mDebugConfiguration;

	bool mDebugEnabledFlag;
	bool mDebugConsoleFlag;

	std::string mDebugScriptFile;

	std::string mDebugPromptPrefix;

	bool mDebugFilteringDetailFlag;
	bool mDebugFilteringInitializeFlag;
	bool mDebugFilteringFinalizeFlag;

	bool mDebugPrefilteringFlag;
	bool mDebugPrefilteringDetailFlag;
	bool mDebugPrefilteringFinalizeFlag;

	bool mDebugPostfilteringFlag;
	bool mDebugPostfilteringDetailFlag;
	bool mDebugPostfilteringFinalizeFlag;

	bool mDebugPreprocessingFlag;
	bool mDebugPreprocessingDetailFlag;

	bool mDebugPostprocessingFlag;
	bool mDebugPostprocessingDetailFlag;

	avm_size_t mDebugEvalStepCount;
	avm_size_t mDebugBreakpointEvalStep;
	avm_size_t mDebugBreakpointEvalStepPeriod;

	avm_size_t mDebugBreakpointEvalContext;

	const ExecutionContext * mDebugSelectedContext;
	bool mDebugTraceFullPathFlag;

	TraceSequence mDebugTraceSequence;

	TracePoint * mDebugSelectedVar;
	ListOfTracePoint mDebugSelectedVars;

	TracePoint * mDebugSelectedTimeVar;

	TracePoint * mDebugSelectedPort;
	ListOfTracePoint mDebugSelectedPorts;

	TracePoint * mDebugSelectedBuffer;
	ListOfTracePoint mDebugSelectedBuffers;

	TracePoint mDebugParametersMachine;

	TracePoint * mDebugSelectedMachine;
	ListOfTracePoint mDebugSelectedMachines;

	TracePoint * mDebugSelectedState;
	ListOfTracePoint mDebugSelectedStates;

	TracePoint * mDebugSelectedStatemachine;
	ListOfTracePoint mDebugSelectedStatemachines;

	TracePoint * mDebugSelectedTransition;
	ListOfTracePoint mDebugSelectedTransitions;

	TracePoint * mDebugSelectedRoutine;
	ListOfTracePoint mDebugSelectedRoutines;

	TracePoint * mDebugSelectedRunnable;
	ListOfTracePoint mDebugSelectedRunnables;

	// Trace Factory tools
	TraceFactory * mDebugTraceFactory;
	InstanceOfData   * mDebugTimeVariable;
	InstanceOfData   * mDebugDeltaTimeVariable;

	////////////////////////////////////////////////////////////////////////////
	// Computing Variables
	BF dbgTP;
	TracePoint * dbgTracePoint;
	ListOfTracePoint::iterator dbgPointIt;
	ListOfTracePoint::iterator dbgPointItEnd;

	ListOfExecutionContext * dbgQueue;
	ListOfExecutionContext::iterator dbgQueueIt;
	ListOfExecutionContext::iterator dbgQueueItEnd;

	bool dbgContinueREPL;

	bool dbgDetailsMin;
	bool dbgDetailsMed;
	bool dbgDetailsMax;

	bool dbgDecodeCommandOk;

	VectorOfString dbgCommandLineHistory;
	std::string dbgCommandLine;
	std::string dbgCommandArg;

	avm_integer_t dbgIntValue;
	avm_size_t dbgOffset;

	const ExecutionContext * dbgEC;
	APExecutionData dbgED;
	const RuntimeForm * dbgRF;
	BF dbgValue;


public:
	/**
	 * CONSTRUCTOR
	 * Default
	 */
	IDebugProcessorProvider(AbstractProcessorUnit * aProcessor)
	: mDebugProcessor( aProcessor ),
	mDebugConfiguration( aProcessor->getConfiguration() ),
	mDebugEnabledFlag( false ),

	mDebugConsoleFlag( true ),
	mDebugScriptFile( ),

	mDebugPromptPrefix( ),

	mDebugFilteringDetailFlag( false ),
	mDebugFilteringInitializeFlag( false ),
	mDebugFilteringFinalizeFlag( false ),

	mDebugPrefilteringFlag( false ),
	mDebugPrefilteringDetailFlag( false ),
	mDebugPrefilteringFinalizeFlag( false ),

	mDebugPostfilteringFlag( false ),
	mDebugPostfilteringDetailFlag( false ),
	mDebugPostfilteringFinalizeFlag( false ),

	mDebugPreprocessingFlag( false ),
	mDebugPreprocessingDetailFlag( false ),

	mDebugPostprocessingFlag( false ),
	mDebugPostprocessingDetailFlag( false ),

	mDebugEvalStepCount( 0 ),
	mDebugBreakpointEvalStep( 0 ),
	mDebugBreakpointEvalStepPeriod( 0 ),

	mDebugBreakpointEvalContext( 0 ),

	mDebugSelectedContext( NULL ),

	mDebugTraceFullPathFlag( false ),

	mDebugTraceSequence( ),

	mDebugSelectedVar( NULL ),
	mDebugSelectedVars( ),

	mDebugSelectedTimeVar( NULL ),

	mDebugSelectedPort( NULL ),
	mDebugSelectedPorts( ),

	mDebugSelectedBuffer( NULL ),
	mDebugSelectedBuffers( ),

	mDebugParametersMachine( ENUM_TRACE_POINT::TRACE_MACHINE_NATURE ),

	mDebugSelectedMachine( NULL ),
	mDebugSelectedMachines( ),

	mDebugSelectedState( NULL ),
	mDebugSelectedStates( ),

	mDebugSelectedStatemachine( NULL ),
	mDebugSelectedStatemachines( ),

	mDebugSelectedTransition( NULL ),
	mDebugSelectedTransitions( ),

	mDebugSelectedRoutine( NULL ),
	mDebugSelectedRoutines( ),

	mDebugSelectedRunnable( NULL ),
	mDebugSelectedRunnables( ),

	// Trace Factory tools
	mDebugTraceFactory( NULL ),
	mDebugTimeVariable( NULL ),
	mDebugDeltaTimeVariable( NULL ),

	dbgTP( ),
	dbgTracePoint( NULL ),
	dbgPointIt( ),
	dbgPointItEnd( ),

	////////////////////////////////////////////////////////////////////////////
	// Computing Variables
	dbgQueue( NULL ),
	dbgQueueIt( ),
	dbgQueueItEnd( ),

	dbgContinueREPL( true ),

	dbgDetailsMin( false ),
	dbgDetailsMed( false ),
	dbgDetailsMax( false ),

	dbgDecodeCommandOk( false ),

	dbgCommandLineHistory( "help" ),
	dbgCommandLine( ),
	dbgCommandArg( ),

	dbgIntValue( 0 ),
	dbgOffset( 0 ),

	dbgEC( NULL ),
	dbgED( ),
	dbgRF( NULL ),
	dbgValue( )
	{
		//!! NOTHING
	}

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


	////////////////////////////////////////////////////////////////////////////
	////////////////////////////////////////////////////////////////////////////
	// PLUGIN PROCESSOR API
	////////////////////////////////////////////////////////////////////////////
	////////////////////////////////////////////////////////////////////////////

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

	virtual bool debugConfigureImpl(WObject * wfParameterObject);

	/**
	 * TEST
	 */
	inline bool isDebugEnabled() const
	{
		return( mDebugFilteringInitializeFlag || mDebugFilteringFinalizeFlag ||
				mDebugPrefilteringFlag  || mDebugPrefilteringFinalizeFlag    ||
				mDebugPostfilteringFlag || mDebugPostfilteringFinalizeFlag   ||
				mDebugPreprocessingFlag || mDebugPostprocessingFlag );
	}


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

	virtual bool debugPreprocessing();

	virtual bool debugPreprocessing(const ExecutionContext * anEC);

	inline bool isDebugPreprocessing() const
	{
		return( mDebugPreprocessingFlag );
	}


	virtual bool debugPostprocessing();

	virtual bool debugPostprocessing(const ExecutionContext * anEC);

	inline bool isDebugPostprocessing() const
	{
		return( mDebugPostprocessingFlag );
	}


	////////////////////////////////////////////////////////////////////////////
	// FILTER API
	////////////////////////////////////////////////////////////////////////////

	bool debugActivatorTriggering();


	bool debugFilteringInitialize();

	bool debugFilteringInitialize(const ExecutionContext * anEC);

	inline bool isDebugFilteringInitialize()
	{
		return( mDebugFilteringInitializeFlag );
	}


	bool debugFilteringFinalize();

	bool debugFilteringFinalize(const ExecutionContext * anEC);

	inline bool isDebugFilteringFinalize()
	{
		return( mDebugFilteringFinalizeFlag );
	}


	virtual bool debugPrefiltering();
	virtual bool debugPrefiltering(const ExecutionContext * anEC);

	inline bool isDebugPrefiltering() const
	{
		return( mDebugPrefilteringFlag );
	}


	bool debugPrefilteringFinalize();

	inline bool isDebugPrefilteringFinalize()
	{
		return( mDebugPrefilteringFinalizeFlag );
	}


	virtual bool debugPostfiltering();
	virtual bool debugPostfiltering(const ExecutionContext * anEC);

	inline bool isDebugPostfiltering() const
	{
		return( mDebugPostfilteringFlag );
	}


	bool debugPostfilteringFinalize();

	inline bool isDebugPostfilteringFinalize()
	{
		return( mDebugPostfilteringFinalizeFlag );
	}


	////////////////////////////////////////////////////////////////////////////
	// DEBUG PROCESSING
	////////////////////////////////////////////////////////////////////////////

	void debugReadEvalCommand();


	void debugReadEvalScript();

	bool isDebugScript(std::ifstream & aScriptStream);

	void debugReadEvalScript(std::ifstream & aScriptStream);


	void debugReadEvalCommandLoop();

	void debugReadHistoryCommand();

	void debugEvalCommand();

	/**
	 * API
	 * if return false,
	 * the default debug evaluation command will handle the current command
	 */
	virtual bool debugEvalCommandImpl() = 0;

	/**
	 * method for launch anywhere the REPL command loop !
	 */
	inline void debugReadEvalCommandPrintLoop(
			const std::string & aDebugPromptPrefix = "PROCESSOR#CTX",
			ExecutionContext * aDebugSelectedContext = NULL)
	{
		mDebugPromptPrefix = aDebugPromptPrefix;

		if( aDebugSelectedContext != NULL )
		{
			mDebugPromptPrefix = aDebugPromptPrefix;
		}

		debugReadEvalCommand();
	}


	/**
	 * Command decoder
	 */
	inline bool isDebugStringCommand(const std::string & cmdString)
	{
		if( StringTools::startsWith(dbgCommandLine, cmdString) )
		{
			StringTools::ltrim( dbgCommandArg , cmdString.size());

			return( dbgDecodeCommandOk = true );
		}

		return( false );
	}

	inline bool isDebugCharCommand(char cmdChar)
	{
		if( ((not dbgCommandLine.empty()) && (dbgCommandLine[0] == cmdChar)) &&
			((dbgCommandLine.size() == 1) || (not ::isalpha(dbgCommandLine[1]))) )
		{
			StringTools::ltrim( dbgCommandArg , 1 );

			return( dbgDecodeCommandOk = true );
		}

		return( false );
	}


	void dbgCheckCommandDetailsArg();


	inline bool dbgDecodeCommand(const std::string & cmdStr)
	{
		if( isDebugStringCommand(cmdStr) )
		{
			dbgCheckCommandDetailsArg() ;
		}

		return( dbgDecodeCommandOk );
	}

	inline bool dbgDecodeCommand(const std::string & cmdStr, char cmdChar)
	{
		if( isDebugStringCommand(cmdStr) || isDebugCharCommand(cmdChar) )
		{
			dbgCheckCommandDetailsArg() ;

			dbgDecodeCommandOk = true;
		}

		return( dbgDecodeCommandOk );
	}

	inline bool dbgDecodeCommand(
			const std::string & cmdStr, const std::string & cmdStr1)
	{
		if( isDebugStringCommand(cmdStr) || isDebugStringCommand(cmdStr1) )
		{
			dbgCheckCommandDetailsArg() ;
		}

		return( dbgDecodeCommandOk );
	}

	inline bool dbgDecodeCommand(const std::string & cmdStr,
			const std::string & cmdStr1, const std::string & cmdStr2)
	{
		if( isDebugStringCommand(cmdStr) || isDebugStringCommand(cmdStr1) ||
			isDebugStringCommand(cmdStr2) )
		{
			dbgCheckCommandDetailsArg() ;
		}

		return( dbgDecodeCommandOk );
	}

	inline bool dbgDecodeCommand(
			const std::string & cmdStr, const std::string & cmdStr1,
			const std::string & cmdStr2, const std::string & cmdStr3)
	{
		if( isDebugStringCommand(cmdStr)  || isDebugStringCommand(cmdStr1) ||
			isDebugStringCommand(cmdStr2) || isDebugStringCommand(cmdStr3) )
		{
			dbgCheckCommandDetailsArg() ;
		}

		return( dbgDecodeCommandOk );
	}

	inline bool dbgDecodeCommand(const std::string & cmdStr,
			const std::string & cmdStr1, char cmdChar)
	{
		if( isDebugStringCommand(cmdStr) || isDebugStringCommand(cmdStr1) ||
			isDebugCharCommand(cmdChar)  )
		{
			dbgCheckCommandDetailsArg() ;
		}

		return( dbgDecodeCommandOk );
	}

	inline bool dbgDecodeCommand(
			const std::string & cmdStr, char cmdChar, char cmdChar1)
	{
		if( isDebugStringCommand(cmdStr) ||
			isDebugCharCommand(cmdChar)  || isDebugCharCommand(cmdChar1) )
		{
			dbgCheckCommandDetailsArg() ;
		}

		return( dbgDecodeCommandOk );
	}


	static std::string DEBUG_SHELL_COMMAND_SUMMARY;

	static std::string DEBUG_SHELL_COMMAND_HISTORY;

	static std::string DEBUG_SHELL_COMMAND_CONTROL;

	static std::string DEBUG_SHELL_COMMAND_QUEUE;

	static std::string DEBUG_SHELL_COMMAND_CONTEX;

	static std::string DEBUG_SHELL_COMMAND_DATA;

	static std::string DEBUG_SHELL_COMMAND_PRINT;

	static std::string DEBUG_SHELL_COMMAND_REPORT;

	static std::string DEBUG_SHELL_COMMAND_BREAKPOINT;

	static std::string DEBUG_SHELL_COMMAND_OPTION;

	static std::string DEBUG_SHELL_COMMAND_LOG;


	void dbgCommandHelp();

	void dbgCommandHistory();


	void dbgCommandConfig();

	void dbgCommandBreak();

	void dbgCommandNext();

	void dbgCommandPeriod();

	void dbgCommandQueue();

	void dbgCommandContext();

	void dbgCommandPath();

	void dbgCommandTrace();

	void dbgCommandTraceDetailLevel();

	void dbgPrintVarInfo(TracePoint * aTP);
	void dbgCommandVar();
	void dbgCommandVars();

	void dbgCommandTime();

	void dbgPrintPortInfo(TracePoint * aTP);
	void dbgCommandPort(ENUM_TRACE_POINT::TRACE_NATURE nature);
	void dbgCommandPorts(ENUM_TRACE_POINT::TRACE_NATURE nature);

	void dbgPrintBufferInfo(TracePoint * aTP);
	void dbgCommandBuffer();
	void dbgCommandBuffers();

	void dbgPrintMachineInfo(TracePoint * aTP);
	void dbgCommandMachine();
	void dbgCommandMachines();

	void dbgCommandParametersMachine();

	void dbgPrintStateInfo(TracePoint * aTP);
	void dbgCommandState();
	void dbgCommandStates();

	void dbgPrintStatemachineInfo(TracePoint * aTP);
	void dbgCommandStatemachine();
	void dbgCommandStatemachines();

	void dbgPrintTransitionInfo(TracePoint * aTP);
	void dbgCommandTransition();
	void dbgCommandTransitions();

	void dbgPrintRoutineInfo(TracePoint * aTP);
	void dbgCommandRoutine();
	void dbgCommandRoutines();

	void dbgPrintRunnableInfo(TracePoint * aTP);
	void dbgCommandRunnable();
	void dbgCommandRunnables();

	void dbgCommandEcho();
	void dbgCommandPrint();
	void dbgCommandShow();

	void dbgCommandEnableDisableProcess(bool bStatus);

	void dbgCommandVerbosityLevel();

	void dbgCommandDebugLevel();

	void dbgCommandDebugFlag(bool bStatus);

};


} /* namespace sep */

#endif /* IDEBUGPROCESSORPROVIDER_H_ */