/*
 * Copyright 2024 Rive
 */

#include "gm.hpp"
#include "gmutils.hpp"
#include "common/rand.hpp"
#include "rive/math/math_types.hpp"

using namespace rivegm;

namespace rive::gpu
{
// Verifies that draw call batching works correctly when drawing strokes and
// fills with and without feathers.
class InterleavedFeatherGM : public GM
{
public:
  InterleavedFeatherGM() : GM(1000, 1000) {}

  ColorInt clearColor() const override { return 0; }

  void onDraw(Renderer* renderer) override
  {
    Rand rando;
    rando.seed(1);

    Path flower;
    flower->fillRule(FillRule::clockwise);
    constexpr static int NUM_PETALS = 7;
    constexpr static float R = 100;
    flower->moveTo(R, 0);
    for (int i = 1; i <= NUM_PETALS; ++i)
    {
      float c1 = 2 * rive::math::PI * (i - 2 / 3.f) / NUM_PETALS;
      float c2 = 2 * rive::math::PI * (i - 1 / 3.f) / NUM_PETALS;
      float theta = 2 * rive::math::PI * i / NUM_PETALS;
      flower->cubicTo(
          cosf(c1) * R * 1.65,
          sinf(c1) * R * 1.65,
          cosf(c2) * R * 1.65,
          sinf(c2) * R * 1.65,
          cosf(theta) * R,
          sinf(theta) * R);
    }
    path_addOval(
        flower,
        AABB(-.6f * R, -.6f * R, .6f * R, .6f * R),
        rivegm::PathDirection::ccw);
    flower->close();

    Paint paint;
    paint->blendMode(BlendMode::colorBurn);
    for (int i = 0; i < 300; ++i)
    {
      if (rando.boolean())
      {
        paint->feather(rando.f32(20));
      }
      else
      {
        paint->feather(expf(rando.f32(4)));
      }
      renderer->save();
      // Sequence Rand calls into named locals — C++ doesn't specify
      // argument evaluation order, so passing them directly causes
      // the random draws to interleave differently across compilers.
      float tx = rando.f32(0, 1000);
      float ty = rando.f32(0, 1000);
      renderer->translate(tx, ty);
      float s = rando.f32(.25f, .5f);
      renderer->scale(s, s);
      renderer->rotate(rando.f32(math::PI * 2));

      paint->style(RenderPaintStyle::fill);
      paint->color(rando.u32() | 0x40808080);
      renderer->drawPath(flower.get(), paint.get());

      if (rando.boolean())
      {
        paint->style(RenderPaintStyle::stroke);
        paint->thickness(rando.f32(1, 8));
        paint->join(static_cast<StrokeJoin>(rando.u32(0, 2)));
        paint->color(rando.u32() & 0xff000000);
        renderer->drawPath(flower.get(), paint.get());
      }

      renderer->restore();
    }
  }
};
GMREGISTER(interleavedfeather, return new InterleavedFeatherGM)
} // namespace rive::gpu