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

#ifndef ITYPESPECIFIER_H_
#define ITYPESPECIFIER_H_

#include <string>


namespace sep
{

class BF;


enum TYPE_SPECIFIER
{
	///////////////////
	// UNDEFINED
	///////////////////

	TYPE_UNDEFINED_SPECIFIER,

	//////////////////////////////
	// PRIMITIVE TYPE
	//////////////////////////////

	// ENUMERATION
	TYPE_BOOLEAN_SPECIFIER,

	TYPE_CHARACTER_SPECIFIER,

	TYPE_ENUM_SPECIFIER,

	// STRING
	TYPE_STRING_SPECIFIER,

	TYPE_IDENTIFIER_SPECIFIER,
	TYPE_QUALIFIED_IDENTIFIER_SPECIFIER,

	// NUMERIC
	TYPE_POS_INTEGER_SPECIFIER,

	TYPE_UINTEGER_SPECIFIER,

	TYPE_INTEGER_SPECIFIER,


	TYPE_URATIONAL_SPECIFIER,

	TYPE_RATIONAL_SPECIFIER,


	TYPE_UFLOAT_SPECIFIER,

	TYPE_FLOAT_SPECIFIER,


	TYPE_UREAL_SPECIFIER,

	TYPE_REAL_SPECIFIER,


	///////////////////
	// CLOCK / TIME TYPE
	///////////////////

	TYPE_CLOCK_SPECIFIER,

	TYPE_TIME_SPECIFIER,

	TYPE_CONTINUOUS_TIME_SPECIFIER,

	TYPE_DISCRETE_TIME_SPECIFIER,


	///////////////////
	// INTERVAL TYPE
	///////////////////

	TYPE_INTERVAL_SPECIFIER,


	//////////////////////////////
	// TABLE STRUCTURE
	//////////////////////////////

	// ARRAY
	TYPE_ARRAY_SPECIFIER,

	// BUILTIN ARRAY
//		TYPE_ARRAY_BOOLEAN_SPECIFIER,
//		TYPE_ARRAY_CHARACTER_SPECIFIER,
//		TYPE_ARRAY_INTEGER_SPECIFIER,
//		TYPE_ARRAY_FLOAT_SPECIFIER,
//
//		TYPE_ARRAY_STRING_SPECIFIER,
//		TYPE_ARRAY_IDENTIFIER_SPECIFIER,
//		TYPE_ARRAY_UFI_SPECIFIER,
//		TYPE_ARRAY_ENUM_SPECIFIER,
//
//		TYPE_ARRAY_FORM_SPECIFIER,


	//////////////////////////////
	// CONTAINER TYPE
	//////////////////////////////

	TYPE_FIFO_SPECIFIER,

	TYPE_LIFO_SPECIFIER,


	TYPE_MULTI_FIFO_SPECIFIER,

	TYPE_MULTI_LIFO_SPECIFIER,


	TYPE_RAM_SPECIFIER,


	TYPE_VECTOR_SPECIFIER,

	TYPE_REVERSE_VECTOR_SPECIFIER,

	TYPE_LIST_SPECIFIER,

	TYPE_SET_SPECIFIER,

	TYPE_MULTISET_SPECIFIER,

	//////////////////////////////
	// LAMBDA TYPE
	//////////////////////////////

	TYPE_LAMBDA_SPECIFIER,


	//////////////////////////////
	// COMPOSITE TYPE
	//////////////////////////////

	// USER CLASS STRUCTURE
	TYPE_CLASS_SPECIFIER,

	// USER UNION STRUCTURE
	TYPE_UNION_SPECIFIER,

	// USER CHOICE STRUCTURE
	TYPE_CHOICE_SPECIFIER,


	///////////////////
	// XLIA FORM TYPE
	///////////////////

	// OPERATOR
	TYPE_OPERATOR_SPECIFIER,

	// AVMCODE
	TYPE_AVMCODE_SPECIFIER,

	// CHANNEL
	TYPE_CHANNEL_SPECIFIER,

	// PORT
	TYPE_PORT_SPECIFIER,

	// MESSAGE
	TYPE_MESSAGE_SPECIFIER,

	// SIGNAL
	TYPE_SIGNAL_SPECIFIER,

	// BUFFER
	TYPE_BUFFER_SPECIFIER,

	// CONNECT
	TYPE_CONNECTOR_SPECIFIER,

	// MACHINE
	TYPE_MACHINE_SPECIFIER,


	///////////////////
	// ALIAS TYPEDEF
	///////////////////

	TYPE_ALIAS_SPECIFIER,


	///////////////////
	// UNIVERSAL TYPE
	///////////////////

	TYPE_UNIVERSAL_SPECIFIER,


	///////////////////
	// NULL TYPE
	///////////////////

	TYPE_NULL_SPECIFIER,


};


//typedef std::uint64_t         avm_type_specifier_kind_t;
typedef TYPE_SPECIFIER  avm_type_specifier_kind_t;


class BaseTypeSpecifier;


class ITypeSpecifier
{


public:

	/**
	 * DESTRUCTOR
	 */
	virtual ~ITypeSpecifier()
	{
		//!! NOTHING
	}


	/**
	 * GETTER
	 */

	virtual const BaseTypeSpecifier * thisTypeSpecifier() const = 0;

	virtual avm_type_specifier_kind_t getTypeSpecifierKind() const = 0;


	//////////////////////////////
	// TYPE ALGEBRA
	//////////////////////////////

	inline bool isTyped(avm_type_specifier_kind_t otherTSK)
	{
		return( getTypeSpecifierKind() == otherTSK );
	}

	bool isTypeFamily(avm_type_specifier_kind_t typeFamily);

	bool weaklyTyped(avm_type_specifier_kind_t otherTSK);


	//////////////////////////////
	// PRIMITIVE TYPE
	//////////////////////////////

	inline bool isTypedEnumeration() const
	{
		switch( getTypeSpecifierKind() )
		{
			case TYPE_BOOLEAN_SPECIFIER:
			case TYPE_CHARACTER_SPECIFIER:
			case TYPE_ENUM_SPECIFIER:
				return( true );

			default:
				return( false );
		}
	}

	inline bool isTypedBoolean() const
	{
		return( getTypeSpecifierKind() == TYPE_BOOLEAN_SPECIFIER );
	}

	inline bool isTypedCharacter() const
	{
		return( getTypeSpecifierKind() == TYPE_CHARACTER_SPECIFIER );
	}

	inline bool isTypedString() const
	{
		return( getTypeSpecifierKind() == TYPE_STRING_SPECIFIER );
	}

	inline bool isTypedEnum() const
	{
		return( getTypeSpecifierKind() == TYPE_ENUM_SPECIFIER );
	}


	inline bool isTypedIdentifier() const
	{
		return( getTypeSpecifierKind() == TYPE_IDENTIFIER_SPECIFIER );
	}

	inline bool isTypedQualifiedIdentifier() const
	{
		return( getTypeSpecifierKind() == TYPE_QUALIFIED_IDENTIFIER_SPECIFIER );
	}

	inline bool weaklyTypedIdentifier() const
	{
		return( (getTypeSpecifierKind() == TYPE_IDENTIFIER_SPECIFIER)
			 || (getTypeSpecifierKind() == TYPE_QUALIFIED_IDENTIFIER_SPECIFIER) );
	}


	bool isTypedNumeric() const;


	///////////////////
	// CLOCK TYPE
	///////////////////

	inline bool hasTypedClock() const
	{
		return( isTypedClock() );
	}

	inline bool isTypedClock() const
	{
		return( getTypeSpecifierKind() == TYPE_CLOCK_SPECIFIER );
	}

	bool weaklyTypedClockInteger() const;

	bool weaklyTypedClockRational() const;

	bool weaklyTypedClockFloat() const;

	bool weaklyTypedClockReal() const;


	///////////////////
	// TIME TYPE
	///////////////////

	inline bool hasTypedTime() const
	{
		return( (getTypeSpecifierKind() == TYPE_TIME_SPECIFIER)
			 || (getTypeSpecifierKind() == TYPE_DISCRETE_TIME_SPECIFIER)
			 || (getTypeSpecifierKind() == TYPE_CONTINUOUS_TIME_SPECIFIER) );
	}

	inline bool isTypedTime() const
	{
		return( getTypeSpecifierKind() == TYPE_TIME_SPECIFIER );
	}

	bool isTypedContinuousTime() const
	{
		return( getTypeSpecifierKind() == TYPE_CONTINUOUS_TIME_SPECIFIER );
	}

	bool isTypedDiscreteTime() const
	{
		return( getTypeSpecifierKind() == TYPE_DISCRETE_TIME_SPECIFIER );
	}

	bool weaklyTypedTimeInteger() const;

	bool weaklyTypedTimeFloat() const;

	bool weaklyTypedTimeRational() const;

	bool weaklyTypedTimeReal() const;


	///////////////////
	// CLOCK/TIME TYPE
	///////////////////

	inline bool hasTypedClockTime() const
	{
		return( hasTypedClock() || hasTypedTime() );
	}

	inline bool isTypedClockTime() const
	{
		return( isTypedClock() || isTypedTime() );
	}

	bool weaklyTypedClockTimeInteger() const;

	bool weaklyTypedClockTimeRational() const;

	bool weaklyTypedClockTimeFloat() const;

	bool weaklyTypedClockTimeReal() const;


	///////////////////
	// INTEGER TYPE
	///////////////////

	inline bool isTypedPosInteger() const
	{
		return( getTypeSpecifierKind() == TYPE_POS_INTEGER_SPECIFIER );
	}

	inline bool isTypedUInteger() const
	{
		return( (getTypeSpecifierKind() == TYPE_UINTEGER_SPECIFIER)
				|| isTypedPosInteger() );
	}

	bool weaklyTypedUInteger() const;

	inline bool isTypedInteger() const
	{
		return( (getTypeSpecifierKind() == TYPE_INTEGER_SPECIFIER)
				|| isTypedUInteger() );
	}

	bool weaklyTypedInteger() const;


	///////////////////
	// RATIONAL TYPE
	///////////////////

	inline bool isTypedURational() const
	{
		return( getTypeSpecifierKind() == TYPE_URATIONAL_SPECIFIER );
	}

	bool weaklyTypedURational() const;

	inline bool isTypedRational() const
	{
		return( (getTypeSpecifierKind() == TYPE_RATIONAL_SPECIFIER)
				|| isTypedURational() );
	}

	bool weaklyTypedRational() const;


	///////////////////
	// FLOAT TYPE
	///////////////////

	inline bool isTypedUFloat() const
	{
		return( getTypeSpecifierKind() == TYPE_UFLOAT_SPECIFIER );
	}

	bool weaklyTypedUFloat() const;

	inline bool isTypedFloat() const
	{
		return( (getTypeSpecifierKind() == TYPE_FLOAT_SPECIFIER)
				|| isTypedUFloat() );
	}

	bool weaklyTypedFloat() const;


	///////////////////
	// REAL TYPE
	///////////////////

	inline bool isTypedUReal() const
	{
		return( getTypeSpecifierKind() == TYPE_UREAL_SPECIFIER );
	}

	bool weaklyTypedUReal() const;

	inline bool isTypedReal() const
	{
		return( (getTypeSpecifierKind() == TYPE_REAL_SPECIFIER)
				|| isTypedUReal() );
	}

	bool weaklyTypedReal() const;


	///////////////////
	// INTERVAL TYPE
	///////////////////

	inline bool isTypedInterval() const
	{
		return( getTypeSpecifierKind() == TYPE_INTERVAL_SPECIFIER );
	}


	///////////////////
	// XKIA FORM TYPE
	///////////////////

	inline bool isTypedOperator() const
	{
		return( getTypeSpecifierKind() == TYPE_OPERATOR_SPECIFIER );
	}

	inline bool isTypedAvmcode() const
	{
		return( getTypeSpecifierKind() == TYPE_AVMCODE_SPECIFIER );
	}

	inline bool isTypedChannel() const
	{
		return( getTypeSpecifierKind() == TYPE_CHANNEL_SPECIFIER );
	}

	inline bool isTypedPort() const
	{
		return( getTypeSpecifierKind() == TYPE_PORT_SPECIFIER );
	}

	inline bool isTypedMessage() const
	{
		return( getTypeSpecifierKind() == TYPE_MESSAGE_SPECIFIER );
	}

	inline bool isTypedSignal() const
	{
		return( getTypeSpecifierKind() == TYPE_SIGNAL_SPECIFIER );
	}

	inline bool isTypedBuffer() const
	{
		return( getTypeSpecifierKind() == TYPE_BUFFER_SPECIFIER );
	}

	inline bool isTypedConnection() const
	{
		return( getTypeSpecifierKind() == TYPE_CONNECTOR_SPECIFIER );
	}

	inline bool isTypedMachine() const
	{
		return( getTypeSpecifierKind() == TYPE_MACHINE_SPECIFIER );
	}


	inline bool hasTypeXliaForm() const
	{
		switch( getTypeSpecifierKind() )
		{
			case TYPE_OPERATOR_SPECIFIER:
			case TYPE_AVMCODE_SPECIFIER:
			case TYPE_PORT_SPECIFIER:
			case TYPE_BUFFER_SPECIFIER:
			case TYPE_SIGNAL_SPECIFIER:
			case TYPE_CONNECTOR_SPECIFIER:
			case TYPE_MACHINE_SPECIFIER:
				return( true );

			default:
				return( false );
		}
	}


	//////////////////////////////
	// ARRAY TYPE
	//////////////////////////////

	inline bool isTypedArray() const
	{
		return( getTypeSpecifierKind() == TYPE_ARRAY_SPECIFIER );
	}


	//////////////////////////////
	// CONTAINER TYPE
	//////////////////////////////

	inline bool isTypedVector() const
	{
		return( getTypeSpecifierKind() == TYPE_VECTOR_SPECIFIER );
	}

	inline bool isTypedReverseVector() const
	{
		return( getTypeSpecifierKind() == TYPE_REVERSE_VECTOR_SPECIFIER );
	}

	inline bool hasTypeVector() const
	{
		switch( getTypeSpecifierKind() )
		{
			case TYPE_VECTOR_SPECIFIER:
			case TYPE_REVERSE_VECTOR_SPECIFIER:
				return( true );

			default:
				return( false );
		}
	}


	inline bool isTypedList() const
	{
		return( getTypeSpecifierKind() == TYPE_LIST_SPECIFIER );
	}

	inline bool isTypedSet() const
	{
		return( getTypeSpecifierKind() == TYPE_SET_SPECIFIER );
	}

	inline bool isTypedMultiset() const
	{
		return( getTypeSpecifierKind() == TYPE_MULTISET_SPECIFIER );
	}


	inline bool isTypedFifo() const
	{
		return( getTypeSpecifierKind() == TYPE_FIFO_SPECIFIER );
	}

	inline bool isTypedLifo() const
	{
		return( getTypeSpecifierKind() == TYPE_LIFO_SPECIFIER );
	}


	inline bool isTypedMultiFifo() const
	{
		return( getTypeSpecifierKind() == TYPE_MULTI_FIFO_SPECIFIER );
	}

	inline bool isTypedMultiLifo() const
	{
		return( getTypeSpecifierKind() == TYPE_MULTI_LIFO_SPECIFIER );
	}


	inline bool isTypedRam() const
	{
		return( getTypeSpecifierKind() == TYPE_RAM_SPECIFIER );
	}


	inline bool hasTypeArrayVector() const
	{
		switch( getTypeSpecifierKind() )
		{
			case TYPE_ARRAY_SPECIFIER:
			case TYPE_VECTOR_SPECIFIER:
			case TYPE_REVERSE_VECTOR_SPECIFIER:
				return( true );

			default:
				return( false );
		}
	}

	inline bool hasTypeQueue() const
	{
		switch( getTypeSpecifierKind() )
		{
			case TYPE_FIFO_SPECIFIER:
			case TYPE_LIFO_SPECIFIER:

			case TYPE_MULTI_FIFO_SPECIFIER:
			case TYPE_MULTI_LIFO_SPECIFIER:

			case TYPE_RAM_SPECIFIER:
				return( true );

			default:
				return( false );
		}
	}


	inline bool hasTypeListCollection() const
	{
		switch( getTypeSpecifierKind() )
		{
			case TYPE_LIST_SPECIFIER:
			case TYPE_SET_SPECIFIER:
			case TYPE_MULTISET_SPECIFIER:
				return( true );

			default:
				return( hasTypeQueue() );
		}
	}

	inline bool hasTypeCollection() const
	{
		return( hasTypeVector() || hasTypeListCollection() );
	}

	inline bool hasTypeContainer() const
	{
		return( isTypedArray() || hasTypeCollection() );
	}


	//////////////////////////////
	// COMPOSITE TYPE
	//////////////////////////////

	inline bool isTypedStructure() const
	{
		return( getTypeSpecifierKind() == TYPE_CLASS_SPECIFIER );
	}

	inline bool isTypedClass() const
	{
		return( getTypeSpecifierKind() == TYPE_CLASS_SPECIFIER );
	}


	inline bool isTypedChoice() const
	{
		return( getTypeSpecifierKind() == TYPE_CHOICE_SPECIFIER );
	}

	inline bool isTypedUnion() const
	{
		return( getTypeSpecifierKind() == TYPE_UNION_SPECIFIER );
	}

	inline bool hasTypeChoiceOrUnion() const
	{
		return( (getTypeSpecifierKind() == TYPE_CHOICE_SPECIFIER)
			 || (getTypeSpecifierKind() == TYPE_UNION_SPECIFIER) );
	}

	inline bool hasTypeStructureOrChoiceOrUnion() const
	{
		return( (getTypeSpecifierKind() == TYPE_CLASS_SPECIFIER  )
			 || (getTypeSpecifierKind() == TYPE_CHOICE_SPECIFIER )
			 || (getTypeSpecifierKind() == TYPE_UNION_SPECIFIER) );
	}


	//////////////////////////////
	// LAMBDA TYPE
	//////////////////////////////

	inline bool isTypedLambda() const
	{
		return( getTypeSpecifierKind() == TYPE_LAMBDA_SPECIFIER );
	}


	//////////////////////////////
	// ALIAS TYPE
	//////////////////////////////

	inline bool isTypedAlias() const
	{
		return( getTypeSpecifierKind() == TYPE_ALIAS_SPECIFIER );
	}


	//////////////////////////////
	// UNIVERSAL TYPE
	//////////////////////////////

	inline bool isTypedUniversal() const
	{
		return( getTypeSpecifierKind() == TYPE_UNIVERSAL_SPECIFIER );
	}


	//////////////////////////////
	// CATEGORY TYPE
	//////////////////////////////

	inline bool hasTypePrimitive() const
	{
		switch( getTypeSpecifierKind() )
		{
			case TYPE_BOOLEAN_SPECIFIER:
			case TYPE_CHARACTER_SPECIFIER:
			case TYPE_STRING_SPECIFIER:

			case TYPE_INTEGER_SPECIFIER:
			case TYPE_RATIONAL_SPECIFIER:
			case TYPE_FLOAT_SPECIFIER:
			case TYPE_REAL_SPECIFIER:

			case TYPE_POS_INTEGER_SPECIFIER:

			case TYPE_UINTEGER_SPECIFIER:
			case TYPE_URATIONAL_SPECIFIER:
			case TYPE_UFLOAT_SPECIFIER:
			case TYPE_UREAL_SPECIFIER:

			case TYPE_CLOCK_SPECIFIER:
			case TYPE_TIME_SPECIFIER:
			case TYPE_CONTINUOUS_TIME_SPECIFIER:
			case TYPE_DISCRETE_TIME_SPECIFIER:
				return( true );

			default:
				return( false );
		}
	}

	inline bool hasTypeBasic() const
	{
		return( isTypedBoolean()   || isTypedNumeric() ||
				isTypedCharacter() || isTypedString()  ||
				hasTypeXliaForm() );
	}

	inline bool hasTypeSimple() const
	{
		return( hasTypeBasic() || isTypedEnum() );
	}

	inline bool hasTypeSimpleOrCollection() const
	{
		return( hasTypeSimple() || hasTypeCollection() );
	}

	inline bool hasTypeArrayOrStructure() const
	{
		return( isTypedArray() || isTypedStructure() );
	}

	inline bool hasTypeComposite() const
	{
		return( hasTypeContainer() || isTypedStructure() );
	}


	inline bool hasTypeEnumOrComposite() const
	{
		return( isTypedEnum() || hasTypeComposite() );
	}


	/**
	 * Serialization
	 */
	std::string strSpecifierKind() const;

};


////////////////////////////////////////////////////////////////////////////////
// INTERVAL::KIND
////////////////////////////////////////////////////////////////////////////////

class IIntervalKind
{

public:

	enum KIND
	{
		CLOSED = 0x00,

		LOPEN  = 0x01,

		ROPEN  = 0x02,

		OPEN   = 0x03,
	};


	/**
	 * DESTRUCTOR
	 */
	virtual ~IIntervalKind()
	{
		//!! NOTHING
	}


	/**
	 * API
	 */
	virtual KIND getIntervalKind() const = 0;


	inline bool isCLOSED()const
	{
		return( getIntervalKind() == CLOSED );
	}

	inline bool isLOPEN()const
	{
		return( getIntervalKind() == LOPEN );
	}

	inline bool isROPEN()const
	{
		return( getIntervalKind() == ROPEN );
	}

	inline bool isOPEN()const
	{
		return( getIntervalKind() == OPEN );
	}


	inline bool isLClosed()const
	{
		return( (getIntervalKind() & LOPEN) == 0 );
	}

	inline bool isLOpen()const
	{
		return( (getIntervalKind() & LOPEN) != 0 );
	}

	inline bool isRClosed()const
	{
		return( (getIntervalKind() & ROPEN) == 0 );
	}

	inline bool isROpen()const
	{
		return( (getIntervalKind() & ROPEN) != 0 );
	}


	/**
	 * STATIC
	 */
	/**
	 * Compute interval nature
	 */
	inline static KIND computeKind(char left, char right)
	{
		bool lOpen = (left == ']') || (left == '(') || (left == ')');
		bool rOpen = (left == '[') || (left == ')') || (left == '(');

		return( lOpen ?
				( rOpen ? IIntervalKind::OPEN  : IIntervalKind::LOPEN  ) :
				( rOpen ? IIntervalKind::ROPEN : IIntervalKind::CLOSED ) );
	}


	static std::string to_string(KIND kind, const BF & inf, const BF & sup);

};


} /* namespace sep */
#endif /* ITYPESPECIFIER_H_ */