/*******************************************************************************
 * 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: 5 août 2008
 *
 * Contributors:
 *  Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr
 *   - Initial API and implementation
 ******************************************************************************/

#ifndef INSTANCEOFPORT_H_
#define INSTANCEOFPORT_H_

#include <fml/executable/BaseInstanceForm.h>

#include <common/AvmPointer.h>

#include <fml/lib/IComPoint.h>

#include <fml/executable/InstanceOfData.h>
#include <fml/executable/RoutingData.h>

#include <fml/type/BaseTypeSpecifier.h>

#include <fml/infrastructure/Channel.h>
#include <fml/infrastructure/Port.h>


namespace sep
{

class ArrayBF;
class BaseAvmProgram;
class RoutingData;


class InstanceOfPort :
		public BaseInstanceForm,
		public IComPoint,
		AVM_INJECT_INSTANCE_COUNTER_CLASS( InstanceOfPort )
{

	AVM_DECLARE_CLONABLE_CLASS( InstanceOfPort )


protected:
	/*
	 * ATTRIBUTES
	 */
	avm_size_t mRouteOffset;

	// the nature
	ENUM_IO_NATURE mComPointNature;

	// the Parameter Type Specifier
	ArrayOfBF mParameters;

	// the Contents of the port as channel
	TableOfSymbol mContents;

	InstanceOfPort * mRoutingChannel;

	// The routing data access optimization
	RoutingData mInputRoutingData;
	RoutingData mOutputRoutingData;


public:
	/**
	 * CONSTRUCTOR
	 * Default
	 */
	InstanceOfPort(BaseAvmProgram * aContainer,
			PropertyElement * aCompiled, avm_offset_t anOffset,
			avm_size_t aParameterCount, ENUM_IO_NATURE aNature);


	/**
	 * CONSTRUCTOR
	 * copy
	 */
	InstanceOfPort(const InstanceOfPort & aPort)
	: BaseInstanceForm( aPort ),
	mRouteOffset( aPort.mRouteOffset ),
	mComPointNature( aPort.mComPointNature ),

	mParameters( aPort.mParameters ),
	mContents( aPort.mContents ),

	mRoutingChannel( aPort.mRoutingChannel ),

	mInputRoutingData( aPort.mInputRoutingData ),
	mOutputRoutingData( aPort.mOutputRoutingData )
	{
		//!! NOTHING
//		AVM_OS_TRACE << "port::new :> " << getFullyQualifiedNameID() << std::endl;
	}


	/**
	 * CONSTRUCTOR
	 * via Channel
	 */
	InstanceOfPort(BaseAvmProgram * aContainer, Port * chanPortCompiled,
			InstanceOfPort * aChannel, InstanceOfPort * aTarget)
	: BaseInstanceForm(CLASS_KIND_T( InstanceOfPort ),
			aContainer, chanPortCompiled, aTarget),
	mRouteOffset( aTarget->mRouteOffset ),
	mComPointNature( aTarget->mComPointNature ),

	mParameters( aTarget->mParameters ),
	mContents( aTarget->mContents ),

	mRoutingChannel( aChannel ),

	mInputRoutingData( ),
	mOutputRoutingData( )

	{
		setAliasTarget( aTarget );
//		AVM_OS_TRACE << "port::new :> " << getFullyQualifiedNameID() << std::endl;
	}


	/**
	 * CONSTRUCTOR
	 * for Alias
	 */
	InstanceOfPort(BaseAvmProgram * aContainer, InstanceOfPort * aTarget,
			VectorOfInstanceOfMachine & aRelativeMachinePath)
	: BaseInstanceForm(CLASS_KIND_T( InstanceOfPort ), aContainer, aTarget,
			aRelativeMachinePath),
	mRouteOffset( aTarget->mRouteOffset ),
	mComPointNature( aTarget->mComPointNature ),

	mParameters( aTarget->mParameters ),
	mContents( aTarget->mContents ),

	mRoutingChannel( aTarget->mRoutingChannel ),

	mInputRoutingData( ),
	mOutputRoutingData( )

	{
		//!! NOTHING
//		AVM_OS_TRACE << "port::new :> " << getFullyQualifiedNameID() << std::endl;
	}


	/**
	 * DESTRUCTOR
	 */
	virtual ~InstanceOfPort()
	{
//		AVM_OS_TRACE << "port::delete :> " << getFullyQualifiedNameID() << std::endl;
		//!! NOTHING
	}


	/**
	 * Factory
	 * new Port à Channel
	 */
	static InstanceOfPort * newChannel(BaseAvmProgram * aContainer,
			Channel * aCompiled, avm_offset_t anOffset)
	{
		return( new InstanceOfPort(aContainer, aCompiled,
				anOffset, 0, IO_CHANNEL_NATURE) );
	}

	/**
	 * GETTER - SETTER
	 * mRouteOffset
	 */
	inline avm_size_t getRouteOffset() const
	{
		return( mRouteOffset );
	}

	inline void setRouteOffset(avm_size_t aRouteOffset)
	{
		mRouteOffset = aRouteOffset;
	}


	/**
	 * API
	 * IComPoint
	 * mComPointNature
	 * mComPointDirection
	 */
	inline virtual ENUM_IO_NATURE getComPointNature() const
	{
		return( mComPointNature );
	}


	/**
	 * GETTER - SETTER
	 * mParameters
	 */
	inline ArrayOfBF & getParameters()
	{
		return( mParameters );
	}

	inline const ArrayOfBF & getParameters() const
	{
		return( mParameters );
	}


	inline const BF & getParameter(avm_size_t offset) const
	{
		return( mParameters[offset] );
	}

	inline BaseTypeSpecifier * getParameterType(avm_size_t offset) const
	{
		if( mParameters[offset].is< BaseTypeSpecifier >() )
		{
			return( mParameters[offset].to_ptr< BaseTypeSpecifier >() );
		}
		else if( mParameters[offset].is< BaseInstanceForm >() )
		{
			return( mParameters[offset].
					to_ptr< BaseInstanceForm >()->getTypeSpecifier() );
		}
		return( NULL );
	}


	inline avm_size_t getParameterCount() const
	{
		return( mParameters.size() );
	}


	inline bool hasParameter() const
	{
		return( getParameterCount() > 0 );
	}

	inline bool hasParameterType(avm_size_t offset) const
	{
		if( offset < getParameterCount() )
		{
			if( mParameters[offset].is< BaseTypeSpecifier >() )
			{
				return( true );
			}
			else if( mParameters[offset].is< BaseInstanceForm >() )
			{
				return( mParameters[offset].
						to_ptr< BaseInstanceForm >()->hasTypeSpecifier() );
			}
		}
		return( false );
	}

	inline bool isParameterData(avm_size_t offset) const
	{
		return( mParameters[offset].is< InstanceOfData >() );
	}


	inline void setParameter(avm_size_t index, const BF & aParam)
	{
		mParameters[index]= aParam;
	}


	/**
	 * GETTER - SETTER
	 * mContents
	 */
	inline void appendContent(const Symbol & aSymbol)
	{
		AVM_OS_ASSERT_FATAL_NULL_SMART_POINTER_EXIT( aSymbol )
				<< "Symbol as Channel content !!!"
				<< SEND_EXIT;

		mContents.append(aSymbol);
	}

	inline TableOfSymbol & getContents()
	{
		return( mContents );
	}

	inline const TableOfSymbol & getContents() const
	{
		return( mContents );
	}


	inline const BF & getContent(avm_size_t offset) const
	{
		return( mContents[offset] );
	}


	inline avm_size_t getContentCount() const
	{
		return( mContents.size() );
	}


	inline bool hasContent() const
	{
		return( getContentCount() > 0 );
	}


	inline bool isContentData(avm_size_t offset) const
	{
		return( mContents[offset].is< InstanceOfData >() );
	}

	inline bool isContentPort(avm_size_t offset) const
	{
		return( mContents[offset].is< InstanceOfPort >() );
	}


	inline void setContent(avm_size_t index, const Symbol & aSymbol)
	{
		mContents[index]= aSymbol;
	}


	/**
	 * GETTER - SETTER
	 * mRoutingChannel
	 */
	inline InstanceOfPort * getRoutingChannel() const
	{
		return( mRoutingChannel );
	}

	inline bool hasRoutingChannel() const
	{
		return( mRoutingChannel != NULL );
	}

	inline void setRoutingChannel(InstanceOfPort * aRoutingChannel)
	{
		mRoutingChannel = aRoutingChannel;
	}


	/**
	 * GETTER - SETTER
	 * mInputRoutingData
	 */
	inline const RoutingData & getInputRoutingData() const
	{
		return( mInputRoutingData );
	}

	inline bool hasInputRoutingData() const
	{
		return( mInputRoutingData != NULL );
	}

	inline void setInputRoutingData(const RoutingData & anInputRoutingData)
	{
		mInputRoutingData = anInputRoutingData;
	}


	/**
	 * GETTER - SETTER
	 * mOutputRoutingData
	 */
	inline const RoutingData & getOutputRoutingData() const
	{
		return( mOutputRoutingData );
	}

	inline bool hasOutputRoutingData() const
	{
		return( mOutputRoutingData != NULL );
	}

	inline void setOutputRoutingData(const RoutingData & anOutputRoutingData)
	{
		mOutputRoutingData = anOutputRoutingData;
	}


	/**
	 * Format a value w.r.t. its type
	 */
	virtual void formatStream(OutStream & out, const BF & bfValue) const;

	virtual void formatStream(OutStream & out, const ArrayBF & arrayValue) const;


	/**
	 * Serialization
	 */
	void strParameter(OutStream & out, const BF & aParameter) const;
	void strParameter(OutStream & out) const;

	void strHeader(OutStream & out) const;

	std::string strArg() const;

	void toStream(OutStream & out) const;

};


}

#endif /* INSTANCEOFPORT_H_ */