/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL ES 3.0 Module
 * -------------------------------------------------
 *
 * Copyright 2017 Hugues Evrard, Imperial College London
 *
 * 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 metamorphic tests.
 *//*--------------------------------------------------------------------*/

#include "es3fShaderMetamorphicTests.hpp"
#include "glsShaderRenderCase.hpp"
#include "deUniquePtr.hpp"
#include "deFilePath.hpp"
#include "tcuTestContext.hpp"
#include "tcuTestLog.hpp"
#include "tcuRenderTarget.hpp"
#include "tcuImageCompare.hpp"
#include "tcuVectorUtil.hpp"
#include "tcuResource.hpp"
#include "gluPixelTransfer.hpp"
#include "gluDrawUtil.hpp"

#include "glwFunctions.hpp"

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

namespace deqp
{
namespace gles3
{
namespace Functional
{

static const int MAX_RENDER_WIDTH	= 256;
static const int MAX_RENDER_HEIGHT	= 256;

typedef bool (*SanityCheckFunc)(const tcu::ConstPixelBufferAccess&);

/*--------------------------------------------------------------------*//*!
 * \brief ShaderMetamorphicVariant
 *
 * ShaderMetamorphicVariant aims at rendering a recipient shader and a
 * variant shader, and compare whether the resulting images are the
 * approximately the same. It also checks non-deterministic renderings,
 * by rendering each fragment shader a couple of times.
 *//*--------------------------------------------------------------------*/
class ShaderMetamorphicVariant : public TestCase
{
public:
					ShaderMetamorphicVariant	(Context& context, const char* name, const std::string& vertexFilename, const std::string& recipientFilename, const std::string& variantFilename, SanityCheckFunc sanityCheck);
					~ShaderMetamorphicVariant	(void);
	IterateResult	iterate						(void);

private:
	const std::string	m_vertexFilename;
	const std::string	m_recipientFilename;
	const std::string	m_variantFilename;
	SanityCheckFunc		m_sanityCheck;

	std::string			fileContents	(const std::string& filename);
	void				render			(const tcu::PixelBufferAccess& img, const std::string& vertexSrc, const std::string& fragmentSrc);
	void				checkNondet		(const tcu::Surface& refImg, const std::string& vertexSrc, const std::string& fragmentSrc);
};

ShaderMetamorphicVariant::ShaderMetamorphicVariant (Context& context, const char* name, const std::string& vertexFilename, const std::string& recipientFilename, const std::string& variantFilename, SanityCheckFunc sanityCheck)
	: TestCase				(context, name, "Test a given variant")
	, m_vertexFilename		(vertexFilename)
	, m_recipientFilename	(recipientFilename)
	, m_variantFilename		(variantFilename)
	, m_sanityCheck			(sanityCheck)
{
}

ShaderMetamorphicVariant::~ShaderMetamorphicVariant (void)
{
}

std::string ShaderMetamorphicVariant::fileContents (const std::string& filename)
{
	de::UniquePtr<tcu::Resource>	resource		(m_testCtx.getArchive().getResource(filename.c_str()));
	int								size			= resource->getSize();
	std::vector<deUint8>			data;

	data.resize(size + 1);
	resource->read(&data[0], size);
	data[size] = '\0';
	std::string contents = std::string((const char*)(&data[0]));
	return contents;
}

void ShaderMetamorphicVariant::render (const tcu::PixelBufferAccess& img, const std::string& vertexSrc, const std::string& fragmentSrc)
{
	TestLog&				log		= m_testCtx.getLog();
	const glw::Functions&	gl		= m_context.getRenderContext().getFunctions();

	// Positions, shared between shaders
	const float positions[] =
	{
		-1.0f,  1.0f,	// top-left
		-1.0f, -1.0f,	// bottom-left
		 1.0f, -1.0f,	// bottom-right
		 1.0f,  1.0f,	// top-right
	};

	const deUint16 indices[] =
	{
		0, 1, 2,	// bottom-left triangle
		0, 3, 2,	// top-right triangle
	};

	glu::VertexArrayBinding posBinding = glu::va::Float("coord2d", 2, 6, 0, &positions[0]);

	const glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(vertexSrc, fragmentSrc));
	log << program;

	if (!program.isOk())
		throw tcu::TestError("Compile failed");

	// Set uniforms expected in GraphicsFuzz generated programs
	gl.useProgram(program.getProgram());
	// Uniform: injectionSwitch
	int uniformLoc = gl.getUniformLocation(program.getProgram(), "injectionSwitch");
	if (uniformLoc != -1)
		gl.uniform2f(uniformLoc, 0.0f, 1.0f);
	// Uniform: resolution
	uniformLoc = gl.getUniformLocation(program.getProgram(), "resolution");
	if (uniformLoc != -1)
		gl.uniform2f(uniformLoc, glw::GLfloat(img.getWidth()), glw::GLfloat(img.getHeight()));
	// Uniform: mouse
	uniformLoc = gl.getUniformLocation(program.getProgram(), "mouse");
	if (uniformLoc != -1)
		gl.uniform2f(uniformLoc, 0.0f, 0.0f);
	// Uniform: time
	uniformLoc = gl.getUniformLocation(program.getProgram(), "time");
	if (uniformLoc != -1)
		gl.uniform1f(uniformLoc, 0.0f);

	// Render two times to check nondeterministic renderings
	glu::draw(m_context.getRenderContext(), program.getProgram(), 1, &posBinding, glu::pr::Triangles(DE_LENGTH_OF_ARRAY(indices), &indices[0]));
	glu::readPixels(m_context.getRenderContext(), 0, 0, img);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Draw");
}

void ShaderMetamorphicVariant::checkNondet (const tcu::Surface& refImg, const std::string& vertexSrc, const std::string& fragmentSrc)
{
	TestLog&		log	= m_testCtx.getLog();
	tcu::Surface	img	= tcu::Surface(refImg.getWidth(), refImg.getHeight());

	render(img.getAccess(), vertexSrc, fragmentSrc);
	bool same = tcu::pixelThresholdCompare(log, "Result", "Image comparison result", img, refImg, tcu::RGBA(0,0,0,0), tcu::COMPARE_LOG_RESULT);
	if (!same)
		throw tcu::TestError("Nondeterministic rendering");
}

ShaderMetamorphicVariant::IterateResult ShaderMetamorphicVariant::iterate (void)
{
	TestLog&			log				= m_testCtx.getLog();
	const tcu::RGBA		threshold		= tcu::RGBA(1,1,1,1) + m_context.getRenderTarget().getPixelFormat().getColorThreshold();
	std::string			vertexSrc		= fileContents(m_vertexFilename);
	std::string			recipientSrc	= fileContents(m_recipientFilename);
	std::string			variantSrc		= fileContents(m_variantFilename);
	const int			width			= deMin32(m_context.getRenderTarget().getWidth(), MAX_RENDER_WIDTH);
	const int			height			= deMin32(m_context.getRenderTarget().getHeight(), MAX_RENDER_HEIGHT);
	tcu::Surface		recipientImg	= tcu::Surface(width, height);
	tcu::Surface		variantImg		= tcu::Surface(width, height);

	render(recipientImg.getAccess(), vertexSrc, recipientSrc);
	render(variantImg.getAccess(), vertexSrc, variantSrc);

	checkNondet(recipientImg, vertexSrc, recipientSrc);
	checkNondet(variantImg, vertexSrc, variantSrc);

	if (m_sanityCheck != DE_NULL)
	{
		bool isSane = m_sanityCheck(recipientImg.getAccess());
		if (!isSane)
			throw tcu::TestError("Sanity check fails on recipient");
	}

	bool isOk = tcu::pixelThresholdCompare(log, "Result", "Image comparison result", recipientImg, variantImg, threshold, tcu::COMPARE_LOG_RESULT);

	m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS	: QP_TEST_RESULT_FAIL,
							isOk ? "Pass"				: "Image comparison failed");

	return STOP;
}

/*--------------------------------------------------------------------*//*!
 * \brief ShaderMetamorphicShaderset
 *
 * ShaderMetamorphicShaderset gathers a set of ShaderMetamorphicVariant
 * for a similar recipient.
 *//*--------------------------------------------------------------------*/
class ShaderMetamorphicShaderset : public TestCaseGroup
{
public:
					ShaderMetamorphicShaderset	(Context& context, const char* name, const std::string& vertexFilename, const std::string& recipientFilename, std::vector<std::string> variantFilenames, SanityCheckFunc sanityCheck);
					~ShaderMetamorphicShaderset	(void);
	virtual void	init						(void);

private:
	const std::string			m_vertexFilename;
	const std::string			m_recipientFilename;
	std::vector<std::string>	m_variantFilenames;
	SanityCheckFunc				m_sanityCheck;

								ShaderMetamorphicShaderset	(const ShaderMetamorphicShaderset&);	// Not allowed!
	ShaderMetamorphicShaderset&	operator=					(const ShaderMetamorphicShaderset&);	// Not allowed!
};

ShaderMetamorphicShaderset::ShaderMetamorphicShaderset (Context& context, const char *name, const std::string& vertexFilename, const std::string& recipientFilename, std::vector<std::string> variantFilenames, SanityCheckFunc sanityCheck)
	: TestCaseGroup			(context, name, "Metamorphic Shader Set")
	, m_vertexFilename		(vertexFilename)
	, m_recipientFilename	(recipientFilename)
	, m_variantFilenames	(variantFilenames)
	, m_sanityCheck			(sanityCheck)
{
}

ShaderMetamorphicShaderset::~ShaderMetamorphicShaderset (void)
{
}

void ShaderMetamorphicShaderset::init(void)
{
	for (size_t variantNdx = 0; variantNdx < m_variantFilenames.size(); variantNdx++)
	{
		std::string variantName = de::FilePath(m_variantFilenames[variantNdx]).getBaseName();
		// Remove extension
		size_t pos	= variantName.find_last_of(".");
		variantName	= variantName.substr(0, pos);

		addChild(new ShaderMetamorphicVariant(m_context, variantName.c_str(), m_vertexFilename, m_recipientFilename, m_variantFilenames[variantNdx], m_sanityCheck));
	}
}

/*--------------------------------------------------------------------*//*!
 * \brief SanityPixel
 *
 * A place holder to store info on reference pixel for sanity checking.
 *//*--------------------------------------------------------------------*/
class SanityPixel
{
public:
	float		m_xRelative;
	float		m_yRelative;
	tcu::Vec4	m_RGBA;

	SanityPixel (float xRelative, float yRelative, tcu::Vec4 RGBA);
};

SanityPixel::SanityPixel (float xRelative, float yRelative, tcu::Vec4 RGBA)
	: m_xRelative	(xRelative)
	, m_yRelative	(yRelative)
	, m_RGBA		(RGBA)
{
}

static bool sanityComparePixels (const tcu::ConstPixelBufferAccess& img, std::vector<SanityPixel> sanityPixels)
{
	const int			depth		= 0;
	const tcu::Vec4		threshold	= tcu::Vec4(0.01f, 0.01f, 0.01f, 0.01f);

	for (deUint32 i = 0; i < sanityPixels.size(); i++)
	{
		SanityPixel		sanPix	= sanityPixels[i];
		int				x		= (int)((float)img.getWidth() * sanPix.m_xRelative);
		int				y		= (int)((float)img.getHeight() * sanPix.m_yRelative);
		tcu::Vec4		RGBA	= img.getPixel(x, y, depth);
		tcu::Vec4		diff	= abs(RGBA - sanPix.m_RGBA);
		for (int j = 0; j < 4; j++)
			if (diff[j] >= threshold[j])
				return false;
	}
	return true;
}

static bool sanityCheck_synthetic (const tcu::ConstPixelBufferAccess& img)
{
	std::vector<SanityPixel>	sanityPixels;
	bool						isOK;

	sanityPixels.push_back(SanityPixel(0.5f, 0.5f, tcu::Vec4(0.0f, 1.0f, 1.0f, 1.0f)));

	isOK = sanityComparePixels(img, sanityPixels);
	return isOK;
}

static bool sanityCheck_bubblesort_flag (const tcu::ConstPixelBufferAccess& img)
{
	std::vector<SanityPixel>	sanityPixels;
	bool						isOK;

	sanityPixels.push_back(SanityPixel(0.25f, 0.25f, tcu::Vec4(0.1f, 0.6f, 1.0f, 1.0f)));
	sanityPixels.push_back(SanityPixel(0.25f, 0.75f, tcu::Vec4(1.0f, 0.5f, 0.1f, 1.0f)));
	sanityPixels.push_back(SanityPixel(0.75f, 0.25f, tcu::Vec4(0.6f, 1.0f, 0.1f, 1.0f)));
	sanityPixels.push_back(SanityPixel(0.75f, 0.75f, tcu::Vec4(0.5f, 0.1f, 1.0f, 1.0f)));

	isOK = sanityComparePixels(img, sanityPixels);
	return isOK;
}

/*--------------------------------------------------------------------*//*!
 * \brief ShaderMetamorphicTests
 *
 * ShaderMetamorphicTests regroups metamorphic shadersets.
 *//*--------------------------------------------------------------------*/
ShaderMetamorphicTests::ShaderMetamorphicTests (Context& context)
: TestCaseGroup(context, "metamorphic", "Shader Metamorphic Tests")
{
}

ShaderMetamorphicTests::~ShaderMetamorphicTests (void)
{
}

void ShaderMetamorphicTests::init (void)
{
	std::vector<std::string>	fragNames;
	std::string					vertexFilename = "graphicsfuzz/vertexShader.glsl";

	// synthetic
	fragNames.clear();
	fragNames.push_back("graphicsfuzz/synthetic/variant_1.frag");
	fragNames.push_back("graphicsfuzz/synthetic/variant_2.frag");
	fragNames.push_back("graphicsfuzz/synthetic/variant_3.frag");
	fragNames.push_back("graphicsfuzz/synthetic/variant_4.frag");
	addChild(new ShaderMetamorphicShaderset (m_context, "synthetic", vertexFilename, "graphicsfuzz/synthetic/recipient.frag", fragNames, sanityCheck_synthetic));

	// bubblesort_flag
	fragNames.clear();
	fragNames.push_back("graphicsfuzz/bubblesort_flag/variant_1.frag");
	fragNames.push_back("graphicsfuzz/bubblesort_flag/variant_2.frag");
	addChild(new ShaderMetamorphicShaderset (m_context, "bubblesort_flag", vertexFilename, "graphicsfuzz/bubblesort_flag/recipient.frag", fragNames, sanityCheck_bubblesort_flag));

}

} // Functional
} // gles3
} // deqp