#ifndef _ESEXTCTEXTUREBUFFERACTIVEUNIFORMVALIDATION_HPP
#define _ESEXTCTEXTUREBUFFERACTIVEUNIFORMVALIDATION_HPP
/*-------------------------------------------------------------------------
 * OpenGL Conformance Test Suite
 * -----------------------------
 *
 * Copyright (c) 2014-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  esextcTextureBufferActiveUniformValidation.hpp
 * \brief Texture Buffer -  Active Uniform Value Validation (Test 8)
 */ /*-------------------------------------------------------------------*/

#include "../esextcTestCaseBase.hpp"
#include <map>

namespace glcts
{

/** Implementation of (Test 8) from CTS_EXT_texture_buffer. Description follows
 *
 *   Check whether glGetActiveUniform, glGetActiveUniformsiv and
 *   glGetProgramResourceiv functions return correct information about active
 *   uniform variables of the type:
 *
 *   SAMPLER_BUFFER_EXT
 *   INT_SAMPLER_BUFFER_EXT
 *   UNSIGNED_INT_SAMPLER_BUFFER_EXT
 *   IMAGE_BUFFER_EXT
 *   INT_IMAGE_BUFFER_EXT
 *   UNSIGNED_INT_IMAGE_BUFFER_EXT
 *
 *   Category: API.
 *
 *   Write a fragment shader that defines the following uniform variables:
 *
 *   uniform highp samplerBuffer   sampler_buffer;
 *   uniform highp isamplerBuffer  isampler_buffer;
 *   uniform highp usamplerBuffer  usampler_buffer;
 *
 *   Make sure each of the uniform variables will be considered active.
 *   A uniform variable is considered active if it is determined during the link
 *   operation that it may be accessed during program execution. The easiest way
 *   to make sure the above variables are active is to call texelFetch on each
 *   texture sampler and imageLoad on each image sampler and use the returned
 *   values to determine the output color.
 *
 *   Pair the fragment shader with a boilerplate vertex shader.
 *
 *   Compile vertex and fragment shader, attach them to a program object and link
 *   the program object.
 *
 *   Get the number of active uniforms in the program object by calling
 *   glGetProgramiv with the value GL_ACTIVE_UNIFORMS and store the result in
 *   n_active_uniforms variable.
 *
 *   For index values ranging from zero to n_active_uniforms - 1 get the information
 *   about the uniform variable by calling glGetActiveUniform.
 *
 *   This phase of the test passes if among the returned information
 *   about active uniforms for the specified program object we can identify:
 *
 *   Name:               Type:
 *
 *   "sampler_buffer"    SAMPLER_BUFFER_EXT
 *   "isampler_buffer"   INT_SAMPLER_BUFFER_EXT
 *   "usampler_buffer"   UNSIGNED_INT_SAMPLER_BUFFER_EXT
 *
 *   Store which index corresponds to which variable type.
 *
 *   Create an array holding uniform variables' indices ranging from
 *   zero to n_active_uniforms - 1.
 *
 *   Call
 *
 *   glGetActiveUniformsiv( po_id, n_active_uniforms, indices_array,
 *       GL_UNIFORM_TYPE, types_array );
 *
 *   This phase of the test passes if the resulting types array holds for each
 *   index value in indices_array the same uniform type as returned previously by
 *   glGetActiveUniform called for this index.
 *
 *   For index values ranging from zero to n_active_uniforms - 1
 *   get the type information about the uniform variable by calling
 *   glGetProgramResourceiv with GL_UNIFORM program interface and GL_TYPE property.
 *
 *   This phase of the test passes if for each index value the returned type is
 *   equal to the one previously returned by glGetActiveUniform.
 *
 *   Repeat the test for a compute shader that defines the following uniform
 *   variables:
 *
 *   uniform highp   imageBuffer     image_buffer;
 *   uniform highp   iimageBuffer    iimage_buffer;
 *   uniform highp   uimageBuffer    uimage_buffer;
 *
 *   The corresponding types for the above uniform variables are:
 *
 *   IMAGE_BUFFER_EXT
 *   INT_IMAGE_BUFFER_EXT
 *   UNSIGNED_INT_IMAGE_BUFFER_EXT
 *
 */

/* Helper Sctructure storing texture confituration parameters */
class TextureParameters
{
public:
    TextureParameters();
    TextureParameters(glw::GLuint textureBufferSize, glw::GLenum textureFormat, glw::GLenum textureUniformType,
                      const char *uniformName);

    glw::GLuint get_texture_buffer_size() const
    {
        return m_texture_buffer_size;
    }

    glw::GLenum get_texture_format() const
    {
        return m_texture_format;
    }

    glw::GLenum get_texture_uniform_type() const
    {
        return m_texture_uniform_type;
    }

    std::string get_uniform_name() const
    {
        return m_uniform_name;
    }

private:
    glw::GLenum m_texture_buffer_size;
    glw::GLenum m_texture_format;
    glw::GLenum m_texture_uniform_type;
    std::string m_uniform_name;
};

/* Base Class */
class TextureBufferActiveUniformValidation : public TestCaseBase
{
public:
    /* Public methods */
    TextureBufferActiveUniformValidation(Context &context, const ExtParameters &extParams, const char *name,
                                         const char *description);

    virtual ~TextureBufferActiveUniformValidation()
    {
    }

    virtual void deinit(void);
    virtual IterateResult iterate(void);

protected:
    /* Protected methods */
    void addTextureParam(glw::GLenum uniformType, glw::GLenum format, glw::GLuint size, const char *name,
                         std::vector<TextureParameters> *params);

    /* Protected variables */
    glw::GLuint m_po_id;

    static const glw::GLuint m_param_value_size;

private:
    /* Private methods */
    virtual void configureParams(std::vector<TextureParameters> *params)                       = 0;
    virtual void configureProgram(std::vector<TextureParameters> *params, glw::GLuint *texIds) = 0;
    virtual void createProgram(void)                                                           = 0;

    virtual void initTest(void);
    const char *getUniformTypeName(glw::GLenum uniformType);
    const TextureParameters *getParamsForType(glw::GLenum uniformType) const;

    /* Variables for general usage */
    glw::GLuint *m_tbo_ids;
    glw::GLuint *m_tbo_tex_ids;
    std::vector<TextureParameters> m_texture_params;
};

/* Vertex/Fragment Shader (Case 1)*/
class TextureBufferActiveUniformValidationVSFS : public TextureBufferActiveUniformValidation
{
public:
    /* Public methods */
    TextureBufferActiveUniformValidationVSFS(Context &context, const ExtParameters &extParams, const char *name,
                                             const char *description);

    virtual ~TextureBufferActiveUniformValidationVSFS()
    {
    }

    virtual void deinit(void);

private:
    /* Private methods */
    virtual void configureParams(std::vector<TextureParameters> *params);
    virtual void configureProgram(std::vector<TextureParameters> *params, glw::GLuint *texIds);
    virtual void createProgram(void);

    const char *getFragmentShaderCode(void) const;
    const char *getVertexShaderCode(void) const;

    /* Variables for general usage */
    glw::GLuint m_fs_id;
    glw::GLuint m_vs_id;
};

/* Compute Shader (Case 2)*/
class TextureBufferActiveUniformValidationCS : public TextureBufferActiveUniformValidation
{
public:
    /* Public methods */
    TextureBufferActiveUniformValidationCS(Context &context, const ExtParameters &extParams, const char *name,
                                           const char *description);

    virtual ~TextureBufferActiveUniformValidationCS()
    {
    }

    virtual void deinit(void);

private:
    /* Private methods */
    virtual void configureParams(std::vector<TextureParameters> *params);
    virtual void configureProgram(std::vector<TextureParameters> *params, glw::GLuint *texIds);
    virtual void createProgram(void);

    const char *getComputeShaderCode(void) const;

    /* Variables for general usage */
    glw::GLuint m_cs_id;
};

} // namespace glcts

#endif // _ESEXTCTEXTUREBUFFERACTIVEUNIFORMVALIDATION_HPP