/*-------------------------------------------------------------------------
 * drawElements Quality Program Random Shader Generator
 * ----------------------------------------------------
 *
 * 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 Program Executor.
 *//*--------------------------------------------------------------------*/

#include "rsgProgramExecutor.hpp"
#include "rsgExecutionContext.hpp"
#include "rsgVariableValue.hpp"
#include "rsgUtils.hpp"
#include "tcuSurface.hpp"
#include "deMath.h"
#include "deString.h"

#include <set>
#include <string>
#include <map>

using std::map;
using std::set;
using std::string;
using std::vector;

namespace rsg
{

class VaryingStorage
{
public:
    VaryingStorage(const VariableType &type, int numVertices);
    ~VaryingStorage(void)
    {
    }

    ValueAccess getValue(const VariableType &type, int vtxNdx);
    ConstValueAccess getValue(const VariableType &type, int vtxNdx) const;

private:
    std::vector<Scalar> m_value;
};

VaryingStorage::VaryingStorage(const VariableType &type, int numVertices) : m_value(type.getScalarSize() * numVertices)
{
}

ValueAccess VaryingStorage::getValue(const VariableType &type, int vtxNdx)
{
    return ValueAccess(type, &m_value[type.getScalarSize() * vtxNdx]);
}

ConstValueAccess VaryingStorage::getValue(const VariableType &type, int vtxNdx) const
{
    return ConstValueAccess(type, &m_value[type.getScalarSize() * vtxNdx]);
}

class VaryingStore
{
public:
    VaryingStore(int numVertices);
    ~VaryingStore(void);

    VaryingStorage *getStorage(const VariableType &type, const char *name);

private:
    int m_numVertices;
    std::map<std::string, VaryingStorage *> m_values;
};

VaryingStore::VaryingStore(int numVertices) : m_numVertices(numVertices)
{
}

VaryingStore::~VaryingStore(void)
{
    for (map<string, VaryingStorage *>::iterator i = m_values.begin(); i != m_values.end(); i++)
        delete i->second;
    m_values.clear();
}

VaryingStorage *VaryingStore::getStorage(const VariableType &type, const char *name)
{
    VaryingStorage *storage = m_values[name];

    if (!storage)
    {
        storage        = new VaryingStorage(type, m_numVertices);
        m_values[name] = storage;
    }

    return storage;
}

inline float interpolateVertexQuad(const tcu::Vec4 &quad, float x, float y)
{
    float w00 = (1.0f - x) * (1.0f - y);
    float w01 = (1.0f - x) * y;
    float w10 = x * (1.0f - y);
    float w11 = x * y;
    return quad.x() * w00 + quad.y() * w10 + quad.z() * w01 + quad.w() * w11;
}

inline float interpolateVertex(float x0y0, float x1y1, float x, float y)
{
    return interpolateVertexQuad(tcu::Vec4(x0y0, (x0y0 + x1y1) * 0.5f, (x0y0 + x1y1) * 0.5f, x1y1), x, y);
}

inline float interpolateTri(float v0, float v1, float v2, float x, float y)
{
    return v0 + (v1 - v0) * x + (v2 - v0) * y;
}

inline float interpolateFragment(const tcu::Vec4 &quad, float x, float y)
{
    if (x + y < 1.0f)
        return interpolateTri(quad.x(), quad.y(), quad.z(), x, y);
    else
        return interpolateTri(quad.w(), quad.z(), quad.y(), 1.0f - x, 1.0f - y);
}

template <int Stride>
void interpolateVertexInput(StridedValueAccess<Stride> dst, int dstComp, const ConstValueRangeAccess valueRange,
                            float x, float y)
{
    TCU_CHECK(valueRange.getType().getBaseType() == VariableType::TYPE_FLOAT);
    int numElements = valueRange.getType().getNumElements();
    for (int elementNdx = 0; elementNdx < numElements; elementNdx++)
    {
        float xd, yd;
        getVertexInterpolationCoords(xd, yd, x, y, elementNdx);
        dst.component(elementNdx).asFloat(dstComp) =
            interpolateVertex(valueRange.getMin().component(elementNdx).asFloat(),
                              valueRange.getMax().component(elementNdx).asFloat(), xd, yd);
    }
}

template <int Stride>
void interpolateFragmentInput(StridedValueAccess<Stride> dst, int dstComp, ConstValueAccess vtx0, ConstValueAccess vtx1,
                              ConstValueAccess vtx2, ConstValueAccess vtx3, float x, float y)
{
    TCU_CHECK(dst.getType().getBaseType() == VariableType::TYPE_FLOAT);
    int numElements = dst.getType().getNumElements();
    for (int ndx = 0; ndx < numElements; ndx++)
        dst.component(ndx).asFloat(dstComp) =
            interpolateFragment(tcu::Vec4(vtx0.component(ndx).asFloat(), vtx1.component(ndx).asFloat(),
                                          vtx2.component(ndx).asFloat(), vtx3.component(ndx).asFloat()),
                                x, y);
}

template <int Stride>
void copyVarying(ValueAccess dst, ConstStridedValueAccess<Stride> src, int compNdx)
{
    TCU_CHECK(dst.getType().getBaseType() == VariableType::TYPE_FLOAT);
    for (int elemNdx = 0; elemNdx < dst.getType().getNumElements(); elemNdx++)
        dst.component(elemNdx).asFloat() = src.component(elemNdx).asFloat(compNdx);
}

ProgramExecutor::ProgramExecutor(const tcu::PixelBufferAccess &dst, int gridWidth, int gridHeight)
    : m_dst(dst)
    , m_gridWidth(gridWidth)
    , m_gridHeight(gridHeight)
{
}

ProgramExecutor::~ProgramExecutor(void)
{
}

void ProgramExecutor::setTexture(int samplerNdx, const tcu::Texture2D *texture, const tcu::Sampler &sampler)
{
    m_samplers2D[samplerNdx] = Sampler2D(texture, sampler);
}

void ProgramExecutor::setTexture(int samplerNdx, const tcu::TextureCube *texture, const tcu::Sampler &sampler)
{
    m_samplersCube[samplerNdx] = SamplerCube(texture, sampler);
}

inline tcu::IVec4 computeVertexIndices(float cellWidth, float cellHeight, int gridVtxWidth, int gridVtxHeight, int x,
                                       int y)
{
    DE_UNREF(gridVtxHeight);
    int x0 = (int)deFloatFloor((float)x / cellWidth);
    int y0 = (int)deFloatFloor((float)y / cellHeight);
    return tcu::IVec4(y0 * gridVtxWidth + x0, y0 * gridVtxWidth + x0 + 1, (y0 + 1) * gridVtxWidth + x0,
                      (y0 + 1) * gridVtxWidth + x0 + 1);
}

inline tcu::Vec2 computeGridCellWeights(float cellWidth, float cellHeight, int x, int y)
{
    float gx = ((float)x + 0.5f) / cellWidth;
    float gy = ((float)y + 0.5f) / cellHeight;
    return tcu::Vec2(deFloatFrac(gx), deFloatFrac(gy));
}

inline tcu::RGBA toColor(tcu::Vec4 rgba)
{
    return tcu::RGBA(
        deClamp32(deRoundFloatToInt32(rgba.x() * 255), 0, 255), deClamp32(deRoundFloatToInt32(rgba.y() * 255), 0, 255),
        deClamp32(deRoundFloatToInt32(rgba.z() * 255), 0, 255), deClamp32(deRoundFloatToInt32(rgba.w() * 255), 0, 255));
}

void ProgramExecutor::execute(const Shader &vertexShader, const Shader &fragmentShader,
                              const vector<VariableValue> &uniformValues)
{
    int gridVtxWidth  = m_gridWidth + 1;
    int gridVtxHeight = m_gridHeight + 1;
    int numVertices   = gridVtxWidth * gridVtxHeight;

    VaryingStore varyingStore(numVertices);

    // Execute vertex shader
    {
        ExecutionContext execCtx(m_samplers2D, m_samplersCube);
        int numPackets = numVertices + ((numVertices % EXEC_VEC_WIDTH) ? 1 : 0);

        const vector<ShaderInput *> &inputs = vertexShader.getInputs();
        vector<const Variable *> outputs;
        vertexShader.getOutputs(outputs);

        // Set uniform values
        for (vector<VariableValue>::const_iterator uniformIter = uniformValues.begin();
             uniformIter != uniformValues.end(); uniformIter++)
            execCtx.getValue(uniformIter->getVariable()) = uniformIter->getValue().value();

        for (int packetNdx = 0; packetNdx < numPackets; packetNdx++)
        {
            int packetStart = packetNdx * EXEC_VEC_WIDTH;
            int packetEnd   = deMin32((packetNdx + 1) * EXEC_VEC_WIDTH, numVertices);

            // Compute values for vertex shader inputs
            for (vector<ShaderInput *>::const_iterator i = inputs.begin(); i != inputs.end(); i++)
            {
                const ShaderInput *input = *i;
                ExecValueAccess access   = execCtx.getValue(input->getVariable());

                for (int vtxNdx = packetStart; vtxNdx < packetEnd; vtxNdx++)
                {
                    int y    = (vtxNdx / gridVtxWidth);
                    int x    = vtxNdx - y * gridVtxWidth;
                    float xf = (float)x / (float)(gridVtxWidth - 1);
                    float yf = (float)y / (float)(gridVtxHeight - 1);

                    interpolateVertexInput(access, vtxNdx - packetStart, input->getValueRange(), xf, yf);
                }
            }

            // Execute vertex shader for packet
            vertexShader.execute(execCtx);

            // Store output values
            for (vector<const Variable *>::const_iterator i = outputs.begin(); i != outputs.end(); i++)
            {
                const Variable *output = *i;

                if (deStringEqual(output->getName(), "gl_Position"))
                    continue; // Do not store position

                ExecConstValueAccess access = execCtx.getValue(output);
                VaryingStorage *dst         = varyingStore.getStorage(output->getType(), output->getName());

                for (int vtxNdx = packetStart; vtxNdx < packetEnd; vtxNdx++)
                {
                    ValueAccess varyingAccess = dst->getValue(output->getType(), vtxNdx);
                    copyVarying(varyingAccess, access, vtxNdx - packetStart);
                }
            }
        }
    }

    // Execute fragment shader
    {
        ExecutionContext execCtx(m_samplers2D, m_samplersCube);

        // Assign uniform values
        for (vector<VariableValue>::const_iterator i = uniformValues.begin(); i != uniformValues.end(); i++)
            execCtx.getValue(i->getVariable()) = i->getValue().value();

        const vector<ShaderInput *> &inputs = fragmentShader.getInputs();
        const Variable *fragColorVar        = DE_NULL;
        vector<const Variable *> outputs;

        // Find fragment shader output assigned to location 0. This is fragment color.
        fragmentShader.getOutputs(outputs);
        for (vector<const Variable *>::const_iterator i = outputs.begin(); i != outputs.end(); i++)
        {
            if ((*i)->getLayoutLocation() == 0)
            {
                fragColorVar = *i;
                break;
            }
        }
        TCU_CHECK(fragColorVar);

        int width      = m_dst.getWidth();
        int height     = m_dst.getHeight();
        int numPackets = (width * height) / EXEC_VEC_WIDTH + (((width * height) % EXEC_VEC_WIDTH) ? 1 : 0);

        float cellWidth  = (float)width / (float)m_gridWidth;
        float cellHeight = (float)height / (float)m_gridHeight;

        for (int packetNdx = 0; packetNdx < numPackets; packetNdx++)
        {
            int packetStart = packetNdx * EXEC_VEC_WIDTH;
            int packetEnd   = deMin32((packetNdx + 1) * EXEC_VEC_WIDTH, width * height);

            // Interpolate varyings
            for (vector<ShaderInput *>::const_iterator i = inputs.begin(); i != inputs.end(); i++)
            {
                const ShaderInput *input  = *i;
                ExecValueAccess access    = execCtx.getValue(input->getVariable());
                const VariableType &type  = input->getVariable()->getType();
                const VaryingStorage *src = varyingStore.getStorage(type, input->getVariable()->getName());

                // \todo [2011-03-08 pyry] Part of this could be pre-computed...
                for (int fragNdx = packetStart; fragNdx < packetEnd; fragNdx++)
                {
                    int y = fragNdx / width;
                    int x = fragNdx - y * width;
                    tcu::IVec4 vtxIndices =
                        computeVertexIndices(cellWidth, cellHeight, gridVtxWidth, gridVtxHeight, x, y);
                    tcu::Vec2 weights = computeGridCellWeights(cellWidth, cellHeight, x, y);

                    interpolateFragmentInput(access, fragNdx - packetStart, src->getValue(type, vtxIndices.x()),
                                             src->getValue(type, vtxIndices.y()), src->getValue(type, vtxIndices.z()),
                                             src->getValue(type, vtxIndices.w()), weights.x(), weights.y());
                }
            }

            // Execute fragment shader
            fragmentShader.execute(execCtx);

            // Write resulting color
            ExecConstValueAccess colorValue = execCtx.getValue(fragColorVar);
            for (int fragNdx = packetStart; fragNdx < packetEnd; fragNdx++)
            {
                int y       = fragNdx / width;
                int x       = fragNdx - y * width;
                int cNdx    = fragNdx - packetStart;
                tcu::Vec4 c = tcu::Vec4(colorValue.component(0).asFloat(cNdx), colorValue.component(1).asFloat(cNdx),
                                        colorValue.component(2).asFloat(cNdx), colorValue.component(3).asFloat(cNdx));

                // \todo [2012-11-13 pyry] Reverse order.
                m_dst.setPixel(c, x, m_dst.getHeight() - y - 1);
            }
        }
    }
}

} // namespace rsg