#include "vello_renderer.hpp"

VelloPath::~VelloPath() { vello_path_release(m_path); }

void VelloPath::rewind() { vello_path_rewind(m_path); }

void VelloPath::addRenderPath(RenderPath* path, const Mat2D& transform)
{
    vello_path_extend(m_path, static_cast<VelloPath*>(path)->m_path, transform.values());
}

void VelloPath::fillRule(FillRule value) { vello_path_set_fill_rule(m_path, value); }

void VelloPath::moveTo(float x, float y) { vello_path_move_to(m_path, x, y); }

void VelloPath::lineTo(float x, float y) { vello_path_line_to(m_path, x, y); }

void VelloPath::cubicTo(float ox, float oy, float ix, float iy, float x, float y)
{
    vello_path_cubic_to(m_path, ox, oy, ix, iy, x, y);
}

void VelloPath::close() { vello_path_close(m_path); }

VelloGradient::~VelloGradient() { vello_gradient_release(m_gradient); }

VelloImage::~VelloImage() { vello_image_release(m_image); }

VelloPaint::~VelloPaint() { vello_paint_release(m_paint); }

void VelloPaint::style(RenderPaintStyle style) { vello_paint_set_style(m_paint, style); }

void VelloPaint::color(unsigned int value) { vello_paint_set_color(m_paint, value); }

void VelloPaint::thickness(float value) { vello_paint_set_thickness(m_paint, value); }

void VelloPaint::join(StrokeJoin value) { vello_paint_set_join(m_paint, value); }

void VelloPaint::cap(StrokeCap value) { vello_paint_set_cap(m_paint, value); }

void VelloPaint::blendMode(BlendMode value) { vello_paint_set_blend_mode(m_paint, value); }

void VelloPaint::shader(rcp<RenderShader> shader)
{
    VelloGradient* gradient = (VelloGradient*)shader.get();

    if (gradient != nullptr)
    {
        vello_paint_set_gradient(m_paint, gradient->gradient());
    }
}

void VelloRenderer::save() { vello_renderer_save(m_renderer); }

void VelloRenderer::restore() { vello_renderer_restore(m_renderer); }

void VelloRenderer::transform(const Mat2D& transform)
{
    vello_renderer_transform(m_renderer, transform.values());
}

void VelloRenderer::clipPath(RenderPath* path)
{
    vello_renderer_clip_path(m_renderer, static_cast<VelloPath*>(path)->path());
}

void VelloRenderer::drawPath(RenderPath* path, RenderPaint* paint)
{
    vello_renderer_draw_path(m_renderer,
                             static_cast<VelloPath*>(path)->path(),
                             static_cast<VelloPaint*>(paint)->paint());
}

void VelloRenderer::drawImage(const RenderImage* image, BlendMode blend_mode, float opacity)
{
    vello_renderer_draw_image(m_renderer,
                              static_cast<const VelloImage*>(image)->image(),
                              blend_mode,
                              opacity);
}

void VelloRenderer::drawImageMesh(const RenderImage* image,
                                  rcp<RenderBuffer> vertices,
                                  rcp<RenderBuffer> uvCoords,
                                  rcp<RenderBuffer> indices,
                                  uint32_t vertexCount,
                                  uint32_t indexCount,
                                  BlendMode blendMode,
                                  float opacity)
{
    vello_renderer_draw_image_mesh(m_renderer,
                                   static_cast<const VelloImage*>(image)->image(),
                                   DataRenderBuffer::Cast(vertices.get())->vecs(),
                                   vertexCount,
                                   DataRenderBuffer::Cast(uvCoords.get())->vecs(),
                                   vertexCount,
                                   DataRenderBuffer::Cast(indices.get())->u16s(),
                                   indexCount,
                                   blendMode,
                                   opacity);
}

rcp<RenderBuffer> VelloFactory::makeRenderBuffer(RenderBufferType type,
                                                 RenderBufferFlags flags,
                                                 size_t sizeInBytes)
{
    return make_rcp<DataRenderBuffer>(type, flags, sizeInBytes);
}

rcp<RenderShader> VelloFactory::makeLinearGradient(float sx,
                                                   float sy,
                                                   float ex,
                                                   float ey,
                                                   const ColorInt colors[], // [count]
                                                   const float stops[],     // [count]
                                                   size_t count)
{
    RawVelloGradient gradient = vello_gradient_new_linear(sx, sy, ex, ey, colors, stops, count);
    return rcp<RenderShader>(new VelloGradient(std::move(gradient)));
}

rcp<RenderShader> VelloFactory::makeRadialGradient(float cx,
                                                   float cy,
                                                   float radius,
                                                   const ColorInt colors[], // [count]
                                                   const float stops[],     // [count]
                                                   size_t count)
{
    RawVelloGradient gradient = vello_gradient_new_radial(cx, cy, radius, colors, stops, count);
    return rcp<RenderShader>(new VelloGradient(std::move(gradient)));
}

std::unique_ptr<RenderPath> VelloFactory::makeRenderPath(RawPath& rawPath, FillRule fillRule)
{
    std::unique_ptr<VelloPath> path = std::make_unique<VelloPath>();

    for (auto [verb, points] : rawPath)
    {
        switch (verb)
        {
            case PathVerb::move:
                path->move(points[0]);
                break;
            case PathVerb::line:
                path->line(points[1]);
                break;
            case PathVerb::cubic:
                path->cubic(points[1], points[2], points[3]);
                break;
            case PathVerb::close:
                path->close();
                break;
        }
    }

    return path;
}

std::unique_ptr<RenderPath> VelloFactory::makeEmptyRenderPath()
{
    return std::make_unique<VelloPath>();
}

std::unique_ptr<RenderPaint> VelloFactory::makeRenderPaint()
{
    return std::make_unique<VelloPaint>();
}

std::unique_ptr<RenderImage> VelloFactory::decodeImage(Span<const uint8_t> encoded)
{
    return std::make_unique<VelloImage>(vello_image_new(encoded.data(), encoded.size()));
}

static VelloFactory factory;
rive::Factory* ViewerContent::RiveFactory() { return &factory; }