#ifndef _VKTTRANSFORMFEEDBACKFUZZLAYOUTCASE_HPP
#define _VKTTRANSFORMFEEDBACKFUZZLAYOUTCASE_HPP
/*------------------------------------------------------------------------
 * Vulkan Conformance Tests
 * ------------------------
 *
 * Copyright (c) 2015 The Khronos Group Inc.
 * Copyright (c) 2015 Samsung Electronics Co., Ltd.
 * Copyright (c) 2018 The Khronos Group Inc.
 *
 * 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 Vulkan Transform Feedback Fuzz Layout Tests
 *//*--------------------------------------------------------------------*/

#include "deSharedPtr.hpp"
#include "vktTestCase.hpp"
#include "tcuDefs.hpp"
#include "gluShaderUtil.hpp"

#include <map>

namespace vkt
{
namespace TransformFeedback
{

// Interface block details.

enum InterfaceFlags
{
	PRECISION_LOW			= (1<<0),
	PRECISION_MEDIUM		= (1<<1),
	PRECISION_HIGH			= (1<<2),
	PRECISION_MASK			= PRECISION_LOW|PRECISION_MEDIUM|PRECISION_HIGH,

	LAYOUT_XFBBUFFER		= (1<<3),
	LAYOUT_XFBOFFSET		= (1<<4),
	LAYOUT_XFBSTRIDE		= (1<<5),
	LAYOUT_MASK				= LAYOUT_XFBBUFFER|LAYOUT_XFBOFFSET|LAYOUT_XFBSTRIDE,

	FIELD_UNASSIGNED		= (1<<6),	//!< Interface or struct member is not used in shader.
	FIELD_MISSING			= (1<<7),	//!< Interface or struct member will be commented out in shader.
	FIELD_OPTIONS			= FIELD_UNASSIGNED|FIELD_MISSING,
};

enum MatrixLoadFlags
{
	LOAD_FULL_MATRIX		= 0,
	LOAD_MATRIX_COMPONENTS	= 1,
};

enum TestStageFlags
{
	TEST_STAGE_VERTEX	= 0,
	TEST_STAGE_GEOMETRY	= 1,
};

class StructType;

class VarType
{
public:
						VarType			(void);
						VarType			(const VarType& other);
						VarType			(glu::DataType basicType, deUint32 flags);
						VarType			(const VarType& elementType, int arraySize);
	explicit			VarType			(const StructType* structPtr, deUint32 flags = 0u);
						~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;	}

	deUint32			getFlags		(void) const	{ return m_flags;					}
	glu::DataType		getBasicType	(void) const	{ return m_data.basicType;			}

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

	const StructType&	getStruct		(void) const	{ return *m_data.structPtr;			}

	VarType&			operator=		(const VarType& other);

private:
	enum Type
	{
		TYPE_BASIC,
		TYPE_ARRAY,
		TYPE_STRUCT,

		TYPE_LAST
	};

	Type				m_type;
	deUint32			m_flags;
	union Data
	{
		glu::DataType		basicType;
		struct
		{
			VarType*		elementType;
			int				size;
		} array;
		const StructType*	structPtr;

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

class StructMember
{
public:
						StructMember	(const std::string& name, const VarType& type, deUint32 flags)
							: m_name(name)
							, m_type(type)
							, m_flags(flags)
						{}

						StructMember	(void)
							: m_flags(0)
						{}

	const std::string&	getName			(void) const { return m_name;	}
	const VarType&		getType			(void) const { return m_type;	}
	deUint32			getFlags		(void) const { return m_flags;	}

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

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

								StructType		(const std::string& typeName) : m_typeName(typeName) {}
								~StructType		(void) {}

	const std::string&			getTypeName		(void) const	{ return m_typeName;			}
	bool						hasTypeName		(void) const	{ return !m_typeName.empty();	}

	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();		}

	void						addMember		(const std::string& name, const VarType& type, deUint32 flags = 0);

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

class InterfaceBlockMember
{
public:
						InterfaceBlockMember	(const std::string& name, const VarType& type, deUint32 flags = 0);

	const std::string&	getName					(void) const { return m_name;	}
	const VarType&		getType					(void) const { return m_type;	}
	deUint32			getFlags				(void) const { return m_flags;	}

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

class InterfaceBlock
{
public:
	typedef std::vector<InterfaceBlockMember>::iterator			Iterator;
	typedef std::vector<InterfaceBlockMember>::const_iterator	ConstIterator;

										InterfaceBlock		(const std::string& blockName);

	const std::string&					getBlockName		(void) const { return m_blockName;				}
	bool								hasInstanceName		(void) const { return !m_instanceName.empty();	}
	const std::string&					getInstanceName		(void) const { return m_instanceName;			}
	bool								isArray				(void) const { return m_arraySize > 0;			}
	int									getArraySize		(void) const { return m_arraySize;				}
	int									getXfbBuffer		(void) const { return m_xfbBuffer;				}
	deUint32							getFlags			(void) const { return m_flags;					}

	void								setInstanceName		(const std::string& name)							{ m_instanceName = name;						}
	void								setFlags			(deUint32 flags)									{ m_flags = flags;								}
	void								setFlag				(deUint32 flag)										{ m_flags |= flag;								}
	void								setArraySize		(int arraySize)										{ m_arraySize = arraySize;						}
	void								setXfbBuffer		(int xfbBuffer)										{ m_xfbBuffer = xfbBuffer;						}
	void								addInterfaceMember	(const InterfaceBlockMember& interfaceBlockMember)	{ m_members.push_back(interfaceBlockMember);	}

	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();		}

private:
	std::string							m_blockName;
	std::string							m_instanceName;
	std::vector<InterfaceBlockMember>	m_members;
	int									m_xfbBuffer;
	int									m_arraySize;	//!< Array size or 0 if not interface block array.
	deUint32							m_flags;
};

typedef de::SharedPtr<StructType>		StructTypeSP;
typedef de::SharedPtr<InterfaceBlock>	InterfaceBlockSP;

class ShaderInterface
{
public:
									ShaderInterface				(void);
									~ShaderInterface			(void);

	StructType&						allocStruct					(const std::string& name);
	void							getNamedStructs				(std::vector<const StructType*>& structs) const;

	InterfaceBlock&					allocBlock					(const std::string& name);

	int								getNumInterfaceBlocks		(void) const	{ return (int)m_interfaceBlocks.size();	}
	const InterfaceBlock&			getInterfaceBlock			(int ndx) const	{ return *m_interfaceBlocks[ndx];		}
	InterfaceBlock&					getInterfaceBlockForModify	(int ndx)		{ return *m_interfaceBlocks[ndx];		}

private:
	std::vector<StructTypeSP>		m_structs;
	std::vector<InterfaceBlockSP>	m_interfaceBlocks;
};

struct BlockLayoutEntry
{
	BlockLayoutEntry (void)
		: xfbBuffer				(-1)
		, xfbOffset				(-1)
		, xfbSize				(0)
		, xfbStride				(0)
		, blockDeclarationNdx	(-1)
		, instanceNdx			(-1)
		, locationNdx			(-1)
		, locationSize			(-1)
	{
	}

	std::string			name;
	int					xfbBuffer;
	int					xfbOffset;
	int					xfbSize;
	int					xfbStride;
	std::vector<int>	activeInterfaceIndices;
	int					blockDeclarationNdx;
	int					instanceNdx;
	// Location are not used for transform feedback, but they must be not overlap to pass GLSL compiler
	int					locationNdx;
	int					locationSize;
};

struct InterfaceLayoutEntry
{
	InterfaceLayoutEntry (void)
		: type			(glu::TYPE_LAST)
		, arraySize		(0)
		, blockLayoutNdx(-1)
		, offset		(-1)
		, arrayStride	(-1)
		, matrixStride	(-1)
		, instanceNdx	(0)
		, locationNdx	(-1)
		, validate		(true)
	{
	}

	std::string			name;
	glu::DataType		type;
	int					arraySize;
	int					blockLayoutNdx;
	int					offset;
	int					arrayStride;
	int					matrixStride;
	int					instanceNdx;
	// Location are not used for transform feedback, but they must be not overlap to pass GLSL compiler
	int					locationNdx;
	bool				validate;
};

class InterfaceLayout
{
public:
	std::vector<BlockLayoutEntry>		blocks;
	std::vector<InterfaceLayoutEntry>	interfaces;

	int									getInterfaceLayoutIndex	(int blockDeclarationNdx, const std::string& name) const;
	int									getBlockLayoutIndex		(int blockDeclarationNdx, int instanceNdx) const;
};

typedef std::vector<vk::VkDeviceSize> DeviceSizeVector;

class InterfaceBlockCase : public vkt::TestCase
{
public:
							InterfaceBlockCase			(tcu::TestContext&		testCtx,
														 const std::string&		name,
														 const std::string&		description,
														 MatrixLoadFlags		matrixLoadFlag,
														 TestStageFlags			testStageFlag,
														 bool					shuffleInterfaceMembers = false);
							~InterfaceBlockCase			(void);

	virtual void			delayedInit					(void);
	virtual	void			initPrograms				(vk::SourceCollections&	programCollection) const;
	virtual TestInstance*	createInstance				(Context&				context) const;

protected:
	ShaderInterface			m_interface;
	MatrixLoadFlags			m_matrixLoadFlag;
	TestStageFlags			m_testStageFlags;
	bool					m_shuffleInterfaceMembers;	//!< Used with explicit offsets to test out of order member offsets
	deUint32				m_locationsRequired;

private:
	std::string				m_vertShaderSource;
	std::string				m_geomShaderSource;

	std::vector<deUint8>	m_data;						//!< Data.
	DeviceSizeVector		m_tfBufBindingSizes;
	DeviceSizeVector		m_tfBufBindingOffsets;
	std::map<int, void*>	m_blockPointers;			//!< Reference block pointers.
	InterfaceLayout			m_interfaceLayout;			//!< interface layout.
};

} // TransformFeedback
} // vkt

#endif // _VKTTRANSFORMFEEDBACKFUZZLAYOUTCASE_HPP