/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL ES 3.1 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 Shader built-in constant tests.
 *//*--------------------------------------------------------------------*/

#include "es31fShaderBuiltinConstantTests.hpp"
#include "glsShaderExecUtil.hpp"
#include "deUniquePtr.hpp"
#include "deStringUtil.hpp"
#include "tcuTestLog.hpp"
#include "gluStrUtil.hpp"
#include "gluContextInfo.hpp"
#include "glwEnums.hpp"
#include "glwFunctions.hpp"

using std::string;
using std::vector;
using tcu::TestLog;

namespace deqp
{
namespace gles31
{
namespace Functional
{
namespace
{

static int getInteger (const glw::Functions& gl, deUint32 pname)
{
	int value = -1;
	gl.getIntegerv(pname, &value);
	GLU_EXPECT_NO_ERROR(gl.getError(), ("glGetIntegerv(" + glu::getGettableStateStr((int)pname).toString() + ")").c_str());
	return value;
}

template<deUint32 Pname>
static int getInteger (const glw::Functions& gl)
{
	return getInteger(gl, Pname);
}

static int getVectorsFromComps (const glw::Functions& gl, deUint32 pname)
{
	int value = -1;
	gl.getIntegerv(pname, &value);
	GLU_EXPECT_NO_ERROR(gl.getError(), ("glGetIntegerv(" + glu::getGettableStateStr((int)pname).toString() + ")").c_str());
	TCU_CHECK_MSG(value%4 == 0, ("Expected " + glu::getGettableStateStr((int)pname).toString() + " to be divisible by 4").c_str());
	return value/4;
}

template<deUint32 Pname>
static int getVectorsFromComps (const glw::Functions& gl)
{
	return getVectorsFromComps(gl, Pname);
}

static tcu::IVec3 getIVec3 (const glw::Functions& gl, deUint32 pname)
{
	tcu::IVec3 value(-1);
	for (int ndx = 0; ndx < 3; ndx++)
		gl.getIntegeri_v(pname, (glw::GLuint)ndx, &value[ndx]);
	GLU_EXPECT_NO_ERROR(gl.getError(), ("glGetIntegeri_v(" + glu::getGettableStateStr((int)pname).toString() + ")").c_str());
	return value;
}

template<deUint32 Pname>
static tcu::IVec3 getIVec3 (const glw::Functions& gl)
{
	return getIVec3(gl, Pname);
}

static std::string makeCaseName (const std::string& varName)
{
	DE_ASSERT(varName.length() > 3);
	DE_ASSERT(varName.substr(0,3) == "gl_");

	std::ostringstream name;
	name << de::toLower(char(varName[3]));

	for (size_t ndx = 4; ndx < varName.length(); ndx++)
	{
		const char c = char(varName[ndx]);
		if (de::isUpper(c))
			name << '_' << de::toLower(c);
		else
			name << c;
	}

	return name.str();
}

enum
{
	VS = (1<<glu::SHADERTYPE_VERTEX),
	TC = (1<<glu::SHADERTYPE_TESSELLATION_CONTROL),
	TE = (1<<glu::SHADERTYPE_TESSELLATION_EVALUATION),
	GS = (1<<glu::SHADERTYPE_GEOMETRY),
	FS = (1<<glu::SHADERTYPE_FRAGMENT),
	CS = (1<<glu::SHADERTYPE_COMPUTE),

	SHADER_TYPES = VS|TC|TE|GS|FS|CS
};

template<typename DataType>
class ShaderBuiltinConstantCase : public TestCase
{
public:
	typedef DataType (*GetConstantValueFunc) (const glw::Functions& gl);

								ShaderBuiltinConstantCase	(Context& context, const char* varName, GetConstantValueFunc getValue, const char* requiredExt);
								~ShaderBuiltinConstantCase	(void);

	void						init						(void);
	IterateResult				iterate						(void);

private:
	bool						verifyInShaderType			(glu::ShaderType shaderType, DataType reference);

	const std::string			m_varName;
	const GetConstantValueFunc	m_getValue;
	const std::string			m_requiredExt;
};

template<typename DataType>
ShaderBuiltinConstantCase<DataType>::ShaderBuiltinConstantCase (Context& context, const char* varName, GetConstantValueFunc getValue, const char* requiredExt)
	: TestCase		(context, makeCaseName(varName).c_str(), varName)
	, m_varName		(varName)
	, m_getValue	(getValue)
	, m_requiredExt	(requiredExt ? requiredExt : "")
{
	DE_ASSERT(!requiredExt == m_requiredExt.empty());
}

template<typename DataType>
ShaderBuiltinConstantCase<DataType>::~ShaderBuiltinConstantCase (void)
{
}

template<typename DataType>
void ShaderBuiltinConstantCase<DataType>::init (void)
{
	const bool supportsES32orGL45 = contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)) ||
									contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5));

	if(!glu::isContextTypeES(m_context.getRenderContext().getType()))
	{
		if(m_varName == "gl_MaxVertexOutputVectors" || m_varName == "gl_MaxFragmentInputVectors")
		{
			std::string message = "The test requires a GLES context. The constant '" + m_varName + "' is not supported.";
			TCU_THROW(NotSupportedError, message.c_str());
		}
	}

	if (m_requiredExt == "GL_OES_sample_variables" || m_requiredExt == "GL_EXT_geometry_shader" || m_requiredExt == "GL_EXT_tessellation_shader")
	{
		if(!supportsES32orGL45)
		{
			const std::string message = "The test requires a GLES 3.2 or GL 4.5 context or support for the extension " + m_requiredExt + ".";
			TCU_CHECK_AND_THROW(NotSupportedError, m_context.getContextInfo().isExtensionSupported(m_requiredExt.c_str()), message.c_str());
		}
	}
	else if (!m_requiredExt.empty() && !m_context.getContextInfo().isExtensionSupported(m_requiredExt.c_str()))
			throw tcu::NotSupportedError(m_requiredExt + " not supported");

	if (!supportsES32orGL45 && (m_varName == "gl_MaxTessControlImageUniforms"	||
		m_varName == "gl_MaxTessEvaluationImageUniforms"			||
		m_varName == "gl_MaxTessControlAtomicCounters"				||
		m_varName == "gl_MaxTessEvaluationAtomicCounters"			||
		m_varName == "gl_MaxTessControlAtomicCounterBuffers"		||
		m_varName == "gl_MaxTessEvaluationAtomicCounterBuffers"))
	{
		std::string message = "The test requires a GLES 3.2 or GL 4.5 context. The constant '" + m_varName + "' is not supported.";
		TCU_THROW(NotSupportedError, message.c_str());
	}
}

static gls::ShaderExecUtil::ShaderExecutor* createGetConstantExecutor (const glu::RenderContext&	renderCtx,
																	   glu::ShaderType				shaderType,
																	   glu::DataType				dataType,
																	   const std::string&			varName,
																	   const std::string&			extName)
{
	using namespace gls::ShaderExecUtil;

	const bool	supportsES32orGL45	= contextSupports(renderCtx.getType(), glu::ApiType::es(3, 2)) ||
									  contextSupports(renderCtx.getType(), glu::ApiType::core(4, 5));
	ShaderSpec	shaderSpec;

	shaderSpec.version	= glu::getContextTypeGLSLVersion(renderCtx.getType());
	shaderSpec.source	= string("result = ") + varName + ";\n";

	shaderSpec.outputs.push_back(Symbol("result", glu::VarType(dataType, glu::PRECISION_HIGHP)));

	if (!extName.empty() && !(supportsES32orGL45 && (extName == "GL_OES_sample_variables" || extName == "GL_EXT_geometry_shader" || extName == "GL_EXT_tessellation_shader")))
		shaderSpec.globalDeclarations = "#extension " + extName + " : require\n";

	return createExecutor(renderCtx, shaderType, shaderSpec);
}

template<typename DataType>
static void logVarValue (tcu::TestLog& log, const std::string& varName, DataType value)
{
	log << TestLog::Message << varName << " = " << value << TestLog::EndMessage;
}

template<>
void logVarValue<int> (tcu::TestLog& log, const std::string& varName, int value)
{
	log << TestLog::Integer(varName, varName, "", QP_KEY_TAG_NONE, value);
}

template<typename DataType>
bool ShaderBuiltinConstantCase<DataType>::verifyInShaderType (glu::ShaderType shaderType, DataType reference)
{
	using namespace gls::ShaderExecUtil;

	const de::UniquePtr<ShaderExecutor>	shaderExecutor	(createGetConstantExecutor(m_context.getRenderContext(), shaderType, glu::dataTypeOf<DataType>(), m_varName, m_requiredExt));
	DataType							result			= DataType(-1);
	void* const							outputs			= &result;

	if (!shaderExecutor->isOk())
	{
		shaderExecutor->log(m_testCtx.getLog());
		TCU_FAIL("Compile failed");
	}

	shaderExecutor->useProgram();
	shaderExecutor->execute(1, DE_NULL, &outputs);

	logVarValue(m_testCtx.getLog(), m_varName, result);

	if (result != reference)
	{
		m_testCtx.getLog() << TestLog::Message << "ERROR: Expected " << m_varName << " = " << reference << TestLog::EndMessage
						   << TestLog::Message << "Test shader:" << TestLog::EndMessage;
		shaderExecutor->log(m_testCtx.getLog());
		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid builtin constant value");
		return false;
	}
	else
		return true;
}

template<typename DataType>
TestCase::IterateResult ShaderBuiltinConstantCase<DataType>::iterate (void)
{
	const DataType	reference	= m_getValue(m_context.getRenderContext().getFunctions());

	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");

	for (int shaderType = 0; shaderType < glu::SHADERTYPE_LAST; shaderType++)
	{
		if ((SHADER_TYPES & (1<<shaderType)) != 0)
		{
			const char* const			shaderTypeName	= glu::getShaderTypeName(glu::ShaderType(shaderType));
			const tcu::ScopedLogSection	section			(m_testCtx.getLog(), shaderTypeName, shaderTypeName);

			try
			{
				const bool isOk = verifyInShaderType(glu::ShaderType(shaderType), reference);
				DE_ASSERT(isOk || m_testCtx.getTestResult() != QP_TEST_RESULT_PASS);
				DE_UNREF(isOk);
			}
			catch (const tcu::NotSupportedError& e)
			{
				m_testCtx.getLog() << TestLog::Message << "Not checking " << shaderTypeName << ": " << e.what() << TestLog::EndMessage;
			}
			catch (const tcu::TestError& e)
			{
				m_testCtx.getLog() << TestLog::Message << e.what() << TestLog::EndMessage;
				m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, e.getMessage());
			}
		}
	}

	return STOP;
}

} // anonymous

ShaderBuiltinConstantTests::ShaderBuiltinConstantTests (Context& context)
	: TestCaseGroup(context, "builtin_constants", "Built-in Constant Tests")
{
}

ShaderBuiltinConstantTests::~ShaderBuiltinConstantTests (void)
{
}

void ShaderBuiltinConstantTests::init (void)
{
	// Core builtin constants
	{
		static const struct
		{
			const char*												varName;
			ShaderBuiltinConstantCase<int>::GetConstantValueFunc	getValue;
		} intConstants[] =
		{
			{ "gl_MaxVertexAttribs",					getInteger<GL_MAX_VERTEX_ATTRIBS>						},
			{ "gl_MaxVertexUniformVectors",				getInteger<GL_MAX_VERTEX_UNIFORM_VECTORS>				},
			{ "gl_MaxVertexOutputVectors",				getVectorsFromComps<GL_MAX_VERTEX_OUTPUT_COMPONENTS>	},
			{ "gl_MaxFragmentInputVectors",				getVectorsFromComps<GL_MAX_FRAGMENT_INPUT_COMPONENTS>	},
			{ "gl_MaxFragmentUniformVectors",			getInteger<GL_MAX_FRAGMENT_UNIFORM_VECTORS>				},
			{ "gl_MaxDrawBuffers",						getInteger<GL_MAX_DRAW_BUFFERS>							},

			{ "gl_MaxVertexTextureImageUnits",			getInteger<GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS>			},
			{ "gl_MaxCombinedTextureImageUnits",		getInteger<GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS>			},
			{ "gl_MaxTextureImageUnits",				getInteger<GL_MAX_TEXTURE_IMAGE_UNITS>					},

			{ "gl_MinProgramTexelOffset",				getInteger<GL_MIN_PROGRAM_TEXEL_OFFSET>					},
			{ "gl_MaxProgramTexelOffset",				getInteger<GL_MAX_PROGRAM_TEXEL_OFFSET>					},

			{ "gl_MaxImageUnits",						getInteger<GL_MAX_IMAGE_UNITS>							},
			{ "gl_MaxVertexImageUniforms",				getInteger<GL_MAX_VERTEX_IMAGE_UNIFORMS>				},
			{ "gl_MaxFragmentImageUniforms",			getInteger<GL_MAX_FRAGMENT_IMAGE_UNIFORMS>				},
			{ "gl_MaxComputeImageUniforms",				getInteger<GL_MAX_COMPUTE_IMAGE_UNIFORMS>				},
			{ "gl_MaxCombinedImageUniforms",			getInteger<GL_MAX_COMBINED_IMAGE_UNIFORMS>				},

			{ "gl_MaxCombinedShaderOutputResources",	getInteger<GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES>		},

			{ "gl_MaxComputeUniformComponents",			getInteger<GL_MAX_COMPUTE_UNIFORM_COMPONENTS>			},
			{ "gl_MaxComputeTextureImageUnits",			getInteger<GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS>			},

			{ "gl_MaxComputeAtomicCounters",			getInteger<GL_MAX_COMPUTE_ATOMIC_COUNTERS>				},
			{ "gl_MaxComputeAtomicCounterBuffers",		getInteger<GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS>		},

			{ "gl_MaxVertexAtomicCounters",				getInteger<GL_MAX_VERTEX_ATOMIC_COUNTERS>				},
			{ "gl_MaxFragmentAtomicCounters",			getInteger<GL_MAX_FRAGMENT_ATOMIC_COUNTERS>				},
			{ "gl_MaxCombinedAtomicCounters",			getInteger<GL_MAX_COMBINED_ATOMIC_COUNTERS>				},
			{ "gl_MaxAtomicCounterBindings",			getInteger<GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS>		},

			{ "gl_MaxVertexAtomicCounterBuffers",		getInteger<GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS>		},
			{ "gl_MaxFragmentAtomicCounterBuffers",		getInteger<GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS>		},
			{ "gl_MaxCombinedAtomicCounterBuffers",		getInteger<GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS>		},
			{ "gl_MaxAtomicCounterBufferSize",			getInteger<GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE>			},
		};

		static const struct
		{
			const char*													varName;
			ShaderBuiltinConstantCase<tcu::IVec3>::GetConstantValueFunc	getValue;
		} ivec3Constants[] =
		{
			{ "gl_MaxComputeWorkGroupCount",			getIVec3<GL_MAX_COMPUTE_WORK_GROUP_COUNT>				},
			{ "gl_MaxComputeWorkGroupSize",				getIVec3<GL_MAX_COMPUTE_WORK_GROUP_SIZE>				},
		};

		tcu::TestCaseGroup* const coreGroup = new tcu::TestCaseGroup(m_testCtx, "core", "Core Specification");
		addChild(coreGroup);

		for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(intConstants); ndx++)
			coreGroup->addChild(new ShaderBuiltinConstantCase<int>(m_context, intConstants[ndx].varName, intConstants[ndx].getValue, DE_NULL));

		for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(ivec3Constants); ndx++)
			coreGroup->addChild(new ShaderBuiltinConstantCase<tcu::IVec3>(m_context, ivec3Constants[ndx].varName, ivec3Constants[ndx].getValue, DE_NULL));
	}

	// OES_sample_variables
	{
		tcu::TestCaseGroup* const sampleVarGroup = new tcu::TestCaseGroup(m_testCtx, "sample_variables", "GL_OES_sample_variables");
		addChild(sampleVarGroup);
		sampleVarGroup->addChild(new ShaderBuiltinConstantCase<int>(m_context, "gl_MaxSamples", getInteger<GL_MAX_SAMPLES>, "GL_OES_sample_variables"));
	}

	// EXT_geometry_shader
	{
		static const struct
		{
			const char*												varName;
			ShaderBuiltinConstantCase<int>::GetConstantValueFunc	getValue;
		} intConstants[] =
		{
			{ "gl_MaxGeometryInputComponents",			getInteger<GL_MAX_GEOMETRY_INPUT_COMPONENTS>			},
			{ "gl_MaxGeometryOutputComponents",			getInteger<GL_MAX_GEOMETRY_OUTPUT_COMPONENTS>			},
			{ "gl_MaxGeometryImageUniforms",			getInteger<GL_MAX_GEOMETRY_IMAGE_UNIFORMS>				},
			{ "gl_MaxGeometryTextureImageUnits",		getInteger<GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS>			},
			{ "gl_MaxGeometryOutputVertices",			getInteger<GL_MAX_GEOMETRY_OUTPUT_VERTICES>				},
			{ "gl_MaxGeometryTotalOutputComponents",	getInteger<GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS>		},
			{ "gl_MaxGeometryUniformComponents",		getInteger<GL_MAX_GEOMETRY_UNIFORM_COMPONENTS>			},
			{ "gl_MaxGeometryAtomicCounters",			getInteger<GL_MAX_GEOMETRY_ATOMIC_COUNTERS>				},
			{ "gl_MaxGeometryAtomicCounterBuffers",		getInteger<GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS>		},
		};

		tcu::TestCaseGroup* const geomGroup = new tcu::TestCaseGroup(m_testCtx, "geometry_shader", "GL_EXT_geometry_shader");
		addChild(geomGroup);

		for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(intConstants); ndx++)
			geomGroup->addChild(new ShaderBuiltinConstantCase<int>(m_context, intConstants[ndx].varName, intConstants[ndx].getValue, "GL_EXT_geometry_shader"));
	}

	// EXT_tessellation_shader
	{
		static const struct
		{
			const char*												varName;
			ShaderBuiltinConstantCase<int>::GetConstantValueFunc	getValue;
		} intConstants[] =
		{
			{ "gl_MaxTessControlInputComponents",			getInteger<GL_MAX_TESS_CONTROL_INPUT_COMPONENTS>			},
			{ "gl_MaxTessControlOutputComponents",			getInteger<GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS>			},
			{ "gl_MaxTessControlTextureImageUnits",			getInteger<GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS>			},
			{ "gl_MaxTessControlUniformComponents",			getInteger<GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS>			},
			{ "gl_MaxTessControlTotalOutputComponents",		getInteger<GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS>		},

			{ "gl_MaxTessControlImageUniforms",				getInteger<GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS>				},
			{ "gl_MaxTessEvaluationImageUniforms",			getInteger<GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS>			},
			{ "gl_MaxTessControlAtomicCounters",			getInteger<GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS>				},
			{ "gl_MaxTessEvaluationAtomicCounters",			getInteger<GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS>			},
			{ "gl_MaxTessControlAtomicCounterBuffers",		getInteger<GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS>		},
			{ "gl_MaxTessEvaluationAtomicCounterBuffers",	getInteger<GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS>	},

			{ "gl_MaxTessEvaluationInputComponents",		getInteger<GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS>			},
			{ "gl_MaxTessEvaluationOutputComponents",		getInteger<GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS>		},
			{ "gl_MaxTessEvaluationTextureImageUnits",		getInteger<GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS>		},
			{ "gl_MaxTessEvaluationUniformComponents",		getInteger<GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS>		},

			{ "gl_MaxTessPatchComponents",					getInteger<GL_MAX_TESS_PATCH_COMPONENTS>					},

			{ "gl_MaxPatchVertices",						getInteger<GL_MAX_PATCH_VERTICES>							},
			{ "gl_MaxTessGenLevel",							getInteger<GL_MAX_TESS_GEN_LEVEL>							},
		};

		tcu::TestCaseGroup* const tessGroup = new tcu::TestCaseGroup(m_testCtx, "tessellation_shader", "GL_EXT_tessellation_shader");
		addChild(tessGroup);

		for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(intConstants); ndx++)
			tessGroup->addChild(new ShaderBuiltinConstantCase<int>(m_context, intConstants[ndx].varName, intConstants[ndx].getValue, "GL_EXT_tessellation_shader"));
	}
}

} // Functional
} // gles31
} // deqp