/*-------------------------------------------------------------------------
 * OpenGL Conformance Test Suite
 * -----------------------------
 *
 * Copyright (c) 2017 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  glcAggressiveShaderOptimizationsTests.cpp
 * \brief Conformance tests that checks if shader optimizations are not
 *		  overly aggressive. This is done by compering result of complex
 *		  trigonometric functions aproximation to shader buil
 */ /*-------------------------------------------------------------------*/

#include "glcAggressiveShaderOptimizationsTests.hpp"
#include "deSharedPtr.hpp"
#include "glsShaderExecUtil.hpp"
#include "gluContextInfo.hpp"
#include "gluDrawUtil.hpp"
#include "gluPixelTransfer.hpp"
#include "gluShaderProgram.hpp"
#include "glwFunctions.hpp"
#include "tcuImageCompare.hpp"
#include "tcuRenderTarget.hpp"
#include "tcuStringTemplate.hpp"
#include "tcuSurface.hpp"
#include "tcuTestLog.hpp"

using namespace glw;

namespace glcts
{

enum ShaderType
{
	TEST_VERTEX_SHADER,
	TEST_FRAGMENT_SHADER
};

struct TrigonometryCaseData
{
	const char* testedFunction;
	const char* testedType;
	const char* colorComponents;
	ShaderType  shaderType;
};

class TrigonometryTestCase : public deqp::TestCase
{
public:
	TrigonometryTestCase(deqp::Context& context, const std::string& name, const TrigonometryCaseData& data);
	virtual ~TrigonometryTestCase();

	IterateResult iterate(void);

protected:
	glu::ProgramSources prepareSineSources(bool useBuiltin);
	glu::ProgramSources prepareCosineSources(bool useBuiltin);

	void renderAndGrabSurface(glu::ProgramSources sources, tcu::Surface& result) const;

private:
	ShaderType  m_shaderType;
	const char* m_testedFunction;
	std::map<std::string, std::string> m_specializationMap;
};

TrigonometryTestCase::TrigonometryTestCase(deqp::Context& context, const std::string& name,
										   const TrigonometryCaseData& data)
	: deqp::TestCase(context, name.c_str(), ""), m_shaderType(data.shaderType), m_testedFunction(data.testedFunction)
{
	glu::ContextType contextType = m_context.getRenderContext().getType();
	glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(contextType);

	m_specializationMap["VERSION"]			= glu::getGLSLVersionDeclaration(glslVersion);
	m_specializationMap["TYPE"]				= data.testedType;
	m_specializationMap["COLOR_COMPONENTS"] = data.colorComponents;

	if (glu::contextSupports(contextType, glu::ApiType::es(3, 0)) || glu::isContextTypeGLCore(contextType))
	{
		m_specializationMap["IN"]						= "in";
		m_specializationMap["OUT"]						= "out";
		m_specializationMap["ATTRIBUTE"]				= "in";
		m_specializationMap["FS_OUT_COLOR_NAME"]		= "fragColor";
		m_specializationMap["FS_OUT_COLOR_DECLARATION"] = "out vec4 fragColor;";
	}
	else
	{
		m_specializationMap["IN"]						= "varying";
		m_specializationMap["OUT"]						= "varying";
		m_specializationMap["ATTRIBUTE"]				= "attribute";
		m_specializationMap["FS_OUT_COLOR_NAME"]		= "gl_FragColor";
		m_specializationMap["FS_OUT_COLOR_DECLARATION"] = "";
	}
}

TrigonometryTestCase::~TrigonometryTestCase()
{
}

glu::ProgramSources TrigonometryTestCase::prepareSineSources(bool useBuiltinSin)
{
	const char* vsDefault = "${VERSION}\n"
							"${ATTRIBUTE} highp vec2 position;\n"
							"${ATTRIBUTE} highp vec3 baseColor;\n"
							"${OUT} vec4 color;\n"
							"void main (void) {\n"
							"  color = vec4(baseColor, 1.0);\n"
							"  gl_Position = vec4(position, 0.0, 1.0);\n"
							"}\n";

	const char* vsCalculateSin = "${VERSION}\n"
								 "${ATTRIBUTE} highp vec2 position;\n"
								 "${ATTRIBUTE} highp vec3 baseColor;\n"
								 "${OUT} vec4 color;\n"
								 "${SIN_FUNCTION_DEFINITION_VS}\n"
								 "void main (void) {\n"
								 "  const float M_2PI = 2.0 * 3.14159265358979323846;\n"
								 "  ${TYPE} c = baseColor.${COLOR_COMPONENTS} * M_2PI;\n"
								 "  ${TYPE} sin_c = ${SIN_FUNCTION_NAME}(c);\n"
								 "  \n"
								 "  color = vec4(0.0, 0.0, 0.0, 1.0);\n"
								 "  color.${COLOR_COMPONENTS} = sin_c * 0.5 + 0.5;\n"
								 "  gl_Position = vec4(position, 0.0, 1.0);\n"
								 "}\n";

	const char* fsDefault = "${VERSION}\n"
							"precision mediump float;\n"
							"${IN} vec4 color;\n"
							"${FS_OUT_COLOR_DECLARATION}\n"
							"void main (void) {\n"
							"  ${FS_OUT_COLOR_NAME} = color;\n"
							"}\n";

	const char* fsCalculateSin = "${VERSION}\n"
								 "precision mediump float;\n"
								 "${IN} vec4 color;\n"
								 "${FS_OUT_COLOR_DECLARATION}\n\n"
								 "${SIN_FUNCTION_DEFINITION_FS}\n"
								 "void main (void) {\n"
								 "  const float M_2PI = 2.0 * 3.14159265358979323846;\n"
								 "  ${TYPE} c = color.${COLOR_COMPONENTS};\n"
								 "  ${TYPE} sin_c = ${SIN_FUNCTION_NAME}(c * M_2PI);\n"
								 "  \n"
								 "  ${FS_OUT_COLOR_NAME} =vec4(0.0, 0.0, 0.0, 1.0);\n"
								 "  ${FS_OUT_COLOR_NAME}.${COLOR_COMPONENTS} = sin_c * 0.5 + 0.5;\n"
								 "}\n";

	std::string vsTemplate;
	std::string fsTemplate;

	if (m_shaderType == TEST_VERTEX_SHADER)
	{
		vsTemplate = vsCalculateSin;
		fsTemplate = fsDefault;
	}
	else
	{
		vsTemplate = vsDefault;
		fsTemplate = fsCalculateSin;
	}

	if (useBuiltinSin)
	{
		m_specializationMap["SIN_FUNCTION_NAME"]		  = "sin";
		m_specializationMap["SIN_FUNCTION_DEFINITION_VS"] = "";
		m_specializationMap["SIN_FUNCTION_DEFINITION_FS"] = "";
	}
	else
	{
		std::string sinFunctionDefinitionVS = "${TYPE} ${SIN_FUNCTION_NAME}(${TYPE} c) {\n"
											  "  ${TYPE} sin_c = ${TYPE}(0.0);\n"
											  "  float sign = 1.0;\n"
											  "  float fact;\n"
											  "  float fact_of;\n"
											  "  \n"
											  "  // Taylors series expansion for sin \n"
											  "  for(int i = 0; i < 12; i++) {\n"
											  "    fact = 1.0;\n"
											  "    for(int j = 2; j <= 23; j++)\n"
											  "      if (j <= 2 * i + 1)\n"
											  "        fact *= float(j);\n"
											  "    \n"
											  "    sin_c += sign * pow(c, ${TYPE}(2.0 * float(i) + 1.0)) / fact;\n"
											  "    sign *= -1.0;\n"
											  "  }\n"
											  "  return sin_c;\n"
											  "}";
		std::string sinFunctionDefinitionFS = "float lerpHelper(float a, float b, float weight) {\n"
											  "  return a + (b - a) * weight;\n"
											  "}\n"
											  "float sinLerpHelper(int index, float weight) {\n"
											  "  float sArray[17];\n"
											  "  sArray[0] = 0.0;\n"
											  "  sArray[1] = 0.382683;\n"
											  "  sArray[2] = 0.707107;\n"
											  "  sArray[3] = 0.92388;\n"
											  "  sArray[4] = 1.0;\n"
											  "  sArray[5] = 0.92388;\n"
											  "  sArray[6] = 0.707107;\n"
											  "  sArray[7] = 0.382683;\n"
											  "  sArray[8] = 0.0;\n"
											  "  sArray[9] = -0.382683;\n"
											  "  sArray[10] = -0.707107;\n"
											  "  sArray[11] = -0.92388;\n"
											  "  sArray[12] = -1.0;\n"
											  "  sArray[13] = -0.923879;\n"
											  "  sArray[14] = -0.707107;\n"
											  "  sArray[15] = -0.382683;\n"
											  "  sArray[16] = 0.0;\n"
											  "  \n"
											  "  if (index == 0)\n"
											  "    return lerpHelper(sArray[0], sArray[1], weight);\n"
											  "  if (index == 1)\n"
											  "    return lerpHelper(sArray[1], sArray[2], weight);\n"
											  "  if (index == 2)\n"
											  "    return lerpHelper(sArray[2], sArray[3], weight);\n"
											  "  if (index == 3)\n"
											  "    return lerpHelper(sArray[3], sArray[4], weight);\n"
											  "  if (index == 4)\n"
											  "    return lerpHelper(sArray[4], sArray[5], weight);\n"
											  "  if (index == 5)\n"
											  "    return lerpHelper(sArray[5], sArray[6], weight);\n"
											  "  if (index == 6)\n"
											  "    return lerpHelper(sArray[6], sArray[7], weight);\n"
											  "  if (index == 7)\n"
											  "    return lerpHelper(sArray[7], sArray[8], weight);\n"
											  "  if (index == 8)\n"
											  "    return lerpHelper(sArray[8], sArray[9], weight);\n"
											  "  if (index == 9)\n"
											  "    return lerpHelper(sArray[9], sArray[10], weight);\n"
											  "  if (index == 10)\n"
											  "    return lerpHelper(sArray[10], sArray[11], weight);\n"
											  "  if (index == 11)\n"
											  "    return lerpHelper(sArray[11], sArray[12], weight);\n"
											  "  if (index == 12)\n"
											  "    return lerpHelper(sArray[12], sArray[13], weight);\n"
											  "  if (index == 13)\n"
											  "    return lerpHelper(sArray[13], sArray[14], weight);\n"
											  "  if (index == 14)\n"
											  "    return lerpHelper(sArray[14], sArray[15], weight);\n"
											  "  if (index == 15)\n"
											  "    return lerpHelper(sArray[15], sArray[16], weight);\n"
											  "  return sArray[16];\n"
											  "}\n"
											  "${TYPE} ${SIN_FUNCTION_NAME}(${TYPE} c) {\n"
											  "  ${TYPE} arrVal = c * 2.546478971;\n"
											  "  ${TYPE} weight = arrVal - floor(arrVal);\n"
											  "  ${TYPE} sin_c = ${TYPE}(0.0);\n"
											  "  ${INTERPOLATE_SIN}"
											  "  return sin_c;\n"
											  "}";

		if (m_specializationMap["TYPE"] == "float")
		{
			m_specializationMap["INTERPOLATE_SIN"] = "\n"
													 "  int index = int(floor(arrVal));\n"
													 "  sin_c = sinLerpHelper(index, weight);\n";
		}
		else if (m_specializationMap["TYPE"] == "vec2")
		{
			m_specializationMap["INTERPOLATE_SIN"] = "\n"
													 "  int indexX = int(floor(arrVal.x));\n"
													 "  sin_c.x = sinLerpHelper(indexX, weight.x);\n"
													 "  int indexY = int(floor(arrVal.y));\n"
													 "  sin_c.y = sinLerpHelper(indexY, weight.y);\n";
		}
		else if (m_specializationMap["TYPE"] == "vec3")
		{
			m_specializationMap["INTERPOLATE_SIN"] = "\n"
													 "  int indexX = int(floor(arrVal.x));\n"
													 "  sin_c.x = sinLerpHelper(indexX, weight.x);\n"
													 "  int indexY = int(floor(arrVal.y));\n"
													 "  sin_c.y = sinLerpHelper(indexY, weight.y);\n"
													 "  int indexZ = int(floor(arrVal.z));\n"
													 "  sin_c.z = sinLerpHelper(indexZ, weight.z);\n";
		}

		m_specializationMap["SIN_FUNCTION_NAME"] = "calculateSin";
		m_specializationMap["SIN_FUNCTION_DEFINITION_VS"] =
			tcu::StringTemplate(sinFunctionDefinitionVS).specialize(m_specializationMap);
		m_specializationMap["SIN_FUNCTION_DEFINITION_FS"] =
			tcu::StringTemplate(sinFunctionDefinitionFS).specialize(m_specializationMap);
	}

	// Specialize shader templates
	vsTemplate = tcu::StringTemplate(vsTemplate).specialize(m_specializationMap);
	fsTemplate = tcu::StringTemplate(fsTemplate).specialize(m_specializationMap);
	return glu::makeVtxFragSources(vsTemplate.c_str(), fsTemplate.c_str());
}

glu::ProgramSources TrigonometryTestCase::prepareCosineSources(bool useBuiltinCos)
{
	const char* vsDefault = "${VERSION}\n"
							"${ATTRIBUTE} highp vec2 position;\n"
							"${ATTRIBUTE} highp vec3 baseColor;\n"
							"${OUT} vec4 color;\n"
							"void main (void) {\n"
							"  color = vec4(baseColor, 1.0);\n"
							"  gl_Position = vec4(position, 0.0, 1.0);\n"
							"}\n";

	const char* vsCalculateCos = "${VERSION}\n"
								 "${ATTRIBUTE} highp vec2 position;\n"
								 "${ATTRIBUTE} highp vec3 baseColor;\n"
								 "${OUT} vec4 color;\n"
								 "${COS_FUNCTION_DEFINITION_VS}\n"
								 "void main (void) {\n"
								 "  const float M_2PI = 2.0 * 3.14159265358979323846;\n"
								 "  ${TYPE} c = baseColor.${COLOR_COMPONENTS};\n"
								 "  ${TYPE} cos_c = ${COS_FUNCTION_NAME}(c * M_2PI);\n"
								 "  \n"
								 "  color = vec4(0.0, 0.0, 0.0, 1.0);\n"
								 "  color.${COLOR_COMPONENTS} = cos_c * 0.5 + 0.5;\n"
								 "  gl_Position = vec4(position, 0.0, 1.0);\n"
								 "}\n";

	const char* fsDefault = "${VERSION}\n"
							"precision mediump float;\n"
							"${IN} vec4 color;\n"
							"${FS_OUT_COLOR_DECLARATION}\n"
							"void main (void) {\n"
							"  ${FS_OUT_COLOR_NAME} = color;\n"
							"}\n";

	const char* fsCalculateCos = "${VERSION}\n"
								 "precision mediump float;\n"
								 "${IN} vec4 color;\n"
								 "${FS_OUT_COLOR_DECLARATION}\n\n"
								 "// function definitions \n"
								 "${COS_FUNCTION_DEFINITION_FS}\n"
								 "${TYPE} preprocessColor(${TYPE} c) {\n"
								 "  ${PREPROCESS_COLOR};\n"
								 "  return c;\n"
								 "}\n\n"
								 "void main (void) {\n"
								 "  const float M_2PI = 2.0 * 3.14159265358979323846;\n"
								 "  ${TYPE} c = preprocessColor(color.${COLOR_COMPONENTS});\n"
								 "  ${TYPE} cos_c = ${COS_FUNCTION_NAME}(c * M_2PI);\n"
								 "  \n"
								 "  ${FS_OUT_COLOR_NAME} = vec4(0.0, 0.0, 0.0, 1.0);\n"
								 "  ${FS_OUT_COLOR_NAME}.${COLOR_COMPONENTS} = cos_c * 0.5 + 0.5;\n"
								 "}\n";

	std::string vsTemplate;
	std::string fsTemplate;

	if (m_shaderType == TEST_VERTEX_SHADER)
	{
		vsTemplate = vsCalculateCos;
		fsTemplate = fsDefault;
	}
	else
	{
		vsTemplate = vsDefault;
		fsTemplate = fsCalculateCos;
	}

	if (useBuiltinCos)
	{
		m_specializationMap["PREPROCESS_COLOR"]			  = "";
		m_specializationMap["COS_FUNCTION_NAME"]		  = "cos";
		m_specializationMap["COS_FUNCTION_DEFINITION_VS"] = "";
		m_specializationMap["COS_FUNCTION_DEFINITION_FS"] = "";
	}
	else
	{
		std::string cosFunctionDefinitionVS = "${TYPE} ${COS_FUNCTION_NAME}(${TYPE} c) {\n"
											  "  ${TYPE} cos_c = ${TYPE}(1.0);\n"
											  "  float sign = -1.0;\n"
											  "  float fact =  1.0;\n"
											  "  \n"
											  "  for(int i = 2; i <= 20; i += 2) {\n"
											  "    fact  *= float(i)*float(i-1);\n"
											  "    cos_c += sign*pow(c, ${TYPE}(float(i)))/fact;\n"
											  "    sign = -sign;\n"
											  "  }\n"
											  "  return cos_c;\n"
											  "}";
		std::string cosFunctionDefinitionFS = "${TYPE} ${COS_FUNCTION_NAME}(${TYPE} c) {\n"
											  "  ${TYPE} cos_c = ${TYPE}(-1.0);\n"
											  "  float sign      = 1.0;\n"
											  "  float fact_even = 1.0;\n"
											  "  float fact_odd  = 1.0;\n"
											  "  ${TYPE} sum;\n"
											  "  ${TYPE} exp;\n"
											  "  \n"
											  "  for(int i = 2; i <= 10; i += 2) {\n"
											  "    fact_even *= float(i);\n"
											  "    fact_odd  *= float(i-1);\n"
											  "    exp = ${TYPE}(float(i/2));\n"
											  "    sum = sign * pow(abs(c), exp)/fact_even;\n"
											  "    cos_c += pow(abs(c), exp)*(sum/fact_odd);\n"
											  "    sign = -sign;\n"
											  "  }\n"
											  "  return cos_c;\n"
											  "}";

		m_specializationMap["PREPROCESS_COLOR"]  = "c = (fract(abs(c)) - 0.5)";
		m_specializationMap["COS_FUNCTION_NAME"] = "calculateCos";
		m_specializationMap["COS_FUNCTION_DEFINITION_VS"] =
			tcu::StringTemplate(cosFunctionDefinitionVS).specialize(m_specializationMap);
		m_specializationMap["COS_FUNCTION_DEFINITION_FS"] =
			tcu::StringTemplate(cosFunctionDefinitionFS).specialize(m_specializationMap);
	}

	// Specialize shader templates
	vsTemplate = tcu::StringTemplate(vsTemplate).specialize(m_specializationMap);
	fsTemplate = tcu::StringTemplate(fsTemplate).specialize(m_specializationMap);
	return glu::makeVtxFragSources(vsTemplate.c_str(), fsTemplate.c_str());
}

void TrigonometryTestCase::renderAndGrabSurface(glu::ProgramSources sources, tcu::Surface& result) const
{
	static const deUint16 quadIndices[] = { 0, 1, 2, 2, 1, 3 };
	static const float	positions[]   = { -1.0, 1.0, 1.0, 1.0, -1.0, -1.0, 1.0, -1.0 };
	static const float	baseColors[]  = { 1.0, 0.0, 0.25, 0.75, 0.25, 1.0, 0.0, 1.0, 0.75, 0.25, 0.5, 0.0 };

	glu::RenderContext&   renderContext = m_context.getRenderContext();
	const glw::Functions& gl			= renderContext.getFunctions();
	glu::ShaderProgram	testProgram(renderContext, sources);
	if (!testProgram.isOk())
	{
		m_testCtx.getLog() << testProgram;
		TCU_FAIL("Test program compilation failed");
	}

	// Render
	gl.useProgram(testProgram.getProgram());
	const glu::VertexArrayBinding vertexArrays[] = { glu::va::Float("position", 2, 4, 0, positions),
													 glu::va::Float("baseColor", 3, 4, 0, baseColors) };
	glu::draw(renderContext, testProgram.getProgram(), DE_LENGTH_OF_ARRAY(vertexArrays), vertexArrays,
			  glu::pr::TriangleStrip(DE_LENGTH_OF_ARRAY(quadIndices), quadIndices));

	// Grab surface
	glu::readPixels(renderContext, 0, 0, result.getAccess());
}

tcu::TestNode::IterateResult TrigonometryTestCase::iterate(void)
{
	glu::RenderContext&   renderContext = m_context.getRenderContext();
	const glw::Functions& gl			= renderContext.getFunctions();

	int  renderWidth  = 64;
	int  renderHeight = 64;
	if (renderWidth > m_context.getRenderTarget().getWidth())
		renderWidth = m_context.getRenderTarget().getWidth();
	if (renderHeight > m_context.getRenderTarget().getHeight())
		renderHeight = m_context.getRenderTarget().getHeight();
	bool isSin		  = std::string(m_testedFunction) == "sin";

	gl.viewport(0, 0, renderWidth, renderHeight);

	// Use program that will call trigonometric function aproximation
	tcu::Surface testSurface(renderWidth, renderHeight);
	if (isSin)
		renderAndGrabSurface(prepareSineSources(false), testSurface);
	else
		renderAndGrabSurface(prepareCosineSources(false), testSurface);

	// Use reference program that will call builtin function
	tcu::Surface referenceSurface(renderWidth, renderHeight);
	if (isSin)
		renderAndGrabSurface(prepareSineSources(true), referenceSurface);
	else
		renderAndGrabSurface(prepareCosineSources(true), referenceSurface);

	// Compare surfaces
	qpTestResult testResult = QP_TEST_RESULT_FAIL;
	if (tcu::fuzzyCompare(m_testCtx.getLog(), "Result", "Image comparison result", referenceSurface, testSurface, 0.05f,
						  tcu::COMPARE_LOG_RESULT))
		testResult = QP_TEST_RESULT_PASS;

	m_testCtx.setTestResult(testResult, qpGetTestResultName(testResult));
	return STOP;
}

AggressiveShaderOptimizationsTests::AggressiveShaderOptimizationsTests(deqp::Context& context)
	: TestCaseGroup(context, "aggressive_optimizations", "checks if shader optimizations are not overly aggressive")
{
}

AggressiveShaderOptimizationsTests::~AggressiveShaderOptimizationsTests()
{
}

void AggressiveShaderOptimizationsTests::init(void)
{
	TrigonometryCaseData trigonometryCases[] = {
		{ "sin", "float", "r", TEST_VERTEX_SHADER },  { "sin", "float", "r", TEST_FRAGMENT_SHADER },
		{ "sin", "vec2", "rg", TEST_VERTEX_SHADER },  { "sin", "vec2", "rg", TEST_FRAGMENT_SHADER },
		{ "sin", "vec3", "rgb", TEST_VERTEX_SHADER }, { "sin", "vec3", "rgb", TEST_FRAGMENT_SHADER },
		{ "cos", "float", "r", TEST_VERTEX_SHADER },  { "cos", "float", "r", TEST_FRAGMENT_SHADER },
		{ "cos", "vec2", "rg", TEST_VERTEX_SHADER },  { "cos", "vec2", "rg", TEST_FRAGMENT_SHADER },
		{ "cos", "vec3", "rgb", TEST_VERTEX_SHADER }, { "cos", "vec3", "rgb", TEST_FRAGMENT_SHADER },
	};

	for (int i = 0; i < DE_LENGTH_OF_ARRAY(trigonometryCases); ++i)
	{
		const TrigonometryCaseData& tcd		   = trigonometryCases[i];
		std::string					shaderType = (tcd.shaderType == TEST_VERTEX_SHADER) ? "_vert" : "_frag";
		std::string					name	   = std::string(tcd.testedFunction) + "_" + tcd.testedType + shaderType;
		addChild(new TrigonometryTestCase(m_context, name, tcd));
	}
}

} // glcts namespace