//
// Copyright 2023 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.
//
// PolygonModeTest.cpp: Test cases for GL_NV_polygon_mode and GL_ANGLE_polygon_mode
//

#include "test_utils/ANGLETest.h"
#include "test_utils/gl_raii.h"

using namespace angle;

class PolygonModeTest : public ANGLETest<>
{
  protected:
    PolygonModeTest()
    {
        setConfigRedBits(8);
        setConfigGreenBits(8);
        setConfigBlueBits(8);
        setConfigAlphaBits(8);
        setConfigDepthBits(24);
        setExtensionsEnabled(false);
        setWindowWidth(16);
        setWindowHeight(16);
    }
};

// New state queries and commands fail without the extension
TEST_P(PolygonModeTest, NoExtension)
{
    {
        GLint mode = 0;
        glGetIntegerv(GL_POLYGON_MODE_NV, &mode);
        EXPECT_GL_ERROR(GL_INVALID_ENUM);
        EXPECT_EQ(mode, 0);

        glPolygonModeNV(GL_FRONT_AND_BACK, GL_FILL_NV);
        EXPECT_GL_ERROR(GL_INVALID_OPERATION);

        glPolygonModeANGLE(GL_FRONT_AND_BACK, GL_FILL_NV);
        EXPECT_GL_ERROR(GL_INVALID_OPERATION);
    }
    for (GLenum state : {GL_POLYGON_OFFSET_POINT_NV, GL_POLYGON_OFFSET_LINE_NV})
    {
        EXPECT_FALSE(glIsEnabled(state));
        EXPECT_GL_ERROR(GL_INVALID_ENUM);

        GLboolean enabled = true;
        glGetBooleanv(state, &enabled);
        EXPECT_GL_ERROR(GL_INVALID_ENUM);
        EXPECT_TRUE(enabled);

        glEnable(state);
        EXPECT_GL_ERROR(GL_INVALID_ENUM);

        glDisable(state);
        EXPECT_GL_ERROR(GL_INVALID_ENUM);
    }
}

// Test NV_polygon_mode entrypoints
TEST_P(PolygonModeTest, ExtensionStateNV)
{
    ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_NV_polygon_mode"));

    // Default state
    {
        GLint mode = 0;
        glGetIntegerv(GL_POLYGON_MODE_NV, &mode);
        EXPECT_GLENUM_EQ(GL_FILL_NV, mode);
        EXPECT_GL_NO_ERROR();
    }
    for (GLenum state : {GL_POLYGON_OFFSET_POINT_NV, GL_POLYGON_OFFSET_LINE_NV})
    {
        EXPECT_FALSE(glIsEnabled(state));
        EXPECT_GL_NO_ERROR();

        GLboolean enabled = true;
        glGetBooleanv(state, &enabled);
        EXPECT_FALSE(enabled);
        EXPECT_GL_NO_ERROR();
    }

    // Polygon mode state updates
    for (GLenum mode : {GL_POINT_NV, GL_LINE_NV, GL_FILL_NV})
    {
        glPolygonModeNV(GL_FRONT_AND_BACK, mode);
        EXPECT_GL_NO_ERROR();

        GLint result = 0;
        glGetIntegerv(GL_POLYGON_MODE_NV, &result);
        EXPECT_GLENUM_EQ(mode, result);
        EXPECT_GL_NO_ERROR();
    }

    // Polygon offset state updates
    for (GLenum state : {GL_POLYGON_OFFSET_POINT_NV, GL_POLYGON_OFFSET_LINE_NV})
    {
        GLboolean enabled = false;

        glEnable(state);
        EXPECT_GL_NO_ERROR();

        EXPECT_TRUE(glIsEnabled(state));
        EXPECT_GL_NO_ERROR();

        glGetBooleanv(state, &enabled);
        EXPECT_GL_NO_ERROR();
        EXPECT_TRUE(enabled);

        glDisable(state);
        EXPECT_GL_NO_ERROR();

        EXPECT_FALSE(glIsEnabled(state));
        EXPECT_GL_NO_ERROR();

        glGetBooleanv(state, &enabled);
        EXPECT_GL_NO_ERROR();
        EXPECT_FALSE(enabled);
    }

    // Errors
    {
        glPolygonModeNV(GL_FRONT, GL_FILL_NV);
        EXPECT_GL_ERROR(GL_INVALID_ENUM);

        glPolygonModeNV(GL_BACK, GL_FILL_NV);
        EXPECT_GL_ERROR(GL_INVALID_ENUM);

        glPolygonModeNV(GL_FRONT_AND_BACK, 0);
        EXPECT_GL_ERROR(GL_INVALID_ENUM);
    }
}

// Test ANGLE_polygon_mode entrypoints
TEST_P(PolygonModeTest, ExtensionStateANGLE)
{
    ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_ANGLE_polygon_mode"));

    // Default state
    {
        GLint mode = 0;
        glGetIntegerv(GL_POLYGON_MODE_ANGLE, &mode);
        EXPECT_GLENUM_EQ(GL_FILL_ANGLE, mode);
        EXPECT_GL_NO_ERROR();
    }
    for (GLenum state : {GL_POLYGON_OFFSET_LINE_ANGLE})
    {
        EXPECT_FALSE(glIsEnabled(state));
        EXPECT_GL_NO_ERROR();

        GLboolean enabled = true;
        glGetBooleanv(state, &enabled);
        EXPECT_FALSE(enabled);
        EXPECT_GL_NO_ERROR();
    }

    // Polygon mode state updates
    for (GLenum mode : {GL_LINE_ANGLE, GL_FILL_ANGLE})
    {
        glPolygonModeANGLE(GL_FRONT_AND_BACK, mode);
        EXPECT_GL_NO_ERROR();

        GLint result = 0;
        glGetIntegerv(GL_POLYGON_MODE_ANGLE, &result);
        EXPECT_GLENUM_EQ(mode, result);
        EXPECT_GL_NO_ERROR();
    }

    // Polygon offset state updates
    for (GLenum state : {GL_POLYGON_OFFSET_LINE_ANGLE})
    {
        GLboolean enabled = false;

        glEnable(state);
        EXPECT_GL_NO_ERROR();

        EXPECT_TRUE(glIsEnabled(state));
        EXPECT_GL_NO_ERROR();

        glGetBooleanv(state, &enabled);
        EXPECT_GL_NO_ERROR();
        EXPECT_TRUE(enabled);

        glDisable(state);
        EXPECT_GL_NO_ERROR();

        EXPECT_FALSE(glIsEnabled(state));
        EXPECT_GL_NO_ERROR();

        glGetBooleanv(state, &enabled);
        EXPECT_GL_NO_ERROR();
        EXPECT_FALSE(enabled);
    }

    // Errors
    {
        glPolygonModeANGLE(GL_FRONT, GL_FILL_ANGLE);
        EXPECT_GL_ERROR(GL_INVALID_ENUM);

        glPolygonModeANGLE(GL_BACK, GL_FILL_ANGLE);
        EXPECT_GL_ERROR(GL_INVALID_ENUM);

        glPolygonModeANGLE(GL_FRONT_AND_BACK, 0);
        EXPECT_GL_ERROR(GL_INVALID_ENUM);

        glPolygonModeANGLE(GL_FRONT_AND_BACK, GL_POINT_NV);
        EXPECT_GL_ERROR(GL_INVALID_ENUM);

        glIsEnabled(GL_POLYGON_OFFSET_POINT_NV);
        EXPECT_GL_ERROR(GL_INVALID_ENUM);

        GLboolean enabled = true;
        glGetBooleanv(GL_POLYGON_OFFSET_POINT_NV, &enabled);
        EXPECT_GL_ERROR(GL_INVALID_ENUM);
    }
}

// Test that if both extensions are enabled, the ANGLE command allows GL_POINT_NV.
TEST_P(PolygonModeTest, ExtensionInteraction)
{
    ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_ANGLE_polygon_mode"));
    ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_NV_polygon_mode"));

    glPolygonModeANGLE(GL_FRONT_AND_BACK, GL_POINT_NV);
    EXPECT_GL_NO_ERROR();

    GLint result = 0;
    glGetIntegerv(GL_POLYGON_MODE_NV, &result);
    EXPECT_GLENUM_EQ(GL_POINT_NV, result);
    EXPECT_GL_NO_ERROR();
}

// Test line rasterization mode
TEST_P(PolygonModeTest, DrawLines)
{
    const bool extensionNV    = EnsureGLExtensionEnabled("GL_NV_polygon_mode");
    const bool extensionANGLE = EnsureGLExtensionEnabled("GL_ANGLE_polygon_mode");
    ANGLE_SKIP_TEST_IF(!extensionNV && !extensionANGLE);

    ANGLE_GL_PROGRAM(program, essl1_shaders::vs::Simple(), essl1_shaders::fs::UniformColor());
    glUseProgram(program);
    GLint colorLocation = glGetUniformLocation(program, essl1_shaders::ColorUniform());

    const int w = getWindowWidth();
    const int h = getWindowHeight();
    ASSERT(w == h);

    for (bool useNV : {true, false})
    {
        if (useNV && !extensionNV)
        {
            continue;
        }

        glClearColor(1, 0, 0, 1);
        glClear(GL_COLOR_BUFFER_BIT);
        EXPECT_PIXEL_RECT_EQ(0, 0, w, h, GLColor::red);

        // Draw green quad with lines
        if (useNV)
        {
            glPolygonModeNV(GL_FRONT_AND_BACK, GL_LINE_NV);
        }
        else
        {
            glPolygonModeANGLE(GL_FRONT_AND_BACK, GL_LINE_ANGLE);
        }
        glUniform4f(colorLocation, 0.0, 1.0, 0.0, 1.0);
        drawQuad(program, essl1_shaders::PositionAttrib(), 0.0);

        // Nothing was drawn inside triangles
        EXPECT_PIXEL_RECT_EQ(1, 1, 5, 5, GLColor::red);
        EXPECT_PIXEL_RECT_EQ(9, 9, 5, 5, GLColor::red);

        // Main diagonal was drawn
        std::vector<GLColor> colors(w * h);
        glReadPixels(0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, colors.data());
        for (int i = 0; i < w; i++)
        {
            const int x = i;
            const int y = w - 1 - i;
            EXPECT_EQ(GLColor::green, colors[y * w + x]) << "x: " << x << " y: " << y;
        }

        // Draw blue quad with triangles
        if (useNV)
        {
            glPolygonModeNV(GL_FRONT_AND_BACK, GL_FILL_NV);
        }
        else
        {
            glPolygonModeANGLE(GL_FRONT_AND_BACK, GL_FILL_ANGLE);
        }
        glUniform4f(colorLocation, 0.0, 0.0, 1.0, 1.0);
        drawQuad(program, essl1_shaders::PositionAttrib(), 0.0);
        EXPECT_PIXEL_RECT_EQ(0, 0, w, h, GLColor::blue);
    }
}

// Test line rasterization mode with depth offset
TEST_P(PolygonModeTest, DrawLinesWithDepthOffset)
{
    const bool extensionNV    = EnsureGLExtensionEnabled("GL_NV_polygon_mode");
    const bool extensionANGLE = EnsureGLExtensionEnabled("GL_ANGLE_polygon_mode");
    ANGLE_SKIP_TEST_IF(!extensionNV && !extensionANGLE);

    ANGLE_GL_PROGRAM(program, essl1_shaders::vs::Simple(), essl1_shaders::fs::UniformColor());
    glUseProgram(program);
    GLint colorLocation = glGetUniformLocation(program, essl1_shaders::ColorUniform());

    const int w = getWindowWidth();
    const int h = getWindowHeight();
    ASSERT(w == h);

    glEnable(GL_DEPTH_TEST);

    for (bool useNV : {true, false})
    {
        if (useNV && !extensionNV)
        {
            continue;
        }

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        // Draw red quad filled
        if (useNV)
        {
            glPolygonModeNV(GL_FRONT_AND_BACK, GL_FILL_NV);
        }
        else
        {
            glPolygonModeANGLE(GL_FRONT_AND_BACK, GL_FILL_ANGLE);
        }
        glUniform4f(colorLocation, 1.0, 0.0, 0.0, 1.0);
        drawQuad(program, essl1_shaders::PositionAttrib(), 0.5);

        // Draw green quad using lines with offset failing the depth test
        if (useNV)
        {
            glEnable(GL_POLYGON_OFFSET_LINE_NV);
            glPolygonModeNV(GL_FRONT_AND_BACK, GL_LINE_NV);
        }
        else
        {
            glEnable(GL_POLYGON_OFFSET_LINE_ANGLE);
            glPolygonModeANGLE(GL_FRONT_AND_BACK, GL_LINE_ANGLE);
        }
        glPolygonOffset(0.0, 2.0);
        glUniform4f(colorLocation, 0.0, 1.0, 0.0, 1.0);
        drawQuad(program, essl1_shaders::PositionAttrib(), 0.5);

        // Depth test must fail
        EXPECT_PIXEL_RECT_EQ(0, 0, w, h, GLColor::red);

        // Draw green quad with triangles
        if (useNV)
        {
            glPolygonModeNV(GL_FRONT_AND_BACK, GL_FILL_NV);
        }
        else
        {
            glPolygonModeANGLE(GL_FRONT_AND_BACK, GL_FILL_ANGLE);
        }
        drawQuad(program, essl1_shaders::PositionAttrib(), 0.0);

        // Change the offset so that depth test passes
        glPolygonOffset(0.0, -2.0);

        // Draw blue quad with lines
        if (useNV)
        {
            glPolygonModeNV(GL_FRONT_AND_BACK, GL_LINE_NV);
        }
        else
        {
            glPolygonModeANGLE(GL_FRONT_AND_BACK, GL_LINE_ANGLE);
        }
        glUniform4f(colorLocation, 0.0, 0.0, 1.0, 1.0);
        drawQuad(program, essl1_shaders::PositionAttrib(), 0.0);

        // Main diagonal was drawn
        std::vector<GLColor> colors(w * h);
        glReadPixels(0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, colors.data());
        for (int i = 0; i < w; i++)
        {
            const int x = i;
            const int y = w - 1 - i;
            EXPECT_EQ(GLColor::blue, colors[y * w + x]) << "x: " << x << " y: " << y;
        }
    }
}

ANGLE_INSTANTIATE_TEST_ES2_AND_ES3(PolygonModeTest);