//
// Copyright 2018 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// validationES2.h:
//  Inlined validation functions for OpenGL ES 2.0 entry points.

#ifndef LIBANGLE_VALIDATION_ES2_H_
#define LIBANGLE_VALIDATION_ES2_H_

#include "libANGLE/ErrorStrings.h"
#include "libANGLE/validationES.h"
#include "libANGLE/validationES2_autogen.h"

namespace gl
{

void RecordVersionErrorES20(const Context *context, angle::EntryPoint entryPoint);

ANGLE_INLINE bool ValidateDrawArrays(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     PrimitiveMode mode,
                                     GLint first,
                                     GLsizei count)
{
    if (!ValidateDrawArraysCommon(context, entryPoint, mode, first, count, 1))
    {
        return false;
    }

    if (!ValidateDrawArraysTransformFeedbackBufferSize(context, entryPoint, &count, nullptr, 1))
    {
        return false;
    }

    return true;
}

ANGLE_INLINE bool ValidateUniform1f(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    UniformLocation location,
                                    GLfloat x)
{
    return ValidateUniform(context, entryPoint, GL_FLOAT, location, 1);
}

ANGLE_INLINE bool ValidateUniform1fv(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     UniformLocation location,
                                     GLsizei count,
                                     const GLfloat *v)
{
    if (!ValidateUniformValuePointer(context, entryPoint, v))
    {
        // Error already generated.
        return false;
    }

    return ValidateUniform(context, entryPoint, GL_FLOAT, location, count);
}

ANGLE_INLINE bool ValidateUniform1i(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    UniformLocation location,
                                    GLint x)
{
    return ValidateUniform1iv(context, entryPoint, location, 1, &x);
}

ANGLE_INLINE bool ValidateUniform2f(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    UniformLocation location,
                                    GLfloat x,
                                    GLfloat y)
{
    return ValidateUniform(context, entryPoint, GL_FLOAT_VEC2, location, 1);
}

ANGLE_INLINE bool ValidateUniform2fv(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     UniformLocation location,
                                     GLsizei count,
                                     const GLfloat *v)
{
    if (!ValidateUniformValuePointer(context, entryPoint, v))
    {
        // Error already generated.
        return false;
    }

    return ValidateUniform(context, entryPoint, GL_FLOAT_VEC2, location, count);
}

ANGLE_INLINE bool ValidateUniform2i(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    UniformLocation location,
                                    GLint x,
                                    GLint y)
{
    return ValidateUniform(context, entryPoint, GL_INT_VEC2, location, 1);
}

ANGLE_INLINE bool ValidateUniform2iv(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     UniformLocation location,
                                     GLsizei count,
                                     const GLint *v)
{
    if (!ValidateUniformValuePointer(context, entryPoint, v))
    {
        // Error already generated.
        return false;
    }

    return ValidateUniform(context, entryPoint, GL_INT_VEC2, location, count);
}

ANGLE_INLINE bool ValidateUniform3f(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    UniformLocation location,
                                    GLfloat x,
                                    GLfloat y,
                                    GLfloat z)
{
    return ValidateUniform(context, entryPoint, GL_FLOAT_VEC3, location, 1);
}

ANGLE_INLINE bool ValidateUniform3fv(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     UniformLocation location,
                                     GLsizei count,
                                     const GLfloat *v)
{
    if (!ValidateUniformValuePointer(context, entryPoint, v))
    {
        // Error already generated.
        return false;
    }

    return ValidateUniform(context, entryPoint, GL_FLOAT_VEC3, location, count);
}

ANGLE_INLINE bool ValidateUniform3i(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    UniformLocation location,
                                    GLint x,
                                    GLint y,
                                    GLint z)
{
    return ValidateUniform(context, entryPoint, GL_INT_VEC3, location, 1);
}

ANGLE_INLINE bool ValidateUniform3iv(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     UniformLocation location,
                                     GLsizei count,
                                     const GLint *v)
{
    if (!ValidateUniformValuePointer(context, entryPoint, v))
    {
        // Error already generated.
        return false;
    }

    return ValidateUniform(context, entryPoint, GL_INT_VEC3, location, count);
}

ANGLE_INLINE bool ValidateUniform4f(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    UniformLocation location,
                                    GLfloat x,
                                    GLfloat y,
                                    GLfloat z,
                                    GLfloat w)
{
    return ValidateUniform(context, entryPoint, GL_FLOAT_VEC4, location, 1);
}

ANGLE_INLINE bool ValidateUniform4fv(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     UniformLocation location,
                                     GLsizei count,
                                     const GLfloat *v)
{
    if (!ValidateUniformValuePointer(context, entryPoint, v))
    {
        // Error already generated.
        return false;
    }

    return ValidateUniform(context, entryPoint, GL_FLOAT_VEC4, location, count);
}

ANGLE_INLINE bool ValidateUniform4i(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    UniformLocation location,
                                    GLint x,
                                    GLint y,
                                    GLint z,
                                    GLint w)
{
    return ValidateUniform(context, entryPoint, GL_INT_VEC4, location, 1);
}

ANGLE_INLINE bool ValidateUniform4iv(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     UniformLocation location,
                                     GLsizei count,
                                     const GLint *v)
{
    if (!ValidateUniformValuePointer(context, entryPoint, v))
    {
        // Error already generated.
        return false;
    }

    return ValidateUniform(context, entryPoint, GL_INT_VEC4, location, count);
}

ANGLE_INLINE bool ValidateUniformMatrix2fv(const Context *context,
                                           angle::EntryPoint entryPoint,
                                           UniformLocation location,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLfloat *value)
{
    return ValidateUniformMatrix(context, entryPoint, GL_FLOAT_MAT2, location, count, transpose);
}

ANGLE_INLINE bool ValidateUniformMatrix3fv(const Context *context,
                                           angle::EntryPoint entryPoint,
                                           UniformLocation location,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLfloat *value)
{
    return ValidateUniformMatrix(context, entryPoint, GL_FLOAT_MAT3, location, count, transpose);
}

ANGLE_INLINE bool ValidateUniformMatrix4fv(const Context *context,
                                           angle::EntryPoint entryPoint,
                                           UniformLocation location,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLfloat *value)
{
    return ValidateUniformMatrix(context, entryPoint, GL_FLOAT_MAT4, location, count, transpose);
}

ANGLE_INLINE bool ValidateVertexAttrib1f(const PrivateState &state,
                                         ErrorSet *errors,
                                         angle::EntryPoint entryPoint,
                                         GLuint index,
                                         GLfloat x)
{
    return ValidateVertexAttribIndex(state, errors, entryPoint, index);
}

ANGLE_INLINE bool ValidateVertexAttrib1fv(const PrivateState &state,
                                          ErrorSet *errors,
                                          angle::EntryPoint entryPoint,
                                          GLuint index,
                                          const GLfloat *values)
{
    if (values == nullptr)
    {
        errors->validationError(entryPoint, GL_INVALID_VALUE, err::kVertexAttributeValueNULL);
        return false;
    }

    return ValidateVertexAttribIndex(state, errors, entryPoint, index);
}

ANGLE_INLINE bool ValidateVertexAttrib2f(const PrivateState &state,
                                         ErrorSet *errors,
                                         angle::EntryPoint entryPoint,
                                         GLuint index,
                                         GLfloat x,
                                         GLfloat y)
{
    return ValidateVertexAttribIndex(state, errors, entryPoint, index);
}

ANGLE_INLINE bool ValidateVertexAttrib2fv(const PrivateState &state,
                                          ErrorSet *errors,
                                          angle::EntryPoint entryPoint,
                                          GLuint index,
                                          const GLfloat *values)
{
    if (values == nullptr)
    {
        errors->validationError(entryPoint, GL_INVALID_VALUE, err::kVertexAttributeValueNULL);
        return false;
    }

    return ValidateVertexAttribIndex(state, errors, entryPoint, index);
}

ANGLE_INLINE bool ValidateVertexAttrib3f(const PrivateState &state,
                                         ErrorSet *errors,
                                         angle::EntryPoint entryPoint,
                                         GLuint index,
                                         GLfloat x,
                                         GLfloat y,
                                         GLfloat z)
{
    return ValidateVertexAttribIndex(state, errors, entryPoint, index);
}

ANGLE_INLINE bool ValidateVertexAttrib3fv(const PrivateState &state,
                                          ErrorSet *errors,
                                          angle::EntryPoint entryPoint,
                                          GLuint index,
                                          const GLfloat *values)
{
    if (values == nullptr)
    {
        errors->validationError(entryPoint, GL_INVALID_VALUE, err::kVertexAttributeValueNULL);
        return false;
    }

    return ValidateVertexAttribIndex(state, errors, entryPoint, index);
}

ANGLE_INLINE bool ValidateVertexAttrib4f(const PrivateState &state,
                                         ErrorSet *errors,
                                         angle::EntryPoint entryPoint,
                                         GLuint index,
                                         GLfloat x,
                                         GLfloat y,
                                         GLfloat z,
                                         GLfloat w)
{
    return ValidateVertexAttribIndex(state, errors, entryPoint, index);
}

ANGLE_INLINE bool ValidateVertexAttrib4fv(const PrivateState &state,
                                          ErrorSet *errors,
                                          angle::EntryPoint entryPoint,
                                          GLuint index,
                                          const GLfloat *values)
{
    if (values == nullptr)
    {
        errors->validationError(entryPoint, GL_INVALID_VALUE, err::kVertexAttributeValueNULL);
        return false;
    }

    return ValidateVertexAttribIndex(state, errors, entryPoint, index);
}

ANGLE_INLINE bool ValidateGenBuffers(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     GLint n,
                                     const BufferID *buffers)
{
    return ValidateGenOrDelete(context->getMutableErrorSetForValidation(), entryPoint, n, buffers);
}

ANGLE_INLINE bool ValidateGenFramebuffers(const Context *context,
                                          angle::EntryPoint entryPoint,
                                          GLint n,
                                          const FramebufferID *framebuffers)
{
    return ValidateGenOrDelete(context->getMutableErrorSetForValidation(), entryPoint, n,
                               framebuffers);
}

ANGLE_INLINE bool ValidateGenRenderbuffers(const Context *context,
                                           angle::EntryPoint entryPoint,
                                           GLint n,
                                           const RenderbufferID *renderbuffers)
{
    return ValidateGenOrDelete(context->getMutableErrorSetForValidation(), entryPoint, n,
                               renderbuffers);
}

ANGLE_INLINE bool ValidateGenTextures(const Context *context,
                                      angle::EntryPoint entryPoint,
                                      GLint n,
                                      const TextureID *textures)
{
    return ValidateGenOrDelete(context->getMutableErrorSetForValidation(), entryPoint, n, textures);
}

ANGLE_INLINE bool ValidateGenerateMipmap(const Context *context,
                                         angle::EntryPoint entryPoint,
                                         TextureType target)
{
    return ValidateGenerateMipmapBase(context, entryPoint, target);
}

ANGLE_INLINE bool ValidateGetBufferParameteriv(const Context *context,
                                               angle::EntryPoint entryPoint,
                                               BufferBinding targetPacked,
                                               BufferParam pnamePacked,
                                               const GLint *params)
{
    return ValidateGetBufferParameterBase(context, entryPoint, targetPacked, pnamePacked, nullptr);
}

ANGLE_INLINE bool ValidateGetRenderbufferParameteriv(const Context *context,
                                                     angle::EntryPoint entryPoint,
                                                     GLenum target,
                                                     GLenum pname,
                                                     const GLint *params)
{
    return ValidateGetRenderbufferParameterivBase(context, entryPoint, target, pname, nullptr);
}

ANGLE_INLINE bool ValidateGetShaderiv(const Context *context,
                                      angle::EntryPoint entryPoint,
                                      ShaderProgramID shaderPacked,
                                      ShaderParameter pnamePacked,
                                      const GLint *params)
{
    return ValidateGetShaderivBase(context, entryPoint, shaderPacked, pnamePacked, params, nullptr);
}

ANGLE_INLINE bool ValidateGetTexParameterfv(const Context *context,
                                            angle::EntryPoint entryPoint,
                                            TextureType targetPacked,
                                            GLenum pname,
                                            const GLfloat *params)
{
    return ValidateGetTexParameterBase(context, entryPoint, targetPacked, pname, nullptr);
}

ANGLE_INLINE bool ValidateGetTexParameteriv(const Context *context,
                                            angle::EntryPoint entryPoint,
                                            TextureType targetPacked,
                                            GLenum pname,
                                            const GLint *params)
{
    return ValidateGetTexParameterBase(context, entryPoint, targetPacked, pname, nullptr);
}

ANGLE_INLINE bool ValidateGetUniformfv(const Context *context,
                                       angle::EntryPoint entryPoint,
                                       ShaderProgramID programPacked,
                                       UniformLocation locationPacked,
                                       const GLfloat *params)
{
    return ValidateGetUniformBase(context, entryPoint, programPacked, locationPacked);
}

ANGLE_INLINE bool ValidateGetUniformiv(const Context *context,
                                       angle::EntryPoint entryPoint,
                                       ShaderProgramID programPacked,
                                       UniformLocation locationPacked,
                                       const GLint *params)
{
    return ValidateGetUniformBase(context, entryPoint, programPacked, locationPacked);
}

ANGLE_INLINE bool ValidateGetVertexAttribfv(const Context *context,
                                            angle::EntryPoint entryPoint,
                                            GLuint index,
                                            GLenum pname,
                                            const GLfloat *params)
{
    return ValidateGetVertexAttribBase(context, entryPoint, index, pname, nullptr);
}

ANGLE_INLINE bool ValidateGetVertexAttribiv(const Context *context,
                                            angle::EntryPoint entryPoint,
                                            GLuint index,
                                            GLenum pname,
                                            const GLint *params)
{
    return ValidateGetVertexAttribBase(context, entryPoint, index, pname, nullptr);
}

ANGLE_INLINE bool ValidateGetVertexAttribPointerv(const Context *context,
                                                  angle::EntryPoint entryPoint,
                                                  GLuint index,
                                                  GLenum pname,
                                                  void *const *pointer)
{
    return ValidateGetVertexAttribPointerBase(context, entryPoint, index, pname, nullptr);
}

ANGLE_INLINE bool ValidateReadPixels(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     GLint x,
                                     GLint y,
                                     GLsizei width,
                                     GLsizei height,
                                     GLenum format,
                                     GLenum type,
                                     const void *pixels)
{
    return ValidateReadPixelsBase(context, entryPoint, x, y, width, height, format, type,
                                  std::numeric_limits<GLsizei>::max(), pixels);
}

ANGLE_INLINE bool ValidateTexParameterf(const Context *context,
                                        angle::EntryPoint entryPoint,
                                        TextureType targetPacked,
                                        GLenum pname,
                                        GLfloat param)
{
    return ValidateTexParameterBase(context, entryPoint, targetPacked, pname, &param);
}

ANGLE_INLINE bool ValidateTexParameterfv(const Context *context,
                                         angle::EntryPoint entryPoint,
                                         TextureType targetPacked,
                                         GLenum pname,
                                         const GLfloat *params)
{
    return ValidateTexParameterBase(context, entryPoint, targetPacked, pname, params);
}

ANGLE_INLINE bool ValidateTexParameteri(const Context *context,
                                        angle::EntryPoint entryPoint,
                                        TextureType targetPacked,
                                        GLenum pname,
                                        GLint param)
{
    return ValidateTexParameterBase(context, entryPoint, targetPacked, pname, &param);
}

ANGLE_INLINE bool ValidateTexParameteriv(const Context *context,
                                         angle::EntryPoint entryPoint,
                                         TextureType targetPacked,
                                         GLenum pname,
                                         const GLint *params)
{
    return ValidateTexParameterBase(context, entryPoint, targetPacked, pname, params);
}

ANGLE_INLINE bool ValidateBindBuffer(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     BufferBinding target,
                                     BufferID buffer)
{
    if (!context->isValidBufferBinding(target))
    {
        ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, err::kInvalidBufferTarget);
        return false;
    }

    if (!context->getState().isBindGeneratesResourceEnabled() &&
        !context->isBufferGenerated(buffer))
    {
        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, err::kObjectNotGenerated);
        return false;
    }

    if (context->isWebGL() && !ValidateWebGLBufferBinding(context, entryPoint, target, buffer))
    {
        // Error already generated
        return false;
    }

    return true;
}

ANGLE_INLINE bool ValidateDrawElements(const Context *context,
                                       angle::EntryPoint entryPoint,
                                       PrimitiveMode mode,
                                       GLsizei count,
                                       DrawElementsType type,
                                       const void *indices)
{
    return ValidateDrawElementsCommon(context, entryPoint, mode, count, type, indices, 1);
}

ANGLE_INLINE bool ValidateVertexAttribPointer(const Context *context,
                                              angle::EntryPoint entryPoint,
                                              GLuint index,
                                              GLint size,
                                              VertexAttribType type,
                                              GLboolean normalized,
                                              GLsizei stride,
                                              const void *ptr)
{
    if (!ValidateFloatVertexFormat(context->getPrivateState(), context->getPrivateStateCache(),
                                   context->getMutableErrorSetForValidation(), entryPoint, index,
                                   size, type))
    {
        return false;
    }

    if (stride < 0)
    {
        ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, err::kNegativeStride);
        return false;
    }

    if (context->getClientVersion() >= ES_3_1)
    {
        const Caps &caps = context->getCaps();
        if (stride > caps.maxVertexAttribStride)
        {
            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, err::kExceedsMaxVertexAttribStride);
            return false;
        }

        if (index >= static_cast<GLuint>(caps.maxVertexAttribBindings))
        {
            ANGLE_VALIDATION_ERROR(GL_INVALID_VALUE, err::kExceedsMaxVertexAttribBindings);
            return false;
        }
    }

    // [OpenGL ES 3.0.2] Section 2.8 page 24:
    // An INVALID_OPERATION error is generated when a non-zero vertex array object
    // is bound, zero is bound to the ARRAY_BUFFER buffer object binding point,
    // and the pointer argument is not NULL.
    bool nullBufferAllowed = context->getState().areClientArraysEnabled() &&
                             context->getState().getVertexArray()->id().value == 0;
    if (!nullBufferAllowed && context->getState().getTargetBuffer(BufferBinding::Array) == 0 &&
        ptr != nullptr)
    {
        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, err::kClientDataInVertexArray);
        return false;
    }

    if (context->isWebGL())
    {
        // WebGL 1.0 [Section 6.14] Fixed point support
        // The WebGL API does not support the GL_FIXED data type.
        if (type == VertexAttribType::Fixed)
        {
            ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, err::kFixedNotInWebGL);
            return false;
        }

        if (!ValidateWebGLVertexAttribPointer(context, entryPoint, type, normalized, stride, ptr,
                                              false))
        {
            return false;
        }
    }

    return true;
}

void RecordBindTextureTypeError(const Context *context,
                                angle::EntryPoint entryPoint,
                                TextureType target);

ANGLE_INLINE bool ValidateBindTexture(const Context *context,
                                      angle::EntryPoint entryPoint,
                                      TextureType target,
                                      TextureID texture)
{
    if (!context->getStateCache().isValidBindTextureType(target))
    {
        RecordBindTextureTypeError(context, entryPoint, target);
        return false;
    }

    if (texture.value == 0)
    {
        return true;
    }

    Texture *textureObject = context->getTexture(texture);
    if (textureObject && textureObject->getType() != target)
    {
        ANGLE_VALIDATION_ERRORF(GL_INVALID_OPERATION, err::kTextureTargetMismatchWithLabel,
                                static_cast<uint8_t>(target),
                                static_cast<uint8_t>(textureObject->getType()),
                                textureObject->getLabel().c_str());
        return false;
    }

    if (!context->getState().isBindGeneratesResourceEnabled() &&
        !context->isTextureGenerated(texture))
    {
        ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, err::kObjectNotGenerated);
        return false;
    }

    return true;
}

// Validation of [Push,Pop]DebugGroup
bool ValidatePushDebugGroupBase(const Context *context,
                                angle::EntryPoint entryPoint,
                                GLenum source,
                                GLuint id,
                                GLsizei length,
                                const GLchar *message);
bool ValidatePopDebugGroupBase(const Context *context, angle::EntryPoint entryPoint);

bool ValidateDebugMessageControlBase(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     GLenum source,
                                     GLenum type,
                                     GLenum severity,
                                     GLsizei count,
                                     const GLuint *ids);

bool ValidateDebugMessageInsertBase(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    GLenum source,
                                    GLenum type,
                                    GLuint id,
                                    GLenum severity,
                                    GLsizei length,
                                    const GLchar *buf);

bool ValidateGetDebugMessageLogBase(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    GLuint count,
                                    GLsizei bufSize,
                                    const GLenum *sources,
                                    const GLenum *types,
                                    const GLuint *ids,
                                    const GLenum *severities,
                                    const GLsizei *lengths,
                                    const GLchar *messageLog);

// Validation of ObjectLabel
bool ValidateObjectLabelBase(const Context *context,
                             angle::EntryPoint entryPoint,
                             GLenum identifier,
                             GLuint name,
                             GLsizei length,
                             const GLchar *label);

// Validation of GetObjectLabel
bool ValidateGetObjectLabelBase(const Context *context,
                                angle::EntryPoint entryPoint,
                                GLenum identifier,
                                GLuint name,
                                GLsizei bufSize,
                                const GLsizei *length,
                                const GLchar *label);

// Validation of ObjectPtrLabel
bool ValidateObjectPtrLabelBase(const Context *context,
                                angle::EntryPoint entryPoint,
                                const void *ptr,
                                GLsizei length,
                                const GLchar *label);

// Validation of GetObjectPtrLabel
bool ValidateGetObjectPtrLabelBase(const Context *context,
                                   angle::EntryPoint entryPoint,
                                   const void *ptr,
                                   GLsizei bufSize,
                                   const GLsizei *length,
                                   const GLchar *label);

}  // namespace gl

#endif  // LIBANGLE_VALIDATION_ES2_H_