/*
 * Copyright 2024 Rive
 */

#include "bench.hpp"

#include "../src/intersection_board.hpp"
#include "common/intersection_board_reference_impl.hpp"

#include "marty_bboxes_187_copies.hpp"
#include "paper_bboxes_6_copies.hpp"

using namespace rive;
using namespace rive::gpu;

template <GroupingType Type> class IntersectionTileBenchBase : public Bench
{
public:
    void setup() override
    {
        // Prime the std::vectors.
        run();
    }

private:
    int run() const override
    {
        srand(0);
        m_tile.reset(0, 0, 0);
        uint16_t idx = 0;
        for (size_t i = 0; i < 10000; ++i)
        {
            int4 box = int4{rand(), rand(), rand(), rand()} & 0xff;
            int4 ltrb;
            ltrb.xy = simd::min(box.xy, box.zw);
            ltrb.zw = simd::max(box.xy, box.zw);
            ltrb = simd::min(ltrb, int4(254));
            ltrb.zw += 1;

            auto r = m_tile.findMaxIntersectingGroupIndex<Type>(ltrb, {});
            uint16_t idx = simd::reduce_max(r.maxGroupIndices) + 1;
            m_tile.addRectangle<Type>(ltrb, idx, 0);
        }
        return idx;
    }

#if 1
    mutable IntersectionTile m_tile;
#else
    mutable IntersectionBoardReferenceImpl m_tile;
#endif
};

class IntersectionTileBench
    : public IntersectionTileBenchBase<GroupingType::disjoint>
{};
REGISTER_BENCH(IntersectionTileBench);

class IntersectionTileBenchWithOverlap
    : public IntersectionTileBenchBase<GroupingType::overlapAllowed>
{};

REGISTER_BENCH(IntersectionTileBenchWithOverlap);

class IntersectionBoardBench : public Bench
{
public:
    IntersectionBoardBench(uint32_t width,
                           uint32_t height,
                           const int4* bboxes,
                           size_t bboxCount) :
        m_width(width),
        m_height(height),
        m_bboxes(bboxes),
        m_bboxCount(bboxCount),
        m_board{GroupingType::disjoint}
    {}

    void setup() override
    {
        // Prime the std::vectors.
        run();
    }

private:
    int run() const override
    {
        uint16_t maxIdx = 0;
        m_board.resizeAndReset(m_width, m_height);
        for (size_t i = 0; i < m_bboxCount; ++i)
        {
            uint16_t idx = m_board.addRectangle(m_bboxes[i]);
            maxIdx = std::max(idx, maxIdx);
        }
        return maxIdx;
    }

    uint32_t m_width;
    uint32_t m_height;
    const int4* m_bboxes;
    size_t m_bboxCount;

#if 1
    mutable IntersectionBoard m_board;
#else
    mutable IntersectionBoardReferenceImpl m_board;
#endif
};

class IntersectionBoardBench_paper : public IntersectionBoardBench
{
public:
    IntersectionBoardBench_paper() :
        IntersectionBoardBench(paper_bboxes_6_copies_window_width,
                               paper_bboxes_6_copies_window_height,
                               paper_bboxes_6_copies,
                               paper_bboxes_6_copies_bbox_count)
    {}
};

REGISTER_BENCH(IntersectionBoardBench_paper);

class IntersectionBoardBench_marty : public IntersectionBoardBench
{
public:
    IntersectionBoardBench_marty() :
        IntersectionBoardBench(marty_bboxes_187_copies_window_width,
                               marty_bboxes_187_copies_window_height,
                               marty_bboxes_187_copies,
                               marty_bboxes_187_copies_bbox_count)
    {}
};

REGISTER_BENCH(IntersectionBoardBench_marty);