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

#include "RuntimeQuery.h"

#include <fml/executable/ExecutableQuery.h>

#include <fml/workflow/UniFormIdentifier.h>
#include <fml/workflow/WObject.h>


namespace sep
{


////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// STATIC TOOLS
// Used during configuration step
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

/**
 * SEARCH
 * Symbol
 * !UNUSED!
 *
const BF & RuntimeQuery::searchSymbol(WObject * aWProperty)
{
	const std::string & kind = aWProperty->getNameID();
	const std::string & qnid = aWProperty->toStringValue();

	ExecutableQuery XQuery( mConfiguration );

	if( (kind == "variable") || (kind == "var") )
	{
		const BF & aSymbol = XQuery.getDataByQualifiedNameID( qnid );
		if( aSymbol.valid() )
		{
			return( aSymbol );
		}
	}

	else if( (kind == "model") || (kind == "form") )
	{
		const BF & aSymbol = XQuery.searchMachine(
				Specifier::DESIGN_MODEL_KIND, qnid);
		if( aSymbol.valid() )
		{
			return( aSymbol );
		}
	}

	else if( kind == "instance" )
	{
		const BF & aSymbol = XQuery.searchMachine(
				Specifier::DESIGN_INSTANCE_KIND, qnid );
		if( aSymbol.valid() )
		{
			return( aSymbol );
		}
	}

	else if( kind == "executable" )
	{
		const BF & anExecutable = XQuery.getExecutableByQualifiedNameID( qnid );
		if( anExecutable.valid() )
		{
			return( anExecutable );
		}
	}

	else if( kind == "transition" )
	{
		const BF & aSymbol = XQuery.getTransitionByQualifiedNameID( qnid );
		if( aSymbol.valid() )
		{
			return( aSymbol );
		}
	}
	else if( kind == "routine" )
	{
		const BF & aSymbol = XQuery.getProgramByQualifiedNameID(
				qnid, Specifier::SCOPE_ROUTINE_KIND );
		if( aSymbol.valid() )
		{
			return( aSymbol );
		}
	}
	else if( kind == "program" )
	{
		const BF & aSymbol = XQuery.getProgramByQualifiedNameID(
				qnid, Specifier::SCOPE_UNDEFINED_KIND );
//				qnid, Specifier::SCOPE_PROGRAM_KIND   );
		if( aSymbol.valid() )
		{
			return( aSymbol );
		}
	}

	else
	{
		AVM_OS_WARN << "Unexpected attribute << " << aWProperty->str()
				<< " >> as coverage processor parameter";
	}

	return( BF::REF_NULL );
}

avm_size_t RuntimeQuery::searchSymbol(
		WObject * aWProperty, BFList & listofSymbol )
{
	avm_size_t count = 0;

	const std::string & kind = aWProperty->getNameID();
	const std::string & qnid = aWProperty->toStringValue();

	ExecutableQuery XQuery( mConfiguration );

	if( (kind == "variable") || (kind == "var") )
	{
		count += XQuery.getDataByQualifiedNameID(qnid, listofSymbol);
	}

	else if( (kind == "model") || (kind == "form") )
	{
		//!!Symbol
//		count += searchMachine(aSystem, Specifier::DESIGN_MODEL_KIND,
//				qnid, listofSymbol );
	}

	else if( kind == "instance" )
	{
		//!!Symbol
//		count += searchMachine(aSystem, Specifier::DESIGN_INSTANCE_KIND,
//				qnid, listofSymbol );
	}

	else if( kind == "executable" )
	{
		count += XQuery.getExecutableByQualifiedNameID(qnid, listofSymbol);
	}

	else if( kind == "transition" )
	{
		count += XQuery.getTransitionByQualifiedNameID(qnid, listofSymbol );
	}

	else if( kind == "routine" )
	{
		count += XQuery.getProgramByQualifiedNameID(qnid,
				Specifier::SCOPE_ROUTINE_KIND, listofSymbol);
	}

	else if( kind == "program" )
	{
		count += XQuery.getProgramByQualifiedNameID(
				qnid, Specifier::SCOPE_UNDEFINED_KIND, listofSymbol );
//				qnid, Specifier::SCOPE_PROGRAM_KIND  , listofSymbol )
	}

	else
	{
		AVM_OS_WARN << "Unexpected attribute << " << aWProperty->str()
				<< " >> as coverage processor parameter";
	}

	return( count );
}
*
* !UNUSED!
*/

////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// RUNTIME TOOLS
// Used during execution< processing / filtering > step
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

/**
 * SEARCH
 * Variable
 */
BF RuntimeQuery::searchVariable(const ExecutionData & anED,
		const RuntimeID & ctxRID, const std::string & aFullyQualifiedNameID) const
{
	if( anED.hasLocalRuntimeStack() )
	{
		StackOfLocalRuntime::
		reverse_iterator it = anED.getLocalRuntimes()->rbegin();
		StackOfLocalRuntime::
		reverse_iterator itEnd = anED.getLocalRuntimes()->rend();
		for(  ; it != itEnd ; ++it )
		{
			const BF & anInstance = (*it).getProgram()->getAllData().
					getByFQNameID( aFullyQualifiedNameID );
			if( anInstance.valid() )
			{
				return( anInstance );
			}
		}
	}


	UniFormIdentifier anUFI(aFullyQualifiedNameID);

	std::ostringstream osUFI;

	UniFormIdentifier::iterator it = anUFI.begin();
	UniFormIdentifier::iterator itEnd = anUFI.end();

	// recherche de la machine PRINCIPALE (ROOT)
	osUFI << "inst::" << (*it).str();

	const RuntimeID & theSystemRID = anED.getSystemRID();
	RuntimeID theMachineID = theSystemRID;

	for( ++it ; (it != itEnd) ; ++it )
	{
		if( theMachineID.getInstance()->fqnEquals( osUFI.str() ) )
		{
			break;
		}
		osUFI << "." << (*it).str();
	}

	if( it != itEnd )
	{
		VectorOfInstanceOfMachine aliasPath;

		RuntimeID rid = theMachineID;

		// comme c'est la spec RID
//		aliasPath.append( theMachineID.getInstance() );

		// recherche de la machine FEUILLE
		for( ; it != itEnd ; ++it)
		{
			osUFI << "." << (*it).str();
			rid = anED.getRuntime(rid).getChild( osUFI.str() );
			if( rid.valid() )
			{
				theMachineID = rid;
				aliasPath.append( theMachineID.getInstance() );
			}
			else
			{
				break;
			}
		}

		if( (it == itEnd) && (theMachineID == theSystemRID) )
		{
			--it;
		}

		if( it != itEnd )
		{
			ExecutableForm * anExecutable = theMachineID.getExecutable();
			osUFI.str( "" );
			osUFI << "inst::"                    // "exec::".size() == 6
					<< anExecutable->getFullyQualifiedNameID().substr( 6 );


			for( ; it != itEnd ; ++it)
			{
				osUFI << "." << (*it).str();
			}


			// The ORIGINAL INSTANCE
			InstanceOfData * anInstance =
					anExecutable->getAllData().rawByFQNameID( osUFI.str() );

			if( anInstance != NULL )
			{
				anInstance = anExecutable->getConstData().rawByFQNameID(
						osUFI.str() );
			}

			if( anInstance != NULL )
			{
				if( aliasPath.nonempty() )
				{
					anInstance = new InstanceOfData(
							theSystemRID.getExecutable(),
							anInstance, aliasPath );

					anInstance->setCreatorContainerRID( theMachineID );
					anInstance->setRuntimeContainerRID( theMachineID );

					return( BF( anInstance ) );
				}

//				AVM_OS_TRACE << TAB << "Searching " << anUFI->str() << std::endl;
//				AVM_OS_TRACE << TAB << "Found " << std::endl;
//				anInstance->serialize(AVM_OS_TRACE << TAB);
//				AVM_OS_TRACE << std::flush;
			}
		}
	}

	return( BF::REF_NULL );
}


const BF & RuntimeQuery::searchVariable(const ExecutionData & anED,
		const RuntimeID & ctxRID, const ObjectElement * astElement) const
{
	if( anED.hasLocalRuntimeStack() )
	{
		StackOfLocalRuntime::
		reverse_iterator it = anED.getLocalRuntimes()->rbegin();
		StackOfLocalRuntime::
		reverse_iterator itEnd = anED.getLocalRuntimes()->rend();
		for(  ; it != itEnd ; ++it )
		{
			const BF & anInstance =
				(*it).getProgram()->getAllData().getByAstElement(astElement);
			if( anInstance.valid() )
			{
				return( anInstance );
			}
		}
	}

	TableOfRuntimeT::const_iterator itRF = anED.getTableOfRuntime().begin();
	TableOfRuntimeT::const_iterator endRF = anED.getTableOfRuntime().end();
	for( ; itRF != endRF ; ++itRF)
	{
		const BF & anInstance =
			(*itRF)->getExecutable()->getAllData().getByAstElement(astElement);
		if( anInstance.valid() )
		{
			return( anInstance );
		}
	}

	return( BF::REF_NULL );
}


BF RuntimeQuery::searchVariable(const ExecutionData & anED,
		const RuntimeID & ctxRID, const BF & aSymbolicParameter) const
{
	if( aSymbolicParameter.is< InstanceOfData >() )
	{
		InstanceOfData * aParamInstance =
				aSymbolicParameter.to_ptr< InstanceOfData >();

		RuntimeID aRID = aParamInstance->hasCreatorContainerRID() ?
				aParamInstance->getCreatorContainerRID() : ctxRID;

		const BF & foundVariable = aRID.getExecutable()->getymbolByAstElement(
				aParamInstance->getAstElement(), TYPE_UNIVERSAL_SPECIFIER);

		if( foundVariable.valid() )
		{
			return( foundVariable );
		}
		else
		{
			const BF & foundVariable = searchVariable(
					anED, ctxRID, aParamInstance->getAstElement() );

			if( foundVariable.valid() )
			{
				return( foundVariable );
			}
			else
			{
				const BF & foundVariable = searchVariable(anED, ctxRID,
						aParamInstance->getAstFullyQualifiedNameID() );

				if( foundVariable.valid() )
				{
					return( foundVariable );
				}
			}
		}
	}

	return( searchVariable(anED, ctxRID, aSymbolicParameter.str()) );
}


/**
 * SEARCH
 * Symbol
 * !UNUSED!
 *
BF RuntimeQuery::searchSymbol(TableOfSymbol & aliasTable,
		const ExecutionData & anED, UniFormIdentifier * anUFI)
{
	std::ostringstream osUFI;

	std::string aFullyQualifiedNameID = anUFI->str();

	{
		const BF & foundInstance =
				aliasTable.getByFQNameID( aFullyQualifiedNameID );
		if( foundInstance.valid() )
		{
			return( foundInstance );
		}
	}


	if( anED.hasLocalRuntimeStack() )
	{
		StackOfLocalRuntime::
		reverse_iterator it = anED.getLocalRuntimes()->rbegin();
		StackOfLocalRuntime::
		reverse_iterator itEnd = anED.getLocalRuntimes()->rend();
		for(  ; it != itEnd ; ++it )
		{
			const BF & anInstance = (*it).getProgram()->getAllData().
					getByFQNameID( aFullyQualifiedNameID );
			if( anInstance.valid() )
			{
				return( anInstance );
			}
		}
	}


	UniFormIdentifier::iterator it = anUFI->begin();
	UniFormIdentifier::iterator itEnd = anUFI->end();

	// recherche de la machine PRINCIPALE (ROOT)
	osUFI << "inst::" << (*it).str();

	const RuntimeID & theSystemRID = anED.getSystemRID();
	RuntimeID theMachineID = theSystemRID;

	for( ++it ; (it != itEnd) ; ++it )
	{
		if( theMachineID.getInstance()->fqnEquals( osUFI.str() ) )
		{
			break;
		}
		osUFI << "." << (*it).str();
	}

	if( it != itEnd )
	{
		VectorOfInstanceOfMachine aliasPath;

		RuntimeID aRID = theMachineID;

		// comme c'est la spec RID
//		aliasPath.append( theMachineID.getInstance() );

		// recherche de la machine FEUILLE
		for( ; it != itEnd ; ++it)
		{
			osUFI << "." << (*it).str();
			aRID = anED.getRuntime(aRID).getChild( osUFI.str() );
			if( aRID.valid() )
			{
				theMachineID = aRID;
				aliasPath.append( theMachineID.getInstance() );
			}
			else
			{
				break;
			}
		}

		if( (it == itEnd) && (theMachineID == theSystemRID) )
		{
			--it;
		}

		if( it != itEnd )
		{
			ExecutableForm * anExecutable = theMachineID.getExecutable();
			osUFI.str( "inst::" );
			osUFI << anExecutable->getFullyQualifiedNameID().substr( 6 );
			// 6 == "exec::".size()

			for( ; it != itEnd ; ++it)
			{
				osUFI << "." << (*it).str();
			}


			// The ORIGINAL INSTANCE
			BF anInstance = anExecutable->getAllData().
					getByFQNameID( osUFI.str() );

			if( anInstance.invalid() )
			{
				anInstance = anExecutable->getConstData().
						getByFQNameID( osUFI.str() );
			}
			if( anInstance.invalid() )
			{
				anInstance = anExecutable->getPort().
						getByFQNameID( osUFI.str() );
			}
			if( anInstance.invalid() )
			{
				anInstance = anExecutable->getBuffer().
						getByFQNameID( osUFI.str() );
			}
			if( anInstance.invalid() )
			{
				anInstance = anExecutable->getConnect().
						getByFQNameID( osUFI.str() );
			}

			if( anInstance.valid() )
			{

//				AVM_OS_TRACE << TAB << "Searching " << anUFI->str() << std::endl
//						<< TAB << "Found " << std::endl;
//				anInstance.toStream(AVM_OS_TRACE << TAB);
//				AVM_OS_TRACE << std::flush;

				if( aliasPath.nonempty() )
				{
					BaseInstanceForm * newInstance = NULL;

					switch ( anInstance.classKind() )
					{
						case FORM_INSTANCE_DATA_KIND:
						{
							newInstance = new InstanceOfData(
									theSystemRID.getExecutable(),
									anInstance.to_ptr< InstanceOfData >(),
									aliasPath);
							newInstance->setCreatorContainerRID( theMachineID );
							newInstance->setRuntimeContainerRID( theMachineID );
							aliasTable.save( newInstance );

							break;
						}

						case FORM_INSTANCE_MACHINE_KIND:
						{
							newInstance = new InstanceOfMachine(
									theSystemRID.getExecutable(),
									anInstance.to_ptr< InstanceOfMachine >(),
									aliasPath);
							newInstance->setCreatorContainerRID( theMachineID );
							newInstance->setRuntimeContainerRID( theMachineID );

							return( aliasTable.save( newInstance ) );
						}

						case FORM_INSTANCE_PORT_KIND:
						{
							newInstance = new InstanceOfPort(
									theSystemRID.getExecutable(),
									anInstance.to_ptr< InstanceOfPort >(),
									aliasPath);
							newInstance->setCreatorContainerRID( theMachineID );
							newInstance->setRuntimeContainerRID( theMachineID );

							return( aliasTable.save( newInstance ) );
						}

						case FORM_INSTANCE_BUFFER_KIND:
						{
							newInstance = new InstanceOfBuffer(
									theSystemRID.getExecutable(),
									anInstance.to_ptr< InstanceOfBuffer >(),
									aliasPath);
							newInstance->setCreatorContainerRID( theMachineID );
							newInstance->setRuntimeContainerRID( theMachineID );

							return( aliasTable.save( newInstance ) );
						}

						case FORM_INSTANCE_CONNECTOR_KIND:
						{
							newInstance = new InstanceOfConnect(
									theSystemRID.getExecutable(),
									anInstance.to_ptr< InstanceOfConnect >(),
									aliasPath);
							newInstance->setCreatorContainerRID( theMachineID );
							newInstance->setRuntimeContainerRID( theMachineID );

							return( aliasTable.save( newInstance ) );
						}

						default :
						{
							return( BF::REF_NULL );
						}
					}
				}
			}

			return( anInstance );
		}

		else if( aliasPath.nonempty() )
		{
			return( BF(	sep::incrReferenceCount(aliasPath.last()) ) );
		}

		else
		{
			AVM_OS_EXIT( FAILED )
					<< "Unfound leaf machine : << " << osUFI.str()
					<< " >> container of << " << aFullyQualifiedNameID << " >>"
					<< SEND_EXIT;
		}
	}

	return( BF::REF_NULL );
}

const BF & RuntimeQuery::searchSymbol(TableOfSymbol & aliasTable,
		const ExecutionData & anED, const ObjectElement * astElement)
{
	{
		const BF & foundInstance = aliasTable.getByAstElement(astElement);
		if( foundInstance.valid() )
		{
			return( foundInstance );
		}
	}

	if( anED.hasLocalRuntimeStack() )
	{
		StackOfLocalRuntime::
		reverse_iterator it = anED.getLocalRuntimes()->rbegin();
		StackOfLocalRuntime::
		reverse_iterator itEnd = anED.getLocalRuntimes()->rend();
		for(  ; it != itEnd ; ++it )
		{
			const BF & anInstance =
					(*it).getProgram()->getAllData().getByAstElement(astElement);
			if( anInstance.valid() )
			{
				return( anInstance );
			}
		}
	}

	{
		ExecutableQuery XQuery( mConfiguration );

		const BF & foundInstance = XQuery.getInstanceByAstElement(astElement);

		return( foundInstance );
	}
}


const BF & RuntimeQuery::searchSymbol(TableOfSymbol & aliasTable,
		const ExecutionData & anED, const BF & aBaseInstance)
{
	if( aliasTable.contains(aBaseInstance) )
	{
		return( aBaseInstance );
	}

	if( anED.hasLocalRuntimeStack() )
	{
		StackOfLocalRuntime::
		reverse_iterator it = anED.getLocalRuntimes()->rbegin();
		StackOfLocalRuntime::
		reverse_iterator itEnd = anED.getLocalRuntimes()->rend();
		for( ; it != itEnd ; ++it )
		{
			if( (*it).getProgram()->containsData( aBaseInstance ) )
			{
				return( aBaseInstance );
			}
		}
	}

	const RuntimeID & theSystemRID = anED.getSystemRID();

	VectorOfInstanceOfMachine aliasPath;

	TableOfRuntimeT::const_iterator itRF = anED.getTableOfRuntime().begin();
	TableOfRuntimeT::const_iterator endRF = anED.getTableOfRuntime().end();
	for( RuntimeID itRID ; itRF != endRF ; ++itRF)
	{
		itRID = (*itRF)->getRID();

		switch ( aBaseInstance.classKind() )
		{
			case FORM_INSTANCE_DATA_KIND:
			{
				if( itRID.getExecutable()->containsData(
						aBaseInstance.to_ptr< InstanceOfData >()) )
				{
					aliasPath.append( itRID.getInstance() );

					InstanceOfData * newInstance = new InstanceOfData(
						theSystemRID.getExecutable(),
						aBaseInstance.to_ptr< InstanceOfData >(), aliasPath );
					newInstance->setCreatorContainerRID( itRID );
					newInstance->setRuntimeContainerRID( itRID );

					aliasTable.save( newInstance );
				}

				break;
			}

			case FORM_INSTANCE_MACHINE_KIND:
			{
				if( itRID.getExecutable()->
						getInstanceStatic().contains(aBaseInstance) )
				{
					aliasPath.append( itRID.getInstance() );

					InstanceOfMachine * newInstance = new InstanceOfMachine(
							theSystemRID.getExecutable(),
							aBaseInstance.to_ptr< InstanceOfMachine >(),
							aliasPath );
					newInstance->setCreatorContainerRID( itRID );
					newInstance->setRuntimeContainerRID( itRID );

					aliasTable.save( newInstance );
				}
				break;
			}

			case FORM_INSTANCE_PORT_KIND:
			{
				if( itRID.getExecutable()->getPort().contains(aBaseInstance) )
				{
					aliasPath.append( itRID.getInstance() );

					InstanceOfPort * newInstance = new InstanceOfPort(
							theSystemRID.getExecutable(),
							aBaseInstance.to_ptr< InstanceOfPort >(), aliasPath );
					newInstance->setCreatorContainerRID( itRID );
					newInstance->setRuntimeContainerRID( itRID );

					aliasTable.save( newInstance );
				}
				break;
			}

			case FORM_INSTANCE_BUFFER_KIND:
			{
				InstanceOfBuffer * bufferInstance =
						aBaseInstance.to_ptr< InstanceOfBuffer >();

				if( itRID.getExecutable()->getBuffer().contains(bufferInstance) )
				{
					aliasPath.append( itRID.getInstance() );

					InstanceOfBuffer * newInstance = new InstanceOfBuffer(
							theSystemRID.getExecutable(),
							bufferInstance, aliasPath );
					newInstance->setCreatorContainerRID( itRID );
					newInstance->setRuntimeContainerRID( itRID );

					aliasTable.save( newInstance );
				}
				break;
			}

			case FORM_INSTANCE_CONNECTOR_KIND:
			{
				InstanceOfConnect * connectInstance =
						aBaseInstance.to_ptr< InstanceOfConnect >();

				if( itRID.getExecutable()->getConnect().contains(connectInstance) )
				{
					aliasPath.append( itRID.getInstance() );

					InstanceOfConnect * newInstance = new InstanceOfConnect(
							theSystemRID.getExecutable(),
							connectInstance, aliasPath );
					newInstance->setCreatorContainerRID( itRID );
					newInstance->setRuntimeContainerRID( itRID );

					aliasTable.save( newInstance );
				}
				break;
			}

			default :
			{
				break;
			}
		}
	}

	return( aBaseInstance );
}
*
* !UNUSED!
*/


////////////////////////////////////////////////////////////////////////////////
// LIFELINE API
////////////////////////////////////////////////////////////////////////////////

void RuntimeQuery::getSystemLifelines(Vector< RuntimeID > & lifelines) const
{
	const RuntimeForm & systemRF =
			mConfiguration.getMainExecutionData().getSystemRuntime();

	if( systemRF.hasChild() )
	{
		TableOfRuntimeID::const_iterator itRID = systemRF.beginChild();
		TableOfRuntimeID::const_iterator endRID = systemRF.endChild();
		for( ; itRID != endRID ; ++itRID)
		{
			lifelines.append( *itRID );
		}
	}
}


const RuntimeID & RuntimeQuery::getRuntineByQualifiedNameID(
		const std::string & aQualifiedNameID) const
{
	TableOfRuntimeT::const_iterator itRF =
			mConfiguration.getMainExecutionData().getTableOfRuntime().begin();
	TableOfRuntimeT::const_iterator endRF =
			mConfiguration.getMainExecutionData().getTableOfRuntime().end();
	for( ; itRF != endRF ; ++itRF)
	{
		if( NamedElement::fqnEndsWith(
				(*itRF)->getFullyQualifiedNameID(),aQualifiedNameID) )
		{
			return( (*itRF)->getRID() );
		}
	}

	return( RuntimeID::REF_NULL );
}


} /* namespace sep */