#ifndef _GL3CTEXTURESWIZZLETESTS_HPP
#define _GL3CTEXTURESWIZZLETESTS_HPP
/*-------------------------------------------------------------------------
 * OpenGL Conformance Test Suite
 * -----------------------------
 *
 * Copyright (c) 2015-2016 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
 * \brief
 */ /*-------------------------------------------------------------------*/

/**
 * \file  gl3cTextureSwizzleTests.hpp
 * \brief Declares test classes for "Texture Swizzle" functionality.
 */ /*-------------------------------------------------------------------*/

#include "glcTestCase.hpp"
#include "glwDefs.hpp"
#include "glwEnums.hpp"
#include "tcuDefs.hpp"
#include "tcuVector.hpp"
#include <queue>

namespace gl3cts
{
namespace TextureSwizzle
{
class Utils
{
public:
	/** Store information about program object
	 *
	 **/
	struct programInfo
	{
		programInfo(deqp::Context& context);
		~programInfo();

		void build(const glw::GLchar* fragment_shader_code, const glw::GLchar* vertex_shader_code);
		void compile(glw::GLuint shader_id, const glw::GLchar* shader_code) const;
		void link() const;

		deqp::Context& m_context;

		glw::GLuint m_fragment_shader_id;
		glw::GLuint m_program_object_id;
		glw::GLuint m_vertex_shader_id;
	};

	/* Public static methods */
	static void replaceToken(const glw::GLchar* token, size_t& search_position, const glw::GLchar* text,
							 std::string& string);
};

/** Implements APIErrors test, description follows:
 *
 * Verifies that errors are generated as expected.
 *
 * Check if:
 * - INVALID_OPERATION is generated by TexParameter* routines when <pname> is
 * one of [TEXTURE_SWIZZLE_R, TEXTURE_SWIZZLE_G, TEXTURE_SWIZZLE_B,
 * TEXTURE_SWIZZLE_A] and <param> is not one of [RED, GREEN, BLUE, ALPHA, ZERO,
 * ONE];
 * - INVALID_OPERATION is generated by TexParameter*v routines when <pname> is
 * TEXTURE_SWIZZLE_RGBA and any of four values pointed by <param> is not one of
 * [RED, GREEN, BLUE, ALPHA, ZERO, ONE].
 **/
class APIErrorsTest : public deqp::TestCase
{
public:
	/* Public methods */
	APIErrorsTest(deqp::Context& context);

	virtual void						 deinit();
	virtual tcu::TestNode::IterateResult iterate();

private:
	/* Private methods */
	void verifyError(const glw::GLenum expected_error);

	/* Private fields */
	glw::GLuint m_id;
};

/** Implements IntialState test, description follows:
 *
 * Verifies that intial state is as expected.
 *
 * Steps:
 * - create a texture;
 * - verify that query for TEXTURE_SWIZZLE_R results with RED;
 * - verify that query for TEXTURE_SWIZZLE_G results with GREEN;
 * - verify that query for TEXTURE_SWIZZLE_B results with BLUE;
 * - verify that query for TEXTURE_SWIZZLE_A results with ALPHA;
 * - verify that query for TEXTURE_SWIZZLE_RGBA results with [RED, GREEN, BLUE,
 * ALPHA].
 *
 * Use GetTexParameter to query states. If GL_ARB_direct_state_access is
 * supported than repeat the steps with GetTextureParameter.
 * Repeat the steps for all supported texture targets.
 **/
class IntialStateTest : public deqp::TestCase
{
public:
	/* Public methods */
	IntialStateTest(deqp::Context& context);

	virtual void						 deinit();
	virtual tcu::TestNode::IterateResult iterate();

private:
	/* Private methods */
	void verifyValues(const glw::GLenum texture_target);

	/* Private fields */
	glw::GLuint m_id;
};

/** Implements Smoke test, description follows:
 *
 * Verifies that all swizzle combinations work with all texture access
 * routines.
 *
 * Steps:
 * - prepare a source texture so that each channel is filled with specific
 * value;
 * - for each TEXTURE_SWIZZLE state combination:
 *   * for each channel [R, G, B, A]:
 *     + prepare a 2D single channeled texture with format matching sampled
 *     channel and set it up as output color in framebuffer;
 *     + prepare a program that will implement the following snippet in vertex
 *     stage and output the value of result:
 *
 *       result = texture(source).C;
 *
 *     + set swizzle states with channel specific enums;
 *     + draw a full-screen quad;
 *     + verify that the output texture is filled with correct value;
 *     + set swizzle states with RGBA enum;
 *     + draw a full-screen quad;
 *     + verify that the output texture is filled with correct value;
 *     + prepare a program that will implement the following snippet in
 *     fragment stage and output the value of result:
 *
 *       result = texture(source).C;
 *
 *     + set swizzle states with channel specific enums;
 *     + draw a full-screen quad;
 *     + verify that the output texture is filled with correct value;
 *     + set swizzle states with RGBA enum;
 *     + draw a full-screen quad;
 *     + verify that the output texture is filled with correct value.
 *
 * Value is correct when:
 * - it matches value assigned to the specified channel;
 * - it is one for missing alpha channel;
 * - it is zero for missing channel;
 * - it is one for ONE;
 * - it is zero for ZERO.
 *
 * Before any draw output texture should be cleared.
 * Source texture should be RGBA32UI 2D_ARRAY 1x1 of length 1 with
 * single mipmap at level 0.
 * Dimenssions of destination texture should be 8x8.
 * Repeat the steps for the following texture access routines:
 * - textureProj,
 * - textureLod,
 * - textureOffset,
 * - texelFetch,
 * - texelFetchOffset,
 * - textureProjOffset,
 * - textureLodOffset,
 * - textureProjLod,
 * - textureProjLodOffset,
 * - textureGrad,
 * - textureGradOffset,
 * - textureProjGrad,
 * - textureProjGradOffset.
 **/
class SmokeTest : public deqp::TestCase
{
public:
	/* Public methods */
	SmokeTest(deqp::Context& context);
	SmokeTest(deqp::Context& context, const glw::GLchar* name, const glw::GLchar* description);

	virtual void						 deinit();
	virtual tcu::TestNode::IterateResult iterate();

protected:
	/* Protected types */
	struct testCase
	{
		size_t	 m_channel_index;
		size_t	 m_source_texture_format_index;
		size_t	 m_source_texture_target_index;
		size_t	 m_texture_access_index;
		glw::GLint m_texture_swizzle_red;
		glw::GLint m_texture_swizzle_green;
		glw::GLint m_texture_swizzle_blue;
		glw::GLint m_texture_swizzle_alpha;
		glw::GLint m_texture_sizes[4];
	};

	/* Protected methods */
	void captureAndVerify(const testCase& test_case, size_t output_format_index, glw::GLint output_channel_size,
						  size_t index_of_swizzled_channel);

	void deinitOutputTexture();
	void deinitTextures();

	void draw(glw::GLenum target, const glw::GLint* texture_swizzle, bool use_rgba_enum);

	void executeTestCase(const testCase& test_case);

	virtual bool fillSourceTexture(size_t format_idx, size_t target_idx);

	std::string getFragmentShader(const testCase& test_case, size_t output_format_index, bool is_tested_stage);

	std::string getVertexShader(const testCase& test_case, bool is_tested_stage);

	bool isTargetSupported(size_t target_idx);

	bool isTargetSuppByAccess(size_t access_idx, size_t target_idx);

	bool isTargetSuppByFormat(size_t format_idx, size_t target_idx);

	void logTestCaseDetials(const testCase& test_case);

	void prepareAndTestProgram(const testCase& test_case, size_t output_format_index, glw::GLint output_channel_size,
							   size_t index_of_swizzled_channel, bool test_vertex_stage);

	std::string prepareArguments(const testCase& test_case);
	std::string prepareCoordinates(const testCase& test_case);

	std::string prepareDerivatives(const testCase& test_case, size_t index);

	std::string prepareOffsets(const testCase& test_case);
	void prepareOutputTexture(size_t format_idx);

	std::string prepareSample();
	void prepareSourceTexture(size_t format_idx, size_t target_idx, glw::GLint out_sizes[4]);

	void testInit();

	virtual void verifyOutputImage(const testCase& test_case, size_t output_format_index,
								   glw::GLint output_channel_size, size_t index_of_swizzled_channel,
								   const glw::GLubyte* data);

	/* Protected fields */
	bool		m_is_ms_supported;
	glw::GLuint m_prepare_fbo_id;
	glw::GLuint m_out_tex_id;
	glw::GLuint m_source_tex_id;
	glw::GLuint m_test_fbo_id;
	glw::GLuint m_vao_id;

	/* Protected constants */
	static const glw::GLsizei m_depth;
	static const glw::GLsizei m_height;
	static const glw::GLsizei m_width;
	static const glw::GLsizei m_output_height;
	static const glw::GLsizei m_output_width;
};

/** Implements Functional test, description follows:
 *
 * Verifies that swizzle is respected for textures of different formats and
 * targets.
 *
 * Modify Smoke in the following aspects:
 * - repeat the steps for all supported sized internal formats and
 * texture targets;
 * - repeat the steps for the texture_swizzle combinations listed below;
 * - use only texelFetch routine.
 *
 * List of texture_swizzle combinations to test:
 * - ABGR,
 * - 01RA,
 * - 0000,
 * - 1111,
 * - BBBB.
 *
 * Depth-stencil textures can be sampled only via RED channel. Test should set
 * DEPTH_STENCIL_TEXTURE_MODE to select which channel will be accessed.
 *
 * For multisampled targets maximum supported number of samples should be used
 * and fetch should be done to last sample.
 *
 * Support of multisampled targets by TexParameter* routines was introduced in
 * extension GL_ARB_texture_storage_multisample, which is part of core
 * specification since 4.3. Therefore texture_swizzle functionality may be used
 * with multisampled targets only if either context is at least 4.3 or
 * extension GL_ARB_texture_storage_multisample is supported.
 **/
class FunctionalTest : public SmokeTest
{
public:
	/* Public methods */
	FunctionalTest(deqp::Context& context);

	virtual tcu::TestNode::IterateResult iterate();

protected:
	/* Protected methods */
	virtual bool fillSourceTexture(size_t format_idx, size_t target_idx);

	bool fillMSTexture(size_t format_idx, size_t target_idx);

	void prepareProgram(size_t format_idx, Utils::programInfo& program);

	std::string prepareValues(size_t format_idx);

	virtual void verifyOutputImage(const testCase& test_case, size_t output_format_index,
								   glw::GLint output_channel_size, size_t index_of_swizzled_channel,
								   const glw::GLubyte* data);

private:
	/* Private types */
	class wrongResults : public std::exception
	{
	public:
		wrongResults(const FunctionalTest::testCase& test_case) : m_test_case(test_case)
		{
		}

		virtual ~wrongResults() throw()
		{
		}

		virtual const char* what() const throw()
		{
			return "Found pixel with wrong value";
		}

		FunctionalTest::testCase m_test_case;
	};
};
}

/** Group class for GPU Shader 5 conformance tests */
class TextureSwizzleTests : public deqp::TestCaseGroup
{
public:
	/* Public methods */
	TextureSwizzleTests(deqp::Context& context);
	virtual ~TextureSwizzleTests()
	{
	}

	virtual void init(void);

private:
	/* Private methods */
	TextureSwizzleTests(const TextureSwizzleTests&);
	TextureSwizzleTests& operator=(const TextureSwizzleTests&);
};
} /* gl3cts namespace */

#endif // _GL3CTEXTURESWIZZLETESTS_HPP