/*
 * Copyright 2026 Rive
 */

#include "gm.hpp"
#include "gmutils.hpp"

#include "rive/math/math_types.hpp"

#include "assets/nomoon.png.hpp"

using namespace rivegm;
using namespace rive;

constexpr int QuadSize = 120;
constexpr int Columns = 4;
constexpr int Rows = 4;
constexpr int Pad = 10;

struct QuadMesh
{
  rcp<RenderBuffer> pts;
  rcp<RenderBuffer> uvs;
  rcp<RenderBuffer> indices;
  uint32_t vertexCount = 4;
  uint32_t indexCount = 6;
};

static rcp<RenderBuffer> makeVertexBuffer(
    Factory* factory,
    const Vec2D values[4])
{
  auto buffer = factory->makeRenderBuffer(
      RenderBufferType::vertex,
      RenderBufferFlags::mappedOnceAtInitialization,
      4 * sizeof(Vec2D));
  memcpy(buffer->map(), values, 4 * sizeof(Vec2D));
  buffer->unmap();
  return buffer;
}

static QuadMesh makeQuad(Factory* factory)
{
  const Vec2D pts[4] =
      {{0, 0}, {QuadSize, 0}, {QuadSize, QuadSize}, {0, QuadSize}};
  const Vec2D uvs[4] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}};
  const uint16_t indices[6] = {0, 1, 2, 0, 2, 3};

  QuadMesh mesh;
  mesh.pts = makeVertexBuffer(factory, pts);
  mesh.uvs = makeVertexBuffer(factory, uvs);
  mesh.indices = factory->makeRenderBuffer(
      RenderBufferType::index,
      RenderBufferFlags::mappedOnceAtInitialization,
      sizeof(indices));
  memcpy(mesh.indices->map(), indices, sizeof(indices));
  mesh.indices->unmap();
  return mesh;
}

static Mat2D cellTransform(int column, int row)
{
  return Mat2D::fromTranslate(
      Pad + column * (QuadSize + Pad),
      Pad + row * (QuadSize + Pad));
}

// Use a gray background so we can see opacity and additiveness
DEF_SIMPLE_GM_WITH_CLEAR_COLOR(
    mesh_instanced,
    0xff808080,
    Columns*(QuadSize + Pad) + Pad,
    Rows*(QuadSize + Pad) + Pad,
    ren)
{
  auto img = LoadImage(assets::nomoon_png());
  if (img == nullptr)
  {
    return;
  }

  Factory* factory = TestingWindow::Get()->factory();
  QuadMesh mesh = makeQuad(factory);

  auto instances = factory->makeImageMeshInstances(Columns * Rows);
  Span<ImageMeshInstanceData> data = instances->edit();

  for (int column = 0; column < Columns; ++column)
  {
    const float t = column / float(Columns - 1);

    // Row 0: transform only
    Mat2D spin = Mat2D::fromTranslate(QuadSize * 0.5f, QuadSize * 0.5f) *
                 Mat2D::fromRotation(t * math::PI * 0.5f) *
                 Mat2D::fromTranslate(QuadSize * -0.5f, QuadSize * -0.5f);
    data[column].transform = cellTransform(column, 0) * spin;

    // Row 1: opacity ramp
    data[Columns + column].transform = cellTransform(column, 1);
    data[Columns + column].opacity = 1.0f - 0.25f * column;

    // Row 2: UV transform
    data[Columns * 2 + column].transform = cellTransform(column, 2);
    data[Columns * 2 + column].uvScale = {0.5f, 0.5f};
    data[Columns * 2 + column].uvTranslate = {
        (column & 1) ? 0.5f : 0.0f,
        (column & 2) ? 0.5f : 0.0f};

    // Row 3: additiveness ramp.
    data[Columns * 3 + column].transform = cellTransform(column, 3);
    data[Columns * 3 + column].additiveness = t;
  }
  instances->endEdit();

  ren->drawImageMeshInstanced(
      img.get(),
      ImageSampler::LinearClamp(),
      mesh.pts,
      mesh.uvs,
      mesh.indices,
      mesh.vertexCount,
      mesh.indexCount,
      instances);
}