/*
 * Copyright 2026 Rive
 */

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

using namespace rivegm;
using namespace rive;

namespace
{
enum class UseFeather : bool
{
    No,
    Yes,
};

enum class ShapeSize
{
    Small,
    Large,
    Stretch,
};

template <UseFeather Feather,
          ShapeSize InnerSize,
          BlendMode Blend = BlendMode::srcOver>
class ClipShapesGM : public GM
{
public:
    static constexpr int32_t SectionSize = 400;
    static constexpr int32_t Spacing = 50;
    static constexpr int32_t RoundRadius = 50;
    static constexpr int32_t SectionCount = 3;
    static constexpr int32_t ImageDim = SectionCount * SectionSize;

    ClipShapesGM() : GM(ImageDim, ImageDim) {}

    void onDraw(rive::Renderer* renderer) override
    {
        {
            Paint p;
            p->color(0xff000000);
            renderer->drawPath(
                PathBuilder::Rect(
                    {0.0f, 0.0f, float(ImageDim), float(ImageDim)}),
                p);
        }
        {
            Paint p;
            p->color(0xff2c1642);
            p->feather(10.0f);
            auto yStep = 40.0f;
            for (auto y = 20.0f; y < float(SectionCount * SectionSize); y++)
            {
                auto path = PathBuilder::Rect({
                    -100.0f,
                    y,
                    float(ImageDim) + 100.0f,
                    y + yStep * 0.3f,
                });
                path->fillRule(FillRule::clockwise);
                renderer->drawPath(path, p);
                y += yStep;
                yStep *= 1.12f;
            }
        }
        constexpr uint32_t Colors[SectionCount][SectionCount] = {
            {
                0xff881177,
                0xffeedd00,
                0xff00bbcc,
            },
            {
                0xffaa3355,
                0xff99dd55,
                0xffee9944,
            },
            {
                0xffcc6666,
                0xff3366bb,
                0xff22ccbb,
            },
        };
        for (auto yIndex = 0; yIndex < 3; yIndex++)
        {
            for (auto xIndex = 0; xIndex < 3; xIndex++)
            {
                renderer->save();
                {
                    const auto box = AABB{
                        float(SectionSize * xIndex + Spacing / 2),
                        float(SectionSize * yIndex + Spacing / 2),
                        float(SectionSize * (xIndex + 1) - Spacing / 2),
                        float(SectionSize * (yIndex + 1) - Spacing / 2),
                    };
                    auto clipper = PathBuilder::RRect(box,
                                                      float(RoundRadius),
                                                      float(RoundRadius));
                    renderer->clipPath(clipper);

                    Paint p;
                    p->color(Colors[xIndex][yIndex]);
                    p->blendMode(Blend);
                    if constexpr (Feather == UseFeather::Yes)
                    {
                        p->feather(float(Spacing));
                    }

                    if constexpr (InnerSize == ShapeSize::Large)
                    {
                        const auto dim =
                            float(SectionCount * SectionSize) * 0.5f;
                        auto path = PathBuilder::Circle(dim, dim, dim * 0.8f);
                        path->fillRule(FillRule::clockwise);
                        renderer->drawPath(path, p);
                    }
                    else
                    {
                        auto x = lerp(box.right(),
                                      box.left(),
                                      float(xIndex) / float(SectionCount - 1));
                        auto y = lerp(box.bottom(),
                                      box.top(),
                                      float(yIndex) / float(SectionCount - 1));
                        auto path =
                            PathBuilder::Circle(x, y, SectionSize * 0.24f);
                        path->fillRule(FillRule::clockwise);
                        renderer->drawPath(path, p);
                    }
                }
                renderer->restore();
            }
        }
    }
};
} // namespace

GMREGISTER(clip_shapes_large_corners,
           return (new ClipShapesGM<UseFeather::No, ShapeSize::Large>()))
GMREGISTER(clip_shapes_large_corners_feathered,
           return (new ClipShapesGM<UseFeather::Yes, ShapeSize::Large>()))
GMREGISTER(clip_shapes_small_corners,
           return (new ClipShapesGM<UseFeather::No, ShapeSize::Small>()))
GMREGISTER(clip_shapes_small_corners_feathered,
           return (new ClipShapesGM<UseFeather::Yes, ShapeSize::Small>()))
GMREGISTER(clip_shapes_large_corners_feathered_blend,
           return (new ClipShapesGM<UseFeather::Yes,
                                    ShapeSize::Large,
                                    BlendMode::screen>()))
GMREGISTER(clip_shapes_small_corners_feathered_blend,
           return (new ClipShapesGM<UseFeather::Yes,
                                    ShapeSize::Small,
                                    BlendMode::screen>()))