#ifndef _GLUVARTYPE_HPP
#define _GLUVARTYPE_HPP
/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL ES Utilities
 * ------------------------------------------------
 *
 * Copyright 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *//*!
 * \file
 * \brief Shader variable type.
 *//*--------------------------------------------------------------------*/

#include "tcuDefs.hpp"
#include "gluShaderUtil.hpp"

#include <vector>
#include <string>
#include <ostream>

namespace glu
{

class StructType;

/*--------------------------------------------------------------------*//*!
 * \brief Shader variable type.
 *
 * Variable type represents data type. No storage qualifiers are supported
 * since they are associated to a declaration, not to the variable type.
 *
 * \note Structs are handled using struct pointers since it is often desirable
 *		 to maintain unique list of struct declarations.
 *//*--------------------------------------------------------------------*/
class VarType
{
public:
						VarType			(void);
						VarType			(const VarType& other);

						VarType			(DataType basicType, Precision precision);		//!< Basic type constructor.
						VarType			(const VarType& elementType, int arraySize);	//!< Array type constructor.
	explicit			VarType			(const StructType* structPtr);					//!< Struct type constructor.
						~VarType		(void);

	bool				isBasicType		(void) const	{ return m_type == TYPE_BASIC;	}
	bool				isArrayType		(void) const	{ return m_type == TYPE_ARRAY;	}
	bool				isStructType	(void) const	{ return m_type == TYPE_STRUCT;	}

	DataType			getBasicType	(void) const	{ DE_ASSERT(isBasicType()); return m_data.basic.type;			}
	Precision			getPrecision	(void) const	{ DE_ASSERT(isBasicType()); return m_data.basic.precision;		}

	const VarType&		getElementType	(void) const	{ DE_ASSERT(isArrayType()); return *m_data.array.elementType;	}
	int					getArraySize	(void) const	{ DE_ASSERT(isArrayType()); return m_data.array.size;			}

	const StructType*	getStructPtr	(void) const	{ DE_ASSERT(isStructType()); return m_data.structPtr;			}

	int					getScalarSize	(void) const;

	VarType&			operator=		(const VarType& other);

	bool				operator==		(const VarType& other) const;
	bool				operator!=		(const VarType& other) const;

	enum
	{
		UNSIZED_ARRAY = -1 //!< Array length for unsized arrays.
	};

private:
	enum Type
	{
		TYPE_BASIC,
		TYPE_ARRAY,
		TYPE_STRUCT,

		TYPE_LAST
	};

	Type				m_type;
	union Data
	{
		// TYPE_BASIC
		struct
		{
			DataType		type;
			Precision		precision;
		} basic;

		// TYPE_ARRAY
		struct
		{
			VarType*		elementType;
			int				size;
		} array;

		// TYPE_STRUCT
		const StructType*	structPtr;

		Data (void)
		{
			array.elementType	= DE_NULL;
			array.size			= 0;
		};
	} m_data;
};

template <typename T>
inline VarType varTypeOf (Precision prec = PRECISION_LAST) { return VarType(dataTypeOf<T>(), prec); }

class StructMember
{
public:
						StructMember	(const char* name, const VarType& type) : m_name(name), m_type(type) {}
						StructMember	(void) {}

	const char*			getName			(void) const { return m_name.c_str();	}
	const VarType&		getType			(void) const { return m_type;			}

	bool				operator==		(const StructMember& other) const;
	bool				operator!=		(const StructMember& other) const;

private:
	std::string			m_name;
	VarType				m_type;
};

class StructType
{
public:
	typedef std::vector<StructMember>::iterator			Iterator;
	typedef std::vector<StructMember>::const_iterator	ConstIterator;

								StructType		(const char* typeName) : m_typeName(typeName) {}
								~StructType		(void) {}

	bool						hasTypeName		(void) const	{ return !m_typeName.empty();	}
	const char*					getTypeName		(void) const	{ return hasTypeName() ? m_typeName.c_str() : DE_NULL; }

	void						addMember		(const char* name, const VarType& type);

	int							getNumMembers	(void) const	{ return (int)m_members.size();	}
	const StructMember&			getMember		(int ndx) const	{ return m_members[ndx];		}

	inline Iterator				begin			(void)			{ return m_members.begin();		}
	inline ConstIterator		begin			(void) const	{ return m_members.begin();		}
	inline Iterator				end				(void)			{ return m_members.end();		}
	inline ConstIterator		end				(void) const	{ return m_members.end();		}

	bool						operator==		(const StructType& other) const;
	bool						operator!=		(const StructType& other) const;

private:
	std::string					m_typeName;
	std::vector<StructMember>	m_members;
};

enum Storage
{
	STORAGE_IN = 0,
	STORAGE_OUT,
	STORAGE_CONST,
	STORAGE_UNIFORM,
	STORAGE_BUFFER,
	STORAGE_LAST
};

const char* getStorageName (Storage storage);

enum Interpolation
{
	INTERPOLATION_SMOOTH = 0,
	INTERPOLATION_FLAT,
	INTERPOLATION_CENTROID,
	INTERPOLATION_LAST
};

const char* getInterpolationName (Interpolation interpolation);

enum FormatLayout
{
	FORMATLAYOUT_RGBA32F = 0,
	FORMATLAYOUT_RGBA16F,
	FORMATLAYOUT_R32F,
	FORMATLAYOUT_RGBA8,
	FORMATLAYOUT_RGBA8_SNORM,

	FORMATLAYOUT_RGBA32I,
	FORMATLAYOUT_RGBA16I,
	FORMATLAYOUT_RGBA8I,
	FORMATLAYOUT_R32I,

	FORMATLAYOUT_RGBA32UI,
	FORMATLAYOUT_RGBA16UI,
	FORMATLAYOUT_RGBA8UI,
	FORMATLAYOUT_R32UI,

	FORMATLAYOUT_LAST
};

const char* getFormatLayoutName (FormatLayout layout);

enum MemoryAccessQualifier
{
	MEMORYACCESSQUALIFIER_COHERENT_BIT	= 0x01,
	MEMORYACCESSQUALIFIER_VOLATILE_BIT	= 0x02,
	MEMORYACCESSQUALIFIER_RESTRICT_BIT	= 0x04,
	MEMORYACCESSQUALIFIER_READONLY_BIT	= 0x08,
	MEMORYACCESSQUALIFIER_WRITEONLY_BIT	= 0x10,

	MEMORYACCESSQUALIFIER_MASK = (MEMORYACCESSQUALIFIER_WRITEONLY_BIT << 1) - 1
};

const char* getMemoryAccessQualifierName (MemoryAccessQualifier qualifier);

enum MatrixOrder
{
	MATRIXORDER_COLUMN_MAJOR = 0,
	MATRIXORDER_ROW_MAJOR,

	MATRIXORDER_LAST
};

const char* getMatrixOrderName (MatrixOrder qualifier);

// Declaration utilities.

struct Layout
{
					Layout			(int location_ = -1, int binding_ = -1, int offset_ = -1, FormatLayout format_ = FORMATLAYOUT_LAST, MatrixOrder matrixOrder_ = MATRIXORDER_LAST);

	bool			operator==		(const Layout& other) const;
	bool			operator!=		(const Layout& other) const;

	int				location;
	int				binding;
	int				offset;
	FormatLayout	format;
	MatrixOrder		matrixOrder;
};

struct VariableDeclaration
{
						VariableDeclaration	(const VarType& varType_, const std::string& name_, Storage storage_ = STORAGE_LAST, Interpolation interpolation_ = INTERPOLATION_LAST, const Layout& layout_ = Layout(), deUint32 memoryAccessQualifierBits_ = 0);

	bool				operator==			(const VariableDeclaration& other) const;
	bool				operator!=			(const VariableDeclaration& other) const;

	Layout				layout;
	Interpolation		interpolation;
	Storage				storage;
	VarType				varType;
	deUint32			memoryAccessQualifierBits;
	std::string			name;
};

struct InterfaceBlock
{
											InterfaceBlock	(void);

	glu::Layout								layout;
	Storage									storage;
	int										memoryAccessQualifierFlags;
	std::string								interfaceName;
	std::string								instanceName;
	std::vector<glu::VariableDeclaration>	variables;
	std::vector<int>						dimensions;
};

//! Internals for declare() utilities.
namespace decl
{

struct Indent
{
	int level;
	Indent (int level_) : level(level_) {}
};

struct DeclareStructTypePtr
{
	DeclareStructTypePtr (const StructType* structPtr_, int indentLevel_) : structPtr(structPtr_), indentLevel(indentLevel_) {}

	const StructType*	structPtr;
	int					indentLevel;
};

struct DeclareStructType
{
	DeclareStructType (const StructType& structType_, int indentLevel_) : structType(structType_), indentLevel(indentLevel_) {}

	StructType			structType;
	int					indentLevel;
};

struct DeclareVariable
{
	DeclareVariable (const VarType& varType_, const std::string& name_, int indentLevel_) : varType(varType_), name(name_), indentLevel(indentLevel_) {}

	VarType				varType;
	std::string			name;
	int					indentLevel;
};

std::ostream&		operator<<		(std::ostream& str, const Indent&				indent);
std::ostream&		operator<<		(std::ostream& str, const DeclareStructTypePtr&	decl);
std::ostream&		operator<<		(std::ostream& str, const DeclareStructType&	decl);
std::ostream&		operator<<		(std::ostream& str, const DeclareVariable&		decl);

} // decl

inline decl::Indent					indent			(int indentLevel)														{ return decl::Indent(indentLevel);									}
inline decl::DeclareStructTypePtr	declare			(const StructType*	structPtr,	int indentLevel = 0)					{ return decl::DeclareStructTypePtr	(structPtr,		indentLevel);	}
inline decl::DeclareStructType		declare			(const StructType&	structType,	int indentLevel = 0)					{ return decl::DeclareStructType	(structType,	indentLevel);	}
inline decl::DeclareVariable		declare			(const VarType& varType, const std::string& name, int indentLevel = 0)	{ return decl::DeclareVariable		(varType, name, indentLevel);	}

std::ostream&						operator<<		(std::ostream& str, const Layout& decl);
std::ostream&						operator<<		(std::ostream& str, const VariableDeclaration& decl);

} // glu

#endif // _GLUVARTYPE_HPP