/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL ES 3.0 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 Indexed State Query tests.
 *//*--------------------------------------------------------------------*/

#include "es3fIndexedStateQueryTests.hpp"
#include "es3fApiCase.hpp"
#include "glsStateQueryUtil.hpp"
#include "tcuRenderTarget.hpp"
#include "glwEnums.hpp"

using namespace glw; // GLint and other GL types
using deqp::gls::StateQueryUtil::StateQueryMemoryWriteGuard;

namespace deqp
{
namespace gles3
{
namespace Functional
{
namespace
{

void checkIntEquals (tcu::TestContext& testCtx, GLint got, GLint expected)
{
	using tcu::TestLog;

	if (got != expected)
	{
		testCtx.getLog() << TestLog::Message << "// ERROR: Expected " << expected << "; got " << got << TestLog::EndMessage;
		if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
			testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got invalid value");
	}
}

void checkIntEquals (tcu::TestContext& testCtx, GLint64 got, GLint64 expected)
{
	using tcu::TestLog;

	if (got != expected)
	{
		testCtx.getLog() << TestLog::Message << "// ERROR: Expected " << expected << "; got " << got << TestLog::EndMessage;
		if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
			testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got invalid value");
	}
}

class TransformFeedbackCase : public ApiCase
{
public:
	TransformFeedbackCase (Context& context, const char* name, const char* description)
		: ApiCase(context, name, description)
	{
	}

	virtual void testTransformFeedback (void) = DE_NULL;

	void test (void)
	{
		static const char* transformFeedbackTestVertSource	=	"#version 300 es\n"
																"out highp vec4 anotherOutput;\n"
																"void main (void)\n"
																"{\n"
																"	gl_Position = vec4(0.0);\n"
																"	anotherOutput = vec4(0.0);\n"
																"}\n\0";
		static const char* transformFeedbackTestFragSource	=	"#version 300 es\n"
																"layout(location = 0) out mediump vec4 fragColor;"
																"void main (void)\n"
																"{\n"
																"	fragColor = vec4(0.0);\n"
																"}\n\0";

		GLuint shaderVert = glCreateShader(GL_VERTEX_SHADER);
		GLuint shaderFrag = glCreateShader(GL_FRAGMENT_SHADER);

		glShaderSource(shaderVert, 1, &transformFeedbackTestVertSource, DE_NULL);
		glShaderSource(shaderFrag, 1, &transformFeedbackTestFragSource, DE_NULL);

		glCompileShader(shaderVert);
		glCompileShader(shaderFrag);
		expectError(GL_NO_ERROR);

		GLuint shaderProg = glCreateProgram();
		glAttachShader(shaderProg, shaderVert);
		glAttachShader(shaderProg, shaderFrag);

		const char* transformFeedbackOutputs[] =
		{
			"gl_Position",
			"anotherOutput"
		};

		glTransformFeedbackVaryings(shaderProg, 2, transformFeedbackOutputs, GL_INTERLEAVED_ATTRIBS);
		glLinkProgram(shaderProg);
		expectError(GL_NO_ERROR);

		GLuint transformFeedbackId = 0;
		glGenTransformFeedbacks(1, &transformFeedbackId);
		glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, transformFeedbackId);
		expectError(GL_NO_ERROR);

		testTransformFeedback();

		// cleanup

		glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);

		glDeleteTransformFeedbacks(1, &transformFeedbackId);
		glDeleteShader(shaderVert);
		glDeleteShader(shaderFrag);
		glDeleteProgram(shaderProg);
		expectError(GL_NO_ERROR);
	}
};

class TransformFeedbackBufferBindingCase : public TransformFeedbackCase
{
public:
	TransformFeedbackBufferBindingCase (Context& context, const char* name, const char* description)
		: TransformFeedbackCase(context, name, description)
	{
	}

	void testTransformFeedback (void)
	{
		const int feedbackPositionIndex = 0;
		const int feedbackOutputIndex = 1;
		const int feedbackIndex[2] = {feedbackPositionIndex, feedbackOutputIndex};

		// bind bffers

		GLuint feedbackBuffers[2];
		glGenBuffers(2, feedbackBuffers);
		expectError(GL_NO_ERROR);

		for (int ndx = 0; ndx < 2; ++ndx)
		{
			glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, feedbackBuffers[ndx]);
			glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 16, NULL, GL_DYNAMIC_READ);
			glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, feedbackIndex[ndx], feedbackBuffers[ndx]);
			expectError(GL_NO_ERROR);
		}

		// test TRANSFORM_FEEDBACK_BUFFER_BINDING

		for (int ndx = 0; ndx < 2; ++ndx)
		{
			StateQueryMemoryWriteGuard<GLint> boundBuffer;
			glGetIntegeri_v(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, feedbackIndex[ndx], &boundBuffer);
			boundBuffer.verifyValidity(m_testCtx);
			checkIntEquals(m_testCtx, boundBuffer, feedbackBuffers[ndx]);
		}


		// cleanup

		glDeleteBuffers(2, feedbackBuffers);
	}
};

class TransformFeedbackBufferBufferCase : public TransformFeedbackCase
{
public:
	TransformFeedbackBufferBufferCase (Context& context, const char* name, const char* description)
		: TransformFeedbackCase(context, name, description)
	{
	}

	void testTransformFeedback (void)
	{
		const int feedbackPositionIndex = 0;
		const int feedbackOutputIndex = 1;

		const int rangeBufferOffset = 4;
		const int rangeBufferSize = 8;

		// bind buffers

		GLuint feedbackBuffers[2];
		glGenBuffers(2, feedbackBuffers);
		expectError(GL_NO_ERROR);

		glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, feedbackBuffers[0]);
		glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 16, NULL, GL_DYNAMIC_READ);
		glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, feedbackPositionIndex, feedbackBuffers[0]);
		expectError(GL_NO_ERROR);

		glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, feedbackBuffers[1]);
		glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 16, NULL, GL_DYNAMIC_READ);
		glBindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, feedbackOutputIndex, feedbackBuffers[1], rangeBufferOffset, rangeBufferSize);
		expectError(GL_NO_ERROR);

		// test TRANSFORM_FEEDBACK_BUFFER_START and TRANSFORM_FEEDBACK_BUFFER_SIZE

		const struct BufferRequirements
		{
			GLint	index;
			GLenum	pname;
			GLint64 value;
		} requirements[] =
		{
			{ feedbackPositionIndex,	GL_TRANSFORM_FEEDBACK_BUFFER_START, 0					},
			{ feedbackPositionIndex,	GL_TRANSFORM_FEEDBACK_BUFFER_SIZE,	0					},
			{ feedbackOutputIndex,		GL_TRANSFORM_FEEDBACK_BUFFER_START, rangeBufferOffset	},
			{ feedbackOutputIndex,		GL_TRANSFORM_FEEDBACK_BUFFER_SIZE,	rangeBufferSize		}
		};

		for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(requirements); ++ndx)
		{
			StateQueryMemoryWriteGuard<GLint64> state;
			glGetInteger64i_v(requirements[ndx].pname, requirements[ndx].index, &state);

			if (state.verifyValidity(m_testCtx))
				checkIntEquals(m_testCtx, state, requirements[ndx].value);
		}

		// cleanup

		glDeleteBuffers(2, feedbackBuffers);
	}
};

class UniformBufferCase : public ApiCase
{
public:
	UniformBufferCase (Context& context, const char* name, const char* description)
		: ApiCase	(context, name, description)
		, m_program	(0)
	{
	}

	virtual void testUniformBuffers (void) = DE_NULL;

	void test (void)
	{
		static const char* testVertSource	=	"#version 300 es\n"
												"uniform highp vec4 input1;\n"
												"uniform highp vec4 input2;\n"
												"void main (void)\n"
												"{\n"
												"	gl_Position = input1 + input2;\n"
												"}\n\0";
		static const char* testFragSource	=	"#version 300 es\n"
												"layout(location = 0) out mediump vec4 fragColor;"
												"void main (void)\n"
												"{\n"
												"	fragColor = vec4(0.0);\n"
												"}\n\0";

		GLuint shaderVert = glCreateShader(GL_VERTEX_SHADER);
		GLuint shaderFrag = glCreateShader(GL_FRAGMENT_SHADER);

		glShaderSource(shaderVert, 1, &testVertSource, DE_NULL);
		glShaderSource(shaderFrag, 1, &testFragSource, DE_NULL);

		glCompileShader(shaderVert);
		glCompileShader(shaderFrag);
		expectError(GL_NO_ERROR);

		m_program = glCreateProgram();
		glAttachShader(m_program, shaderVert);
		glAttachShader(m_program, shaderFrag);
		glLinkProgram(m_program);
		glUseProgram(m_program);
		expectError(GL_NO_ERROR);

		testUniformBuffers();

		glUseProgram(0);
		glDeleteShader(shaderVert);
		glDeleteShader(shaderFrag);
		glDeleteProgram(m_program);
		expectError(GL_NO_ERROR);
	}

protected:
	GLuint	m_program;
};

class UniformBufferBindingCase : public UniformBufferCase
{
public:
	UniformBufferBindingCase (Context& context, const char* name, const char* description)
		: UniformBufferCase(context, name, description)
	{
	}

	void testUniformBuffers (void)
	{
		const char* uniformNames[] =
		{
			"input1",
			"input2"
		};
		GLuint uniformIndices[2] = {0};
		glGetUniformIndices(m_program, 2, uniformNames, uniformIndices);

		GLuint buffers[2];
		glGenBuffers(2, buffers);

		for (int ndx = 0; ndx < 2; ++ndx)
		{
			glBindBuffer(GL_UNIFORM_BUFFER, buffers[ndx]);
			glBufferData(GL_UNIFORM_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
			glBindBufferBase(GL_UNIFORM_BUFFER, uniformIndices[ndx], buffers[ndx]);
			expectError(GL_NO_ERROR);
		}

		for (int ndx = 0; ndx < 2; ++ndx)
		{
			StateQueryMemoryWriteGuard<GLint> boundBuffer;
			glGetIntegeri_v(GL_UNIFORM_BUFFER_BINDING, uniformIndices[ndx], &boundBuffer);

			if (boundBuffer.verifyValidity(m_testCtx))
				checkIntEquals(m_testCtx, boundBuffer, buffers[ndx]);
			expectError(GL_NO_ERROR);
		}

		glDeleteBuffers(2, buffers);
	}
};

class UniformBufferBufferCase : public UniformBufferCase
{
public:
	UniformBufferBufferCase (Context& context, const char* name, const char* description)
		: UniformBufferCase(context, name, description)
	{
	}

	void testUniformBuffers (void)
	{
		const char* uniformNames[] =
		{
			"input1",
			"input2"
		};
		GLuint uniformIndices[2] = {0};
		glGetUniformIndices(m_program, 2, uniformNames, uniformIndices);

		const GLint alignment = GetAlignment();
		if (alignment == -1) // cannot continue without this
			return;

		m_testCtx.getLog() << tcu::TestLog::Message << "Alignment is " << alignment << tcu::TestLog::EndMessage;

		int rangeBufferOffset		= alignment;
		int rangeBufferSize			= alignment * 2;
		int rangeBufferTotalSize	= rangeBufferOffset + rangeBufferSize + 8; // + 8 has no special meaning, just to make it != with the size of the range

		GLuint buffers[2];
		glGenBuffers(2, buffers);

		glBindBuffer(GL_UNIFORM_BUFFER, buffers[0]);
		glBufferData(GL_UNIFORM_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
		glBindBufferBase(GL_UNIFORM_BUFFER, uniformIndices[0], buffers[0]);
		expectError(GL_NO_ERROR);

		glBindBuffer(GL_UNIFORM_BUFFER, buffers[1]);
		glBufferData(GL_UNIFORM_BUFFER, rangeBufferTotalSize, DE_NULL, GL_DYNAMIC_DRAW);
		glBindBufferRange(GL_UNIFORM_BUFFER, uniformIndices[1], buffers[1], rangeBufferOffset, rangeBufferSize);
		expectError(GL_NO_ERROR);

		// test UNIFORM_BUFFER_START and UNIFORM_BUFFER_SIZE

		const struct BufferRequirements
		{
			GLuint	index;
			GLenum	pname;
			GLint64 value;
		} requirements[] =
		{
			{ uniformIndices[0], GL_UNIFORM_BUFFER_START,	0					},
			{ uniformIndices[0], GL_UNIFORM_BUFFER_SIZE,	0					},
			{ uniformIndices[1], GL_UNIFORM_BUFFER_START,	rangeBufferOffset	},
			{ uniformIndices[1], GL_UNIFORM_BUFFER_SIZE,	rangeBufferSize		}
		};

		for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(requirements); ++ndx)
		{
			StateQueryMemoryWriteGuard<GLint64> state;
			glGetInteger64i_v(requirements[ndx].pname, requirements[ndx].index, &state);

			if (state.verifyValidity(m_testCtx))
				checkIntEquals(m_testCtx, state, requirements[ndx].value);
			expectError(GL_NO_ERROR);
		}

		glDeleteBuffers(2, buffers);
	}

	int GetAlignment()
	{
		StateQueryMemoryWriteGuard<GLint> state;
		glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &state);

		if (!state.verifyValidity(m_testCtx))
			return -1;

		if (state <= 256)
			return state;

		m_testCtx.getLog() << tcu::TestLog::Message << "// ERROR: UNIFORM_BUFFER_OFFSET_ALIGNMENT has a maximum value of 256." << tcu::TestLog::EndMessage;
		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "invalid UNIFORM_BUFFER_OFFSET_ALIGNMENT value");

		return -1;
	}
};

} // anonymous

IndexedStateQueryTests::IndexedStateQueryTests (Context& context)
	: TestCaseGroup(context, "indexed", "Indexed Integer Values")
{
}

void IndexedStateQueryTests::init (void)
{
	// transform feedback
	addChild(new TransformFeedbackBufferBindingCase(m_context, "transform_feedback_buffer_binding", "TRANSFORM_FEEDBACK_BUFFER_BINDING"));
	addChild(new TransformFeedbackBufferBufferCase(m_context, "transform_feedback_buffer_start_size", "TRANSFORM_FEEDBACK_BUFFER_START and TRANSFORM_FEEDBACK_BUFFER_SIZE"));

	// uniform buffers
	addChild(new UniformBufferBindingCase(m_context, "uniform_buffer_binding", "UNIFORM_BUFFER_BINDING"));
	addChild(new UniformBufferBufferCase(m_context, "uniform_buffer_start_size", "UNIFORM_BUFFER_START and UNIFORM_BUFFER_SIZE"));
}

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