/*
 * Copyright 2016 Google Inc.
 * Copyright 2022 Rive
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

/*
 * This GM exercises stroking of paths with large stroke lengths, which is
 * referred to as "overstroke" for brevity. In Skia as of 8/2016 we offset
 * each part of the curve the request amount even if it makes the offsets
 * overlap and create holes. There is not a really great algorithm for this
 * and several other 2D graphics engines have the same bug.
 *
 * The old Nvidia Path Renderer used to yield correct results, so a possible
 * direction of attack is to use the GPU and a completely different algorithm.
 *
 * See crbug.com/589769 skbug.com/5405 skbug.com/5406
 */

#include "gm.hpp"
#include "gmutils.hpp"
#include "rive/renderer.hpp"
#include "rive/math/vec2d.hpp"
#include "rive/math/contour_measure.hpp"

using namespace rivegm;
using namespace rive;

const float OVERSTROKE_WIDTH = 500.0f;
const float NORMALSTROKE_WIDTH = 3.0f;

//////// path and paint builders

Paint make_normal_paint()
{
  Paint p;
  p->style(RenderPaintStyle::stroke);
  p->thickness(NORMALSTROKE_WIDTH);
  p->color(0xff0000ff);

  return p;
}

Paint make_overstroke_paint()
{
  Paint p;
  p->style(RenderPaintStyle::stroke);
  p->thickness(OVERSTROKE_WIDTH);

  return p;
}

RawPath quad_path()
{
  RawPath path;
  path.moveTo(0, 0);
  path.lineTo(100, 0);
  path.quadTo(50, -40, 0, 0);
  path.close();
  return path;
}

RawPath cubic_path()
{
  RawPath path;
  path.moveTo(0, 0);
  path.cubicTo(25, 75, 75, -50, 100, 0);
  return path;
}

RawPath oval_path()
{
  RawPath path;
  path.addOval({0, -25, 100, 25});
  return path;
}

Path ribs_path(const RawPath& path, float radius)
{
  Path ribs;

  const float spacing = 5.0f;
  float accum = 0.0f;

  ContourMeasureIter iter(&path);
  while (auto meas = iter.next())
  {
    while (accum < meas->length())
    {
      auto posTan = meas->getPosTan(accum);
      Vec2D pos = posTan.pos;
      // there appeara to be a bug somewhere that is not normalizing this
      // when it should, so i am doing it here
      Vec2D tan = posTan.tan.normalized();
      tan = {tan.y * radius, -tan.x * radius};

      Vec2D start = pos + tan;
      Vec2D end = pos - tan;

      ribs->moveTo(start.x, start.y);
      ribs->lineTo(end.x, end.y);

      accum += spacing;
    }
    accum += meas->length();
  }

  /*
  SkPathMeasure meas(skpath, false);
  SkScalar length = meas.getLength();
  SkPoint pos;
  SkVector tan;
  while (accum < length)
  {
      if (meas.getPosTan(accum, &pos, &tan))
      {
          tan.scale(radius);
          tan = {tan.y(), -tan.x()};

          ribs->moveTo(pos.x() + tan.x(), pos.y() + tan.y());
          ribs->lineTo(pos.x() - tan.x(), pos.y() - tan.y());
      }
      accum += spacing;
  }
  */

  return ribs;
}

void draw_ribs(Renderer* canvas, const RawPath& path)
{
  Path ribs = ribs_path(path, OVERSTROKE_WIDTH / 2.0f);
  Paint p = make_normal_paint();
  p->thickness(1);
  p->color(0xff00ff00);

  canvas->drawPath(ribs, p);
}

///////// quads

void draw_small_quad(Renderer* canvas)
{
  // scaled so it's visible
  // canvas->scale(8, 8);

  Paint p = make_normal_paint();
  RawPath path = quad_path();

  auto renderPath = renderPathFromRawPath(path);

  draw_ribs(canvas, path);
  canvas->drawPath(renderPath.get(), p);
}

void draw_large_quad(Renderer* canvas)
{
  Paint p = make_overstroke_paint();
  RawPath path = quad_path();

  auto renderPath = renderPathFromRawPath(path);

  canvas->drawPath(renderPath.get(), p);
  draw_ribs(canvas, path);
}

void draw_stroked_quad(Renderer* canvas)
{
  canvas->translate(400, 0);
  draw_large_quad(canvas);
}

////////// cubics

void draw_small_cubic(Renderer* canvas)
{
  Paint p = make_normal_paint();
  RawPath path = cubic_path();

  auto renderPath = renderPathFromRawPath(path);

  draw_ribs(canvas, path);
  canvas->drawPath(renderPath.get(), p);
}

void draw_large_cubic(Renderer* canvas)
{
  Paint p = make_overstroke_paint();
  RawPath path = cubic_path();

  auto renderPath = renderPathFromRawPath(path);

  canvas->drawPath(renderPath.get(), p);
  draw_ribs(canvas, path);
}

void draw_stroked_cubic(Renderer* canvas)
{
  canvas->translate(400, 0);
  draw_large_cubic(canvas);
}

////////// ovals

void draw_small_oval(Renderer* canvas)
{
  Paint p = make_normal_paint();
  RawPath path = oval_path();

  auto renderPath = renderPathFromRawPath(path);

  draw_ribs(canvas, path);
  canvas->drawPath(renderPath.get(), p);
}

void draw_large_oval(Renderer* canvas)
{
  Paint p = make_overstroke_paint();
  RawPath path = oval_path();

  auto renderPath = renderPathFromRawPath(path);

  canvas->drawPath(renderPath.get(), p);
  draw_ribs(canvas, path);
}

void draw_stroked_oval(Renderer* canvas)
{
  canvas->translate(400, 0);
  draw_large_oval(canvas);
}

////////// gm

void (*examples[])(Renderer* canvas) = {
    draw_small_quad,
    draw_stroked_quad,
    draw_small_cubic,
    draw_stroked_cubic,
    draw_small_oval,
    draw_stroked_oval,
};

DEF_SIMPLE_GM(OverStroke, 500, 500, canvas)
{
  const size_t length = sizeof(examples) / sizeof(examples[0]);
  const size_t width = 2;

  for (size_t i = 0; i < length; i++)
  {
    int x = (int)(i % width);
    int y = (int)(i / width);

    canvas->save();
    canvas->translate(150.0f * x, 150.0f * y);
    canvas->scale(0.2f, 0.2f);
    canvas->translate(300.0f, 400.0f);

    examples[i](canvas);

    canvas->restore();
  }
}