#ifndef _GLSLONGSTRESSCASE_HPP
#define _GLSLONGSTRESSCASE_HPP
/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL (ES) Module
 * -----------------------------------------------
 *
 * 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 Parametrized, long-running stress case.
 *//*--------------------------------------------------------------------*/

#include "tcuDefs.hpp"
#include "tcuTestCase.hpp"
#include "tcuTexture.hpp"
#include "tcuMatrix.hpp"
#include "gluRenderContext.hpp"
#include "gluShaderUtil.hpp"
#include "glsTextureTestUtil.hpp"
#include "deRandom.hpp"
#include "deSharedPtr.hpp"

#include <string>
#include <vector>
#include <map>

namespace deqp
{
namespace gls
{

namespace LongStressCaseInternal
{

template <typename T> class GLObjectManager;
class Program;
class Buffer;
class Texture;
class DebugInfoRenderer;

}

struct VarSpec
{
	union Value
	{
		float	f[4*4]; // \note Matrices are stored in column major order.
		int		i[4];
	};

	std::string		name;
	glu::DataType	type;
	Value			minValue;
	Value			maxValue;

	template <typename T>
	VarSpec (const std::string& name_, const T& minValue_, const T& maxValue_)	: name(name_) { set(minValue_, maxValue_); }

	template <typename T>
	VarSpec (const std::string& name_, const T& value)							: name(name_) { set(value, value); }

	void set (float minValue_, float maxValue_)
	{
		type			= glu::TYPE_FLOAT;
		minValue.f[0]	= minValue_;
		maxValue.f[0]	= maxValue_;
	}

	template <int ValSize>
	void set (const tcu::Vector<float, ValSize>& minValue_, const tcu::Vector<float, ValSize>& maxValue_)
	{
		type = glu::getDataTypeFloatVec(ValSize);
		vecToArr(minValue_, minValue.f);
		vecToArr(maxValue_, maxValue.f);
	}

	template <int ValRows, int ValCols>
	void set (const tcu::Matrix<float, ValRows, ValCols>& minValue_, const tcu::Matrix<float, ValRows, ValCols>& maxValue_)
	{
		type = glu::getDataTypeMatrix(ValCols, ValRows);
		matToArr(minValue_, minValue.f);
		matToArr(maxValue_, maxValue.f);
	}

	void set (int minValue_, int maxValue_)
	{
		type			= glu::TYPE_INT;
		minValue.i[0]	= minValue_;
		maxValue.i[0]	= maxValue_;
	}

	template <int ValSize>
	void set (const tcu::Vector<int, ValSize>& minValue_, const tcu::Vector<int, ValSize>& maxValue_)
	{
		type = glu::getDataTypeVector(glu::TYPE_INT, ValSize);
		vecToArr(minValue_, minValue.i);
		vecToArr(maxValue_, maxValue.i);
	}

private:
	template <typename T, int SrcSize, int DstSize>
	static inline void vecToArr (const tcu::Vector<T, SrcSize>& src, T (&dst)[DstSize])
	{
		DE_STATIC_ASSERT(DstSize >= SrcSize);
		for (int i = 0; i < SrcSize; i++)
			dst[i] = src[i];
	}

	template <int ValRows, int ValCols, int DstSize>
	static inline void matToArr (const tcu::Matrix<float, ValRows, ValCols>& src, float (&dst)[DstSize])
	{
		DE_STATIC_ASSERT(DstSize >= ValRows*ValCols);
		tcu::Array<float, ValRows*ValCols> data = src.getColumnMajorData();
		for (int i = 0; i < ValRows*ValCols; i++)
			dst[i] = data[i];
	}
};

struct TextureSpec
{
	glu::TextureTestUtil::TextureType	textureType;
	deUint32							textureUnit;
	int									width;
	int									height;
	deUint32							format;
	deUint32							dataType;
	deUint32							internalFormat;
	bool								useMipmap;
	deUint32							minFilter;
	deUint32							magFilter;
	deUint32							sWrap;
	deUint32							tWrap;
	tcu::Vec4							minValue;
	tcu::Vec4							maxValue;

	TextureSpec (const glu::TextureTestUtil::TextureType	texType,
				 const deUint32								unit,
				 const int									width_,
				 const int									height_,
				 const deUint32								format_,
				 const deUint32								dataType_,
				 const deUint32								internalFormat_,
				 const bool									useMipmap_,
				 const deUint32								minFilter_,
				 const deUint32								magFilter_,
				 const deUint32								sWrap_,
				 const deUint32								tWrap_,
				 const tcu::Vec4&							minValue_,
				 const tcu::Vec4&							maxValue_)
		: textureType		(texType)
		, textureUnit		(unit)
		, width				(width_)
		, height			(height_)
		, format			(format_)
		, dataType			(dataType_)
		, internalFormat	(internalFormat_)
		, useMipmap			(useMipmap_)
		, minFilter			(minFilter_)
		, magFilter			(magFilter_)
		, sWrap				(sWrap_)
		, tWrap				(tWrap_)
		, minValue			(minValue_)
		, maxValue			(maxValue_)
	{
	}
};

/*--------------------------------------------------------------------*//*!
 * \brief Struct for a shader program sources and related data
 *
 * A ProgramContext holds a program's vertex and fragment shader sources
 * as well as specifications of its attributes, uniforms, and textures.
 * When given to a StressCase, the string ${NS} is replaced by a magic
 * number that varies between different compilations of the same program;
 * the same replacement is done in attributes' and uniforms' names. This
 * can be used to avoid shader caching by the GL, by e.g. suffixing each
 * attribute, uniform and varying name with ${NS} in the shader source.
 *//*--------------------------------------------------------------------*/
struct ProgramContext
{
	std::string							vertexSource;
	std::string							fragmentSource;
	std::vector<VarSpec>				attributes;
	std::vector<VarSpec>				uniforms;

	std::vector<TextureSpec>			textureSpecs;		//!< \note If multiple textures have same unit, one of them is picked randomly.

	std::string							positionAttrName;	//!< \note Position attribute may get a bit more careful handling than just complete random.

	ProgramContext (const char* const vtxShaderSource_,
					const char* const fragShaderSource_,
					const char* const positionAttrName_)
		: vertexSource		(vtxShaderSource_)
		, fragmentSource	(fragShaderSource_)
		, positionAttrName	(positionAttrName_)
	{
	}
};

class LongStressCase : public tcu::TestCase
{
public:
	//! Probabilities for actions that may be taken on each iteration. \note The texture and buffer specific actions are randomized per texture or buffer.
	struct FeatureProbabilities
	{
		float rebuildProgram;				//!< Rebuild program, with variable name-mangling.
		float reuploadTexture;				//!< Reupload texture, even if it already exists and has been uploaded.
		float reuploadBuffer;				//!< Reupload buffer, even if it already exists and has been uploaded.
		float reuploadWithTexImage;			//!< Use glTexImage*() when re-uploading texture, not glTexSubImage*().
		float reuploadWithBufferData;		//!< Use glBufferData() when re-uploading buffer, not glBufferSubData().
		float deleteTexture;				//!< Delete texture at end of iteration, even if we could re-use it.
		float deleteBuffer;					//!< Delete buffer at end of iteration, even if we could re-use it.
		float wastefulTextureMemoryUsage;	//!< Don't re-use a texture, and don't delete it until given memory limit is hit.
		float wastefulBufferMemoryUsage;	//!< Don't re-use a buffer, and don't delete it until given memory limit is hit.
		float clientMemoryAttributeData;	//!< Use client memory for vertex attribute data when drawing (instead of GL buffers).
		float clientMemoryIndexData;		//!< Use client memory for vertex indices when drawing (instead of GL buffers).
		float randomBufferUploadTarget;		//!< Use a random target when setting buffer data (i.e. not necessarily the one it'll be ultimately bound to).
		float randomBufferUsage;			//!< Use a random buffer usage parameter with glBufferData(), instead of the ones specified as params for the case.
		float useDrawArrays;				//!< Use glDrawArrays() instead of glDrawElements().
		float separateAttributeBuffers;		//!< Give each vertex attribute its own buffer.

		// Named parameter idiom: helpers that can be used when making temporaries, e.g. FeatureProbabilities().pReuploadTexture(1.0f).pReuploadWithTexImage(1.0f)
		FeatureProbabilities& pRebuildProgram				(const float prob) { rebuildProgram					= prob; return *this; }
		FeatureProbabilities& pReuploadTexture				(const float prob) { reuploadTexture				= prob; return *this; }
		FeatureProbabilities& pReuploadBuffer				(const float prob) { reuploadBuffer					= prob; return *this; }
		FeatureProbabilities& pReuploadWithTexImage			(const float prob) { reuploadWithTexImage			= prob; return *this; }
		FeatureProbabilities& pReuploadWithBufferData		(const float prob) { reuploadWithBufferData			= prob; return *this; }
		FeatureProbabilities& pDeleteTexture				(const float prob) { deleteTexture					= prob; return *this; }
		FeatureProbabilities& pDeleteBuffer					(const float prob) { deleteBuffer					= prob; return *this; }
		FeatureProbabilities& pWastefulTextureMemoryUsage	(const float prob) { wastefulTextureMemoryUsage		= prob; return *this; }
		FeatureProbabilities& pWastefulBufferMemoryUsage	(const float prob) { wastefulBufferMemoryUsage		= prob; return *this; }
		FeatureProbabilities& pClientMemoryAttributeData	(const float prob) { clientMemoryAttributeData		= prob; return *this; }
		FeatureProbabilities& pClientMemoryIndexData		(const float prob) { clientMemoryIndexData			= prob; return *this; }
		FeatureProbabilities& pRandomBufferUploadTarget		(const float prob) { randomBufferUploadTarget		= prob; return *this; }
		FeatureProbabilities& pRandomBufferUsage			(const float prob) { randomBufferUsage				= prob; return *this; }
		FeatureProbabilities& pUseDrawArrays				(const float prob) { useDrawArrays					= prob; return *this; }
		FeatureProbabilities& pSeparateAttribBuffers		(const float prob) { separateAttributeBuffers		= prob; return *this; }

		FeatureProbabilities (void)
			: rebuildProgram				(0.0f)
			, reuploadTexture				(0.0f)
			, reuploadBuffer				(0.0f)
			, reuploadWithTexImage			(0.0f)
			, reuploadWithBufferData		(0.0f)
			, deleteTexture					(0.0f)
			, deleteBuffer					(0.0f)
			, wastefulTextureMemoryUsage	(0.0f)
			, wastefulBufferMemoryUsage		(0.0f)
			, clientMemoryAttributeData		(0.0f)
			, clientMemoryIndexData			(0.0f)
			, randomBufferUploadTarget		(0.0f)
			, randomBufferUsage				(0.0f)
			, useDrawArrays					(0.0f)
			, separateAttributeBuffers		(0.0f)
		{
		}
	};

															LongStressCase						(tcu::TestContext&						testCtx,
																								 const glu::RenderContext&				renderCtx,
																								 const char*							name,
																								 const char*							desc,
																								 int									maxTexMemoryUsageBytes, //!< Approximate upper bound on GL texture memory usage.
																								 int									maxBufMemoryUsageBytes, //!< Approximate upper bound on GL buffer memory usage.
																								 int									numDrawCallsPerIteration,
																								 int									numTrianglesPerDrawCall,
																								 const std::vector<ProgramContext>&		programContexts,
																								 const FeatureProbabilities&			probabilities,
																								 deUint32								indexBufferUsage,
																								 deUint32								attrBufferUsage,
																								 int									redundantBufferFactor = 1,
																								 bool									showDebugInfo = false);

															~LongStressCase						(void);

	void													init								(void);
	void													deinit								(void);

	IterateResult											iterate								(void);

private:
															LongStressCase						(const LongStressCase&);
	LongStressCase&											operator=							(const LongStressCase&);

	const glu::RenderContext&								m_renderCtx;
	const int												m_maxTexMemoryUsageBytes;
	const int												m_maxBufMemoryUsageBytes;
	const int												m_numDrawCallsPerIteration;
	const int												m_numTrianglesPerDrawCall;
	const int												m_numVerticesPerDrawCall;
	const std::vector<ProgramContext>						m_programContexts;
	const FeatureProbabilities								m_probabilities;
	const deUint32											m_indexBufferUsage;
	const deUint32											m_attrBufferUsage;
	const int												m_redundantBufferFactor; //!< By what factor we allocate redundant buffers. Default is 1, i.e. no redundancy.
	const bool												m_showDebugInfo;

	const int												m_numIterations;
	const bool												m_isGLES3;

	int														m_currentIteration;
	deUint64												m_startTimeSeconds; //!< Set at beginning of first iteration.
	deUint64												m_lastLogTime;
	int														m_lastLogIteration;
	int														m_currentLogEntryNdx;

	de::Random												m_rnd;
	LongStressCaseInternal::GLObjectManager<
		LongStressCaseInternal::Program>*					m_programs;
	LongStressCaseInternal::GLObjectManager<
		LongStressCaseInternal::Buffer>*					m_buffers;
	LongStressCaseInternal::GLObjectManager<
		LongStressCaseInternal::Texture>*					m_textures;
	std::vector<deUint16>									m_vertexIndices;

	struct ProgramResources
	{
		std::vector<deUint8>							attrDataBuf;
		std::vector<int>								attrDataOffsets;
		std::vector<int>								attrDataSizes;
		std::vector<de::SharedPtr<tcu::TextureLevel> >	dummyTextures;
		std::string										shaderNameManglingSuffix;
	};

	std::vector<ProgramResources>							m_programResources;

	LongStressCaseInternal::DebugInfoRenderer*				m_debugInfoRenderer;
};


} // gls
} // deqp

#endif // _GLSLONGSTRESSCASE_HPP