/*
 * Copyright 2022 Rive
 */
#include "testing_window.hpp"

#if !defined(RIVE_SVG) || !defined(__EMSCRIPTEN__)

TestingWindow* TestingWindow::MakeSVG() { return nullptr; }

#else

#include "rive/decoders/bitmap_decoder.hpp"
#include "utils/svg_factory.hpp"
#include "utils/svg_renderer.hpp"

#include <limits>
#include <string>
#include <vector>

#include <emscripten/emscripten.h>
#include <emscripten/html5.h>

namespace rive::gpu
{
EM_JS(void, testingWindowSVGResetCanvas, (), {
  var canvas = document["getElementById"]("canvas");
  var ctx = canvas["getContext"]("2d");
  ctx["reset"]();
});

EM_JS(
    bool,
    testingWindowSVGGetCanvasPixels,
    (uint8_t* outBuffer, int width, int height),
    {
      var canvas = document["getElementById"]("canvas");
      var ctx = canvas["getContext"]("2d");
      var imageData = ctx["getImageData"](0, 0, canvas.width, canvas.height);
      var pixelArray = imageData["data"];
      if (pixelArray.length != width * height * 4)
      {
        return false;
      }

      // TestHarness::savePNG() flips vertically on the way out, since every
      // other backend fills this buffer bottom-up (the GL convention).
      // getImageData() hands back rows top-down, so reverse them here and
      // let the two cancel.
      var stride = width * 4;
      for (var y = 0; y < height; ++y)
      {
        Module["HEAPU8"]["set"](
            pixelArray["subarray"](
                (height - 1 - y) * stride,
                (height - y) * stride),
            outBuffer + y * stride);
      }
      return true;
    });

// Rasterizing SVG means handing it to an <img> and blitting that; the browser
// offers no synchronous path. EM_ASYNC_JS relies on the ASYNCIFY that the wasm
// test targets already link with.
EM_ASYNC_JS(
    bool,
    testingWindowSVGDrawSVGToCanvas,
    (const char* svg, int width, int height),
    {
      // clang-format off
    var url = URL["createObjectURL"](new Blob([UTF8ToString(svg)], {
        type: "image/svg+xml"
    }));
    try
    {
        var img = new Image();
        img["src"] = url;
        await img["decode"]();
        var ctx = document["getElementById"]("canvas")["getContext"]("2d");
        ctx["drawImage"](img, 0, 0, width, height);
        return true;
    }
    catch (e)
    {
        console["error"](e);
        return false;
    }
    finally
    {
        URL["revokeObjectURL"](url);
    }
      // clang-format on
    });

// This wrapper exists so that we can return a std::unique_ptr<Renderer> from
// beginFrame() while still holding a pointer to the returned object for use in
// endFrame().
class SVGRendererWrapper : public rive::Renderer
{
public:
  SVGRendererWrapper(std::shared_ptr<rive::SVGRenderer>& renderer)
      : m_renderer(renderer)
  {}

  void save() override { m_renderer->save(); }
  void restore() override { m_renderer->restore(); }
  void transform(const Mat2D& transform) override
  {
    m_renderer->transform(transform);
  }
  void drawPath(RenderPath* path, RenderPaint* paint) override
  {
    m_renderer->drawPath(path, paint);
  }
  void clipPath(RenderPath* path) override { m_renderer->clipPath(path); }
  void drawImage(
      const RenderImage* image,
      ImageSampler sampler,
      BlendMode blendMode,
      float opacity) override
  {
    m_renderer->drawImage(image, sampler, blendMode, opacity);
  }
  void drawImageMesh(
      const RenderImage* image,
      ImageSampler sampler,
      rcp<RenderBuffer> vertices_f32,
      rcp<RenderBuffer> uvCoords_f32,
      rcp<RenderBuffer> indices_u16,
      uint32_t vertexCount,
      uint32_t indexCount,
      BlendMode blendMode,
      float opacity) override
  {
    m_renderer->drawImageMesh(
        image,
        sampler,
        vertices_f32,
        uvCoords_f32,
        indices_u16,
        vertexCount,
        indexCount,
        blendMode,
        opacity);
  }
  void modulateOpacity(float opacity) override
  {
    m_renderer->modulateOpacity(opacity);
  }

private:
  std::shared_ptr<rive::SVGRenderer> m_renderer;
};

// SVGFactory embeds encoded images verbatim as data URIs, so it only needs
// their dimensions. rive_decoders has no header-only sizing entry point, so
// pay for a full decode and throw the pixels away (fine since these are just
// tests).
static bool decodeImageSize(
    rive::Span<const uint8_t> encodedBytes,
    uint32_t* width,
    uint32_t* height)
{
  auto bitmap = Bitmap::decode(encodedBytes.data(), encodedBytes.size());
  if (bitmap == nullptr)
  {
    return false;
  }
  *width = bitmap->width();
  *height = bitmap->height();
  return true;
}

class TestingWindowSVG : public TestingWindow
{
public:
  TestingWindowSVG()
  {
    int w, h;
    emscripten_get_canvas_element_size("#canvas", &w, &h);
    m_width = w;
    m_height = h;

    m_factory = std::make_unique<SVGFactory>(decodeImageSize);
  }

  rive::Factory* factory() override { return m_factory.get(); }

  void resize(int width, int height) override
  {
    if (m_width != (uint32_t)width || m_height != (uint32_t)height)
    {
      TestingWindow::resize(width, height);
      emscripten_set_canvas_element_size("#canvas", width, height);
    }
  }

  std::unique_ptr<rive::Renderer> beginFrame(
      const FrameOptions& options) override
  {
    // Because the SVGRenderer is a stateful object that accumulates all
    // draws, we treat doCleaer as a "reset" flag. If doClear is true, we
    // reset the renderer to start fresh; if false, we keep the existing
    // state and continue drawing on top of it.

    // For the above reason, we always reset the canvas at the start of a
    // frame; endFrame will include previous frames' contents if doClear was
    // not set.
    testingWindowSVGResetCanvas();

    if (options.doClear)
    {
      m_renderer.reset();
    }

    if (!m_renderer)
    {
      // Goldens compare pixels, so emit enough digits to round-trip
      // a float rather than the renderer's compact default.
      m_renderer = std::make_shared<SVGRenderer>(
          std::numeric_limits<float>::max_digits10);
    }

    if (options.doClear)
    {
      RawPath rawPath;
      rawPath.addRect(AABB(0, 0, (float)m_width, (float)m_height));
      auto path = m_factory->makeRenderPath(rawPath, FillRule::nonZero);
      auto paint = m_factory->makeRenderPaint();
      paint->style(RenderPaintStyle::fill);
      paint->color(options.clearColor);
      m_renderer->drawPath(path.get(), paint.get());
    }

    return std::make_unique<SVGRendererWrapper>(m_renderer);
  }

  void endFrame(std::vector<uint8_t>* pixelData) override
  {
    std::string svg = m_renderer->finalize(m_width, m_height);
    if (!testingWindowSVGDrawSVGToCanvas(svg.c_str(), m_width, m_height))
    {
      printf("Failed to rasterize SVG\n");
    }

    if (!pixelData)
    {
      return;
    }

    pixelData->resize(m_width * m_height * 4);
    if (!testingWindowSVGGetCanvasPixels(pixelData->data(), m_width, m_height))
    {
      printf("Canvas size mismatch, read failed\n");
      pixelData->assign(pixelData->size(), 0);
    }

    m_renderer.reset();
  }

private:
  std::unique_ptr<SVGFactory> m_factory;
  std::shared_ptr<SVGRenderer> m_renderer;
};
}; // namespace rive::gpu

TestingWindow* TestingWindow::MakeSVG()
{
  return new rive::gpu::TestingWindowSVG();
}

#endif