/*-------------------------------------------------------------------------
 * 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 Stencil tests.
 *//*--------------------------------------------------------------------*/

#include "es3fStencilTests.hpp"

#include "tcuSurface.hpp"
#include "tcuVector.hpp"
#include "tcuTestLog.hpp"
#include "tcuImageCompare.hpp"
#include "tcuRenderTarget.hpp"

#include "sglrContextUtil.hpp"
#include "sglrGLContext.hpp"
#include "sglrReferenceContext.hpp"

#include "deRandom.hpp"
#include "deMath.h"
#include "deString.h"

#include <vector>

#include "glwEnums.hpp"
#include "glwDefs.hpp"

using std::vector;
using tcu::IVec2;
using tcu::IVec4;
using tcu::Vec3;
using namespace glw;

namespace deqp
{
namespace gles3
{
namespace Functional
{

class StencilShader : public sglr::ShaderProgram
{
public:
    StencilShader(void)
        : sglr::ShaderProgram(sglr::pdec::ShaderProgramDeclaration()
                              << sglr::pdec::VertexAttribute("a_position", rr::GENERICVECTYPE_FLOAT)
                              << sglr::pdec::VertexToFragmentVarying(rr::GENERICVECTYPE_FLOAT)
                              << sglr::pdec::FragmentOutput(rr::GENERICVECTYPE_FLOAT)
                              << sglr::pdec::Uniform("u_color", glu::TYPE_FLOAT_VEC4)
                              << sglr::pdec::VertexSource("#version 300 es\n"
                                                          "in highp vec4 a_position;\n"
                                                          "void main (void)\n"
                                                          "{\n"
                                                          "    gl_Position = a_position;\n"
                                                          "}\n")
                              << sglr::pdec::FragmentSource("#version 300 es\n"
                                                            "uniform highp vec4 u_color;\n"
                                                            "layout(location = 0) out mediump vec4 o_color;\n"
                                                            "void main (void)\n"
                                                            "{\n"
                                                            "    o_color = u_color;\n"
                                                            "}\n"))
        , u_color(getUniformByName("u_color"))
    {
    }

    void setColor(sglr::Context &ctx, uint32_t program, const tcu::Vec4 &color)
    {
        ctx.useProgram(program);
        ctx.uniform4fv(ctx.getUniformLocation(program, "u_color"), 1, color.getPtr());
    }

private:
    void shadeVertices(const rr::VertexAttrib *inputs, rr::VertexPacket *const *packets, const int numPackets) const
    {
        for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
        {
            rr::VertexPacket &packet = *packets[packetNdx];

            packet.position = rr::readVertexAttribFloat(inputs[0], packet.instanceNdx, packet.vertexNdx);
        }
    }

    void shadeFragments(rr::FragmentPacket *packets, const int numPackets,
                        const rr::FragmentShadingContext &context) const
    {
        const tcu::Vec4 color(u_color.value.f4);

        DE_UNREF(packets);

        for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
            for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
                rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, color);
    }

    const sglr::UniformSlot &u_color;
};

class StencilOp
{
public:
    enum Type
    {
        TYPE_CLEAR_STENCIL = 0,
        TYPE_CLEAR_DEPTH,
        TYPE_QUAD,

        TYPE_LAST
    };

    Type type;
    GLenum stencilTest;
    int stencil; //!< Ref for quad op, clear value for clears
    uint32_t stencilMask;
    GLenum depthTest;
    float depth; //!< Quad depth or clear value
    GLenum sFail;
    GLenum dFail;
    GLenum dPass;

    StencilOp(Type type_, GLenum stencilTest_ = GL_ALWAYS, int stencil_ = 0, GLenum depthTest_ = GL_ALWAYS,
              float depth_ = 1.0f, GLenum sFail_ = GL_KEEP, GLenum dFail_ = GL_KEEP, GLenum dPass_ = GL_KEEP)
        : type(type_)
        , stencilTest(stencilTest_)
        , stencil(stencil_)
        , stencilMask(0xffffffffu)
        , depthTest(depthTest_)
        , depth(depth_)
        , sFail(sFail_)
        , dFail(dFail_)
        , dPass(dPass_)
    {
    }

    static StencilOp clearStencil(int stencil)
    {
        StencilOp op(TYPE_CLEAR_STENCIL);
        op.stencil = stencil;
        return op;
    }

    static StencilOp clearDepth(float depth)
    {
        StencilOp op(TYPE_CLEAR_DEPTH);
        op.depth = depth;
        return op;
    }

    static StencilOp quad(GLenum stencilTest, int stencil, GLenum depthTest, float depth, GLenum sFail, GLenum dFail,
                          GLenum dPass)
    {
        return StencilOp(TYPE_QUAD, stencilTest, stencil, depthTest, depth, sFail, dFail, dPass);
    }
};

class StencilCase : public TestCase
{
public:
    StencilCase(Context &context, const char *name, const char *description);
    virtual ~StencilCase(void);

    void init(void);
    void deinit(void);
    IterateResult iterate(void);

    virtual void genOps(vector<StencilOp> &dst, int stencilBits, int depthBits, int targetStencil) = DE_NULL;

private:
    void executeOps(sglr::Context &context, const IVec4 &cell, const vector<StencilOp> &ops);
    void visualizeStencil(sglr::Context &context, int stencilBits, int stencilStep);

    StencilShader m_shader;
    uint32_t m_shaderID;
};

StencilCase::StencilCase(Context &context, const char *name, const char *description)
    : TestCase(context, name, description)
    , m_shaderID(0)
{
}

StencilCase::~StencilCase(void)
{
}

void StencilCase::init(void)
{
}

void StencilCase::deinit(void)
{
}

void StencilCase::executeOps(sglr::Context &context, const IVec4 &cell, const vector<StencilOp> &ops)
{
    // For quadOps
    float x0 = 2.0f * ((float)cell.x() / (float)context.getWidth()) - 1.0f;
    float y0 = 2.0f * ((float)cell.y() / (float)context.getHeight()) - 1.0f;
    float x1 = x0 + 2.0f * ((float)cell.z() / (float)context.getWidth());
    float y1 = y0 + 2.0f * ((float)cell.w() / (float)context.getHeight());

    m_shader.setColor(context, m_shaderID, tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f));

    for (vector<StencilOp>::const_iterator i = ops.begin(); i != ops.end(); i++)
    {
        const StencilOp &op = *i;

        switch (op.type)
        {
        case StencilOp::TYPE_CLEAR_DEPTH:
            context.enable(GL_SCISSOR_TEST);
            context.scissor(cell.x(), cell.y(), cell.z(), cell.w());
            context.clearDepthf(op.depth);
            context.clear(GL_DEPTH_BUFFER_BIT);
            context.disable(GL_SCISSOR_TEST);
            break;

        case StencilOp::TYPE_CLEAR_STENCIL:
            context.enable(GL_SCISSOR_TEST);
            context.scissor(cell.x(), cell.y(), cell.z(), cell.w());
            context.clearStencil(op.stencil);
            context.clear(GL_STENCIL_BUFFER_BIT);
            context.disable(GL_SCISSOR_TEST);
            break;

        case StencilOp::TYPE_QUAD:
            context.enable(GL_DEPTH_TEST);
            context.enable(GL_STENCIL_TEST);
            context.depthFunc(op.depthTest);
            context.stencilFunc(op.stencilTest, op.stencil, op.stencilMask);
            context.stencilOp(op.sFail, op.dFail, op.dPass);
            sglr::drawQuad(context, m_shaderID, Vec3(x0, y0, op.depth), Vec3(x1, y1, op.depth));
            context.disable(GL_STENCIL_TEST);
            context.disable(GL_DEPTH_TEST);
            break;

        default:
            DE_ASSERT(false);
        }
    }
}

void StencilCase::visualizeStencil(sglr::Context &context, int stencilBits, int stencilStep)
{
    int endVal           = 1 << stencilBits;
    int numStencilValues = endVal / stencilStep + 1;

    context.enable(GL_STENCIL_TEST);
    context.stencilOp(GL_KEEP, GL_KEEP, GL_KEEP);

    for (int ndx = 0; ndx < numStencilValues; ndx++)
    {
        int value      = deMin32(ndx * stencilStep, endVal - 1);
        float colorMix = (float)value / (float)de::max(1, endVal - 1);
        tcu::Vec4 color(0.0f, 1.0f - colorMix, colorMix, 1.0f);

        m_shader.setColor(context, m_shaderID, color);
        context.stencilFunc(GL_EQUAL, value, 0xffffffffu);
        sglr::drawQuad(context, m_shaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(+1.0f, +1.0f, 0.0f));
    }
}

TestCase::IterateResult StencilCase::iterate(void)
{
    const tcu::RenderTarget &renderTarget = m_context.getRenderContext().getRenderTarget();
    int depthBits                         = renderTarget.getDepthBits();
    int stencilBits                       = renderTarget.getStencilBits();

    int stencilStep      = stencilBits == 8 ? 8 : 1;
    int numStencilValues = (1 << stencilBits) / stencilStep + 1;

    int gridSize = (int)deFloatCeil(deFloatSqrt((float)(numStencilValues + 2)));

    int width  = deMin32(128, renderTarget.getWidth());
    int height = deMin32(128, renderTarget.getHeight());

    tcu::TestLog &log = m_testCtx.getLog();
    de::Random rnd(deStringHash(m_name.c_str()));
    int viewportX  = rnd.getInt(0, renderTarget.getWidth() - width);
    int viewportY  = rnd.getInt(0, renderTarget.getHeight() - height);
    IVec4 viewport = IVec4(viewportX, viewportY, width, height);

    tcu::Surface gles2Frame(width, height);
    tcu::Surface refFrame(width, height);
    GLenum gles2Error;

    const char *failReason = DE_NULL;

    // Get ops for stencil values
    vector<vector<StencilOp>> ops(numStencilValues + 2);
    {
        // Values from 0 to max
        for (int ndx = 0; ndx < numStencilValues; ndx++)
            genOps(ops[ndx], stencilBits, depthBits, deMin32(ndx * stencilStep, (1 << stencilBits) - 1));

        // -1 and max+1
        genOps(ops[numStencilValues + 0], stencilBits, depthBits, 1 << stencilBits);
        genOps(ops[numStencilValues + 1], stencilBits, depthBits, -1);
    }

    // Compute cells: (x, y, w, h)
    vector<IVec4> cells;
    int cellWidth  = width / gridSize;
    int cellHeight = height / gridSize;
    for (int y = 0; y < gridSize; y++)
        for (int x = 0; x < gridSize; x++)
            cells.push_back(IVec4(x * cellWidth, y * cellHeight, cellWidth, cellHeight));

    DE_ASSERT(ops.size() <= cells.size());

    // Execute for gles3 context
    {
        sglr::GLContext context(m_context.getRenderContext(), log, 0 /* don't log calls or program */, viewport);

        m_shaderID = context.createProgram(&m_shader);

        context.clearColor(1.0f, 0.0f, 0.0f, 1.0f);
        context.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

        for (int ndx = 0; ndx < (int)ops.size(); ndx++)
            executeOps(context, cells[ndx], ops[ndx]);

        visualizeStencil(context, stencilBits, stencilStep);

        gles2Error = context.getError();
        context.readPixels(gles2Frame, 0, 0, width, height);
    }

    // Execute for reference context
    {
        sglr::ReferenceContextBuffers buffers(
            tcu::PixelFormat(8, 8, 8, renderTarget.getPixelFormat().alphaBits ? 8 : 0), renderTarget.getDepthBits(),
            renderTarget.getStencilBits(), width, height);
        sglr::ReferenceContext context(sglr::ReferenceContextLimits(m_context.getRenderContext()),
                                       buffers.getColorbuffer(), buffers.getDepthbuffer(), buffers.getStencilbuffer());

        m_shaderID = context.createProgram(&m_shader);

        context.clearColor(1.0f, 0.0f, 0.0f, 1.0f);
        context.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

        for (int ndx = 0; ndx < (int)ops.size(); ndx++)
            executeOps(context, cells[ndx], ops[ndx]);

        visualizeStencil(context, stencilBits, stencilStep);

        context.readPixels(refFrame, 0, 0, width, height);
    }

    // Check error
    bool errorCodeOk = (gles2Error == GL_NO_ERROR);
    if (!errorCodeOk && !failReason)
        failReason = "Got unexpected error";

    // Compare images
    const float threshold = 0.02f;
    bool imagesOk         = tcu::fuzzyCompare(log, "ComparisonResult", "Image comparison result", refFrame, gles2Frame,
                                              threshold, tcu::COMPARE_LOG_RESULT);

    if (!imagesOk && !failReason)
        failReason = "Image comparison failed";

    // Store test result
    bool isOk = errorCodeOk && imagesOk;
    m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, isOk ? "Pass" : failReason);

    return STOP;
}

StencilTests::StencilTests(Context &context) : TestCaseGroup(context, "stencil", "Stencil Tests")
{
}

StencilTests::~StencilTests(void)
{
}

typedef void (*GenStencilOpsFunc)(vector<StencilOp> &dst, int stencilBits, int depthBits, int targetStencil);

class SimpleStencilCase : public StencilCase
{
public:
    SimpleStencilCase(Context &context, const char *name, const char *description, GenStencilOpsFunc genOpsFunc)
        : StencilCase(context, name, description)
        , m_genOps(genOpsFunc)
    {
    }

    void genOps(vector<StencilOp> &dst, int stencilBits, int depthBits, int targetStencil)
    {
        m_genOps(dst, stencilBits, depthBits, targetStencil);
    }

private:
    GenStencilOpsFunc m_genOps;
};

void StencilTests::init(void)
{
#define STENCIL_CASE(NAME, DESCRIPTION, GEN_OPS_BODY)                                                     \
    do                                                                                                    \
    {                                                                                                     \
        struct Gen_##NAME                                                                                 \
        {                                                                                                 \
            static void genOps(vector<StencilOp> &dst, int stencilBits, int depthBits, int targetStencil) \
            {                                                                                             \
                DE_UNREF(stencilBits &&depthBits);                                                        \
                GEN_OPS_BODY                                                                              \
            }                                                                                             \
        };                                                                                                \
        addChild(new SimpleStencilCase(m_context, #NAME, DESCRIPTION, Gen_##NAME::genOps));               \
    } while (false);

    STENCIL_CASE(clear, "Stencil clear", {
        // \note Unused bits are set to 1, clear should mask them out
        int mask = (1 << stencilBits) - 1;
        dst.push_back(StencilOp::clearStencil(targetStencil | ~mask));
    })

    // Replace in different points
    STENCIL_CASE(stencil_fail_replace, "Set stencil on stencil fail", {
        dst.push_back(StencilOp::quad(GL_NEVER, targetStencil, GL_ALWAYS, 0.0f, GL_REPLACE, GL_KEEP, GL_KEEP));
    })
    STENCIL_CASE(depth_fail_replace, "Set stencil on depth fail", {
        dst.push_back(StencilOp::clearDepth(0.0f));
        dst.push_back(StencilOp::quad(GL_ALWAYS, targetStencil, GL_LESS, 0.5f, GL_KEEP, GL_REPLACE, GL_KEEP));
    })
    STENCIL_CASE(depth_pass_replace, "Set stencil on depth pass", {
        dst.push_back(StencilOp::quad(GL_ALWAYS, targetStencil, GL_LESS, 0.0f, GL_KEEP, GL_KEEP, GL_REPLACE));
    })

    // Increment, decrement
    STENCIL_CASE(incr_stencil_fail, "Increment on stencil fail", {
        if (targetStencil > 0)
        {
            dst.push_back(StencilOp::clearStencil(targetStencil - 1));
            dst.push_back(StencilOp::quad(GL_EQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_INCR, GL_KEEP, GL_KEEP));
        }
        else
            dst.push_back(StencilOp::clearStencil(targetStencil));
    })
    STENCIL_CASE(decr_stencil_fail, "Decrement on stencil fail", {
        int maxStencil = (1 << stencilBits) - 1;
        if (targetStencil < maxStencil)
        {
            dst.push_back(StencilOp::clearStencil(targetStencil + 1));
            dst.push_back(StencilOp::quad(GL_EQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_DECR, GL_KEEP, GL_KEEP));
        }
        else
            dst.push_back(StencilOp::clearStencil(targetStencil));
    })
    STENCIL_CASE(incr_wrap_stencil_fail, "Increment (wrap) on stencil fail", {
        int maxStencil = (1 << stencilBits) - 1;
        dst.push_back(StencilOp::clearStencil((targetStencil - 1) & maxStencil));
        dst.push_back(StencilOp::quad(GL_EQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_INCR_WRAP, GL_KEEP, GL_KEEP));
    })
    STENCIL_CASE(decr_wrap_stencil_fail, "Decrement (wrap) on stencil fail", {
        int maxStencil = (1 << stencilBits) - 1;
        dst.push_back(StencilOp::clearStencil((targetStencil + 1) & maxStencil));
        dst.push_back(StencilOp::quad(GL_EQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_DECR_WRAP, GL_KEEP, GL_KEEP));
    })

    // Zero, Invert
    STENCIL_CASE(zero_stencil_fail, "Zero on stencil fail", {
        dst.push_back(StencilOp::clearStencil(targetStencil));
        dst.push_back(StencilOp::quad(GL_NOTEQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_ZERO, GL_KEEP, GL_KEEP));
        dst.push_back(StencilOp::quad(GL_EQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_REPLACE, GL_KEEP, GL_KEEP));
    })
    STENCIL_CASE(invert_stencil_fail, "Invert on stencil fail", {
        int mask = (1 << stencilBits) - 1;
        dst.push_back(StencilOp::clearStencil((~targetStencil) & mask));
        dst.push_back(StencilOp::quad(GL_EQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_INVERT, GL_KEEP, GL_KEEP));
    })

    // Comparison modes
    STENCIL_CASE(cmp_equal, "Equality comparison", {
        int mask = (1 << stencilBits) - 1;
        int inv  = (~targetStencil) & mask;
        dst.push_back(StencilOp::clearStencil(inv));
        dst.push_back(StencilOp::quad(GL_EQUAL, inv, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INVERT));
        dst.push_back(StencilOp::quad(GL_EQUAL, inv, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INVERT));
    })
    STENCIL_CASE(cmp_not_equal, "Equality comparison", {
        int mask = (1 << stencilBits) - 1;
        int inv  = (~targetStencil) & mask;
        dst.push_back(StencilOp::clearStencil(inv));
        dst.push_back(StencilOp::quad(GL_NOTEQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INVERT));
        dst.push_back(StencilOp::quad(GL_NOTEQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INVERT));
    })
    STENCIL_CASE(cmp_less_than, "Less than comparison", {
        int maxStencil = (1 << stencilBits) - 1;
        if (targetStencil < maxStencil)
        {
            dst.push_back(StencilOp::clearStencil(targetStencil + 1));
            dst.push_back(StencilOp::quad(GL_LESS, targetStencil, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_DECR));
            dst.push_back(StencilOp::quad(GL_LESS, targetStencil, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_DECR));
        }
        else
            dst.push_back(StencilOp::clearStencil(targetStencil));
    })
    STENCIL_CASE(cmp_less_or_equal, "Less or equal comparison", {
        int maxStencil = (1 << stencilBits) - 1;
        if (targetStencil < maxStencil)
        {
            dst.push_back(StencilOp::clearStencil(targetStencil + 1));
            dst.push_back(StencilOp::quad(GL_LEQUAL, targetStencil + 1, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_DECR));
            dst.push_back(StencilOp::quad(GL_LEQUAL, targetStencil + 1, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_DECR));
        }
        else
            dst.push_back(StencilOp::clearStencil(targetStencil));
    })
    STENCIL_CASE(cmp_greater_than, "Greater than comparison", {
        if (targetStencil > 0)
        {
            dst.push_back(StencilOp::clearStencil(targetStencil - 1));
            dst.push_back(StencilOp::quad(GL_GREATER, targetStencil, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INCR));
            dst.push_back(StencilOp::quad(GL_GREATER, targetStencil, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INCR));
        }
        else
            dst.push_back(StencilOp::clearStencil(targetStencil));
    })
    STENCIL_CASE(cmp_greater_or_equal, "Greater or equal comparison", {
        if (targetStencil > 0)
        {
            dst.push_back(StencilOp::clearStencil(targetStencil - 1));
            dst.push_back(StencilOp::quad(GL_GEQUAL, targetStencil - 1, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INCR));
            dst.push_back(StencilOp::quad(GL_GEQUAL, targetStencil - 1, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INCR));
        }
        else
            dst.push_back(StencilOp::clearStencil(targetStencil));
    })
    STENCIL_CASE(cmp_mask_equal, "Equality comparison with mask", {
        int valMask = (1 << stencilBits) - 1;
        int mask    = (1 << 7) | (1 << 5) | (1 << 3) | (1 << 1);
        dst.push_back(StencilOp::clearStencil(~targetStencil));
        StencilOp op =
            StencilOp::quad(GL_EQUAL, (~targetStencil | ~mask) & valMask, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INVERT);
        op.stencilMask = mask;
        dst.push_back(op);
    })
}

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