/*
 * Copyright 2022 Rive
 */

#include "bicubic.hpp"
#include <vector>

template <typename T> T lerp(const T& a, const T& b, float t)
{
    return a * (1 - t) + b * t;
}

using namespace rivegm;

rive::Vec2D BicubicPatch::eval(float u, float v) const
{
    float weights[16];
    this->evalWeights(u, v, weights);

    rive::Vec2D result{0, 0};
    for (int i = 0; i < 16; ++i)
    {
        result += m_Pts[i] * weights[i];
    }
    return result;
}

void BicubicPatch::evalWeights(float u, float v, float weights[16]) const
{
    auto compute_bezier_coeff = [](float c[4], float t) {
        float s = 1 - t;
        c[0] = s * s * s;
        c[1] = 3 * t * s * s;
        c[2] = 3 * t * t * s;
        c[3] = t * t * t;
    };

    float cu[4], cv[4];
    compute_bezier_coeff(cu, u);
    compute_bezier_coeff(cv, v);

    int i = 0;
    for (int y = 0; y < 4; ++y)
    {
        for (int x = 0; x < 4; ++x)
        {
            weights[i++] = cu[x] * cv[y];
        }
    }
}

BicubicPatch::Rec BicubicPatch::buffers(const rive::AABB* uvBounds) const
{
    constexpr int N = 16;

    constexpr int QUADS = N * N;
    constexpr int VERTS = (N + 1) * (N + 1);
    constexpr int TRIS = QUADS * 2;
    constexpr int INDXS = TRIS * 3;

    const rive::AABB unit = {0, 0, 1, 1};
    if (!uvBounds)
    {
        uvBounds = &unit;
    }

    Rec rec;
    rec.pts.resize(VERTS);
    rec.uvs.resize(VERTS);

    auto pos = rec.pts.data();
    auto tex = rec.uvs.data();

    const float normalize = 1.0f / N;

    for (int y = 0; y <= N; ++y)
    {
        const float v = y * normalize;
        const float tex_v = lerp(uvBounds->top(), uvBounds->bottom(), v);
        for (int x = 0; x <= N; ++x)
        {
            const float u = x * normalize;
            *pos++ = this->eval(u, v);
            *tex++ = {
                lerp(uvBounds->left(), uvBounds->right(), u),
                tex_v,
            };
        }
    }
    assert(pos - rec.pts.data() == VERTS);
    assert(tex - rec.uvs.data() == VERTS);

    rec.indices.resize(INDXS);
    uint16_t* ndx = rec.indices.data();

    constexpr int W = N + 1;

    int index = 0;
    for (int y = 0; y < N; ++y)
    {
        for (int x = 0; x < N; ++x)
        {
            ndx[0] = index;
            ndx[1] = index + 1;
            ndx[2] = index + 1 + W;
            ndx[3] = index;
            ndx[4] = index + 1 + W;
            ndx[5] = index + W;
            ndx += 6;
            index += 1;
        }
        index += 1; // skip the last column
    }
    assert(ndx - rec.indices.data() == INDXS);
    for (int i = 0; i < INDXS; ++i)
    {
        assert(rec.indices[i] < VERTS);
    }

    return rec;
}

BicubicPatch::Mesh BicubicPatch::mesh(rive::Factory* factory,
                                      const rive::AABB* uvBounds) const
{
    auto rec = BicubicPatch::buffers(uvBounds);

    auto ptsBuffer =
        factory->makeRenderBuffer(rive::RenderBufferType::vertex,
                                  rive::RenderBufferFlags::none,
                                  rec.pts.size() * sizeof(rive::Vec2D));
    if (ptsBuffer)
    {
        void* ptsData = ptsBuffer->map();
        memcpy(ptsData, rec.pts.data(), ptsBuffer->sizeInBytes());
        ptsBuffer->unmap();
    }

    auto uvsBuffer = factory->makeRenderBuffer(
        rive::RenderBufferType::vertex,
        rive::RenderBufferFlags::mappedOnceAtInitialization,
        rec.uvs.size() * sizeof(rive::Vec2D));
    if (uvsBuffer)
    {
        void* uvsData = uvsBuffer->map();
        memcpy(uvsData, rec.uvs.data(), uvsBuffer->sizeInBytes());
        uvsBuffer->unmap();
    }

    auto idxBuffer = factory->makeRenderBuffer(
        rive::RenderBufferType::index,
        rive::RenderBufferFlags::mappedOnceAtInitialization,
        rec.indices.size() * sizeof(uint16_t));
    if (idxBuffer)
    {
        void* idxData = idxBuffer->map();
        memcpy(idxData, rec.indices.data(), idxBuffer->sizeInBytes());
        idxBuffer->unmap();
    }

    return {std::move(ptsBuffer), std::move(uvsBuffer), std::move(idxBuffer)};
}