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

#include "gm.hpp"
#include "gmutils.hpp"
#include "rive/renderer.hpp"

using namespace rivegm;
using namespace rive;

namespace
{

// Concave test
void test_concave(Renderer* canvas, const Paint& paint)
{
  canvas->translate(0, 0);
  canvas->drawPath(
      PathBuilder::Polygon({{20, 20}, {80, 20}, {30, 30}, {20, 80}}, false),
      paint);
}

// Reverse concave test
void test_reverse_concave(Renderer* canvas, const Paint& paint)
{
  canvas->save();
  canvas->translate(100, 0);
  canvas->drawPath(
      PathBuilder::Polygon({{20, 20}, {20, 80}, {30, 30}, {80, 20}}, false),
      paint);
  canvas->restore();
}

// Bowtie (intersection)
void test_bowtie(Renderer* canvas, const Paint& paint)
{
  canvas->save();
  canvas->translate(200, 0);
  canvas->drawPath(
      PathBuilder::Polygon({{20, 20}, {80, 80}, {80, 20}, {20, 80}}, false),
      paint);
  canvas->restore();
}

// "fake" bowtie (concave, but no intersection)
void test_fake_bowtie(Renderer* canvas, const Paint& paint)
{
  canvas->save();
  canvas->translate(300, 0);
  canvas->drawPath(
      PathBuilder::Polygon(
          {{20, 20}, {50, 40}, {80, 20}, {80, 80}, {50, 60}, {20, 80}},
          false),
      paint);
  canvas->restore();
}

// Bowtie with a smaller right hand lobe. The outer vertex of the left hand
// lobe intrudes into the interior of the right hand lobe.
void test_intruding_vertex(Renderer* canvas, const Paint& paint)
{
  canvas->save();
  canvas->translate(400, 0);
  canvas->drawPath(
      PathBuilder::Polygon(
          {{20, 20}, {50, 50}, {68, 20}, {68, 80}, {50, 50}, {20, 80}},
          false,
          FillRule::nonZero),
      paint);
  canvas->restore();
}

// A shape with an edge that becomes inverted on AA stroking and that also
// contains a repeated start/end vertex.
void test_inversion_repeat_vertex(Renderer* canvas, const Paint& paint)
{
  canvas->save();
  canvas->translate(400, 100);
  const std::vector<Vec2D> pts = {
      {80, 50},
      {40, 80},
      {60, 20},
      {20, 20},
      {39.99f, 80},
      {80, 50},
  };
  canvas->drawPath(PathBuilder::Polygon(pts, false, FillRule::nonZero), paint);
  canvas->restore();
}

// Fish test (intersection/concave)
void test_fish(Renderer* canvas, const Paint& paint)
{
  canvas->save();
  canvas->translate(0, 100);
  canvas->drawPath(
      PathBuilder::Polygon(
          {{20, 20}, {80, 80}, {70, 50}, {80, 20}, {20, 80}, {0, 50}},
          false,
          FillRule::nonZero),
      paint);
  canvas->restore();
}

// Overlapping "Fast-forward" icon: tests coincidence of inner and outer
// vertices generated by intersection.
void test_fast_forward(Renderer* canvas, const Paint& paint)
{
  canvas->save();
  canvas->translate(100, 100);
  auto path = PathBuilder()
                  .addPolygon({{20, 20}, {60, 50}, {20, 80}}, false)
                  .addPolygon({{40, 20}, {40, 80}, {80, 50}}, false)
                  .detach();
  canvas->drawPath(path, paint);
  canvas->restore();
}

// Square polygon with a square hole.
void test_hole(Renderer* canvas, const Paint& paint)
{
  canvas->save();
  canvas->translate(200, 100);
  auto path = PathBuilder()
                  .addPolygon({{20, 20}, {80, 20}, {80, 80}, {20, 80}}, false)
                  .addPolygon({{30, 30}, {30, 70}, {70, 70}, {70, 30}}, false)
                  .detach();
  canvas->drawPath(path, paint);
  canvas->restore();
}

// Star test (self-intersecting)
void test_star(Renderer* canvas, const Paint& paint)
{
  canvas->save();
  canvas->translate(300, 100);
  canvas->drawPath(
      PathBuilder::Polygon(
          {{30, 20}, {50, 80}, {70, 20}, {20, 57}, {80, 57}},
          false),
      paint);
  canvas->restore();
}

// Exercise a case where the intersection is below a bottom edge.
void test_twist(Renderer* canvas, const Paint& paint)
{
  canvas->save();
  canvas->translate(420, 220);
  canvas->scale(10, 10);
  const std::vector<Vec2D> pts = {
      {0.5f, 6},
      {5.8070392608642578125f, 6.4612660408020019531f},
      {-2.9186885356903076172f, 2.811046600341796875f},
      {0.49999994039535522461f, -1.4124038219451904297f},
  };
  canvas->drawPath(PathBuilder::Polygon(pts, false), paint);
  canvas->restore();
}

// Stairstep with repeated vert (intersection)
void test_stairstep(Renderer* canvas, const Paint& paint)
{
  canvas->save();
  canvas->translate(0, 200);
  canvas->drawPath(
      PathBuilder::Polygon(
          {{50, 50}, {50, 20}, {80, 20}, {50, 50}, {20, 50}, {20, 80}},
          false),
      paint);
  canvas->restore();
}

void test_stairstep2(Renderer* canvas, const Paint& paint)
{
  canvas->save();
  canvas->translate(100, 200);
  canvas->drawPath(
      PathBuilder::Polygon(
          {{20, 60}, {35, 80}, {50, 60}, {65, 80}, {80, 60}},
          false),
      paint);
  canvas->restore();
}

// Overlapping segments
void test_overlapping(Renderer* canvas, const Paint& paint)
{
  canvas->save();
  canvas->translate(200, 200);
  canvas->drawPath(
      PathBuilder::Polygon({{20, 80}, {80, 80}, {80, 20}, {80, 30}}, false),
      paint);
  canvas->restore();
}

// Two "island" triangles inside a containing rect.
// This exercises the partnering code in the tessellator.
void test_partners(Renderer* canvas, const Paint& paint)
{
  canvas->save();
  canvas->translate(300, 200);
  auto path = PathBuilder()
                  .addPolygon({{20, 80}, {80, 80}, {80, 20}, {20, 20}}, false)
                  .addPolygon({{30, 30}, {45, 50}, {30, 70}}, false)
                  .addPolygon({{70, 30}, {70, 70}, {55, 50}}, false)
                  .detach();
  canvas->drawPath(path, paint);
  canvas->restore();
}

// A split edge causes one half to be merged to zero winding (destroyed).
// Test that the other half of the split doesn't also get zero winding.
void test_winding_merged_to_zero(Renderer* canvas, const Paint& paint)
{
  PathBuilder path;
  canvas->save();
  canvas->translate(400, 350);
  path.moveTo(20, 80);
  path.moveTo(70, -0.000001f);
  path.lineTo(70, 0.0);
  path.lineTo(60, -30.0);
  path.lineTo(40, 20.0);
  path.moveTo(50, 50.0);
  path.lineTo(50, -50.0);
  path.lineTo(10, 50.0);
  canvas->drawPath(path.detach(), paint);
  canvas->restore();
}

// Monotone test 1 (point in the middle)
void test_monotone_1(Renderer* canvas, const Paint& paint)
{
  PathBuilder path;
  canvas->save();
  canvas->translate(0, 300);
  path.moveTo(20, 20);
  path.quadTo(20, 50, 80, 50);
  path.quadTo(20, 50, 20, 80);
  canvas->drawPath(path.detach(), paint);
  canvas->restore();
}

// Monotone test 2 (point at the top)
void test_monotone_2(Renderer* canvas, const Paint& paint)
{
  PathBuilder path;
  canvas->save();
  canvas->translate(100, 300);
  path.moveTo(20, 20);
  path.lineTo(80, 30);
  path.quadTo(20, 20, 20, 80);
  canvas->drawPath(path.detach(), paint);
  canvas->restore();
}

// Monotone test 3 (point at the bottom)
void test_monotone_3(Renderer* canvas, const Paint& paint)
{
  PathBuilder path;
  canvas->save();
  canvas->translate(200, 300);
  path.moveTo(20, 80);
  path.lineTo(80, 70);
  path.quadTo(20, 80, 20, 20);
  canvas->drawPath(path.detach(), paint);
  canvas->restore();
}

// Monotone test 4 (merging of two monotones)
void test_monotone_4(Renderer* canvas, const Paint& paint)
{
  PathBuilder path;
  canvas->save();
  canvas->translate(300, 300);
  path.moveTo(80, 25);
  path.lineTo(50, 39);
  path.lineTo(20, 25);
  path.lineTo(40, 45);
  path.lineTo(70, 50);
  path.lineTo(80, 80);
  canvas->drawPath(path.detach(), paint);
  canvas->restore();
}

// Monotone test 5 (aborted merging of two monotones)
void test_monotone_5(Renderer* canvas, const Paint& paint)
{
  PathBuilder path;
  canvas->save();
  canvas->translate(0, 400);
  path.moveTo(50, 20);
  path.lineTo(80, 80);
  path.lineTo(50, 50);
  path.lineTo(20, 80);
  canvas->drawPath(path.detach(), paint);
  canvas->restore();
}
// Degenerate intersection test
void test_degenerate(Renderer* canvas, const Paint& paint)
{
  PathBuilder path;
  canvas->save();
  canvas->translate(100, 400);
  path.moveTo(50, 20);
  path.lineTo(70, 30);
  path.lineTo(20, 50);
  path.moveTo(50, 20);
  path.lineTo(80, 80);
  path.lineTo(50, 80);
  canvas->drawPath(path.detach(), paint);
  canvas->restore();
}
// Two triangles with a coincident edge.
void test_coincident_edge(Renderer* canvas, const Paint& paint)
{
  PathBuilder path;
  canvas->save();
  canvas->translate(200, 400);

  path.moveTo(80, 20);
  path.lineTo(80, 80);
  path.lineTo(20, 80);

  path.moveTo(20, 20);
  path.lineTo(80, 80);
  path.lineTo(20, 80);

  canvas->drawPath(path.detach(), paint);
  canvas->restore();
}
// Bowtie with a coincident triangle (one triangle vertex coincident with the
// bowtie's intersection).
void test_bowtie_coincident_triangle(Renderer* canvas, const Paint& paint)
{
  PathBuilder path;
  canvas->save();
  canvas->translate(300, 400);
  path.moveTo(20, 20);
  path.lineTo(80, 80);
  path.lineTo(80, 20);
  path.lineTo(20, 80);
  path.moveTo(50, 50);
  path.lineTo(80, 20);
  path.lineTo(80, 80);
  canvas->drawPath(path.detach(), paint);
  canvas->restore();
}

// Collinear outer boundary edges. In the edge-AA codepath, this creates an
// overlap region which contains a boundary edge. It can't be removed, but it
// must have the correct winding.
void test_collinear_outer_boundary_edge(Renderer* canvas, const Paint& paint)
{
  PathBuilder path;
  canvas->save();
  canvas->translate(400, 400);
  path.moveTo(20, 20);
  path.lineTo(20, 50);
  path.lineTo(50, 50);
  path.moveTo(80, 50);
  path.lineTo(50, 50);
  path.lineTo(80, 20);
  canvas->drawPath(path.detach(), paint);
  canvas->restore();
}

// Coincident edges (big ones first, coincident vert on top).
void test_coincident_edges_1(Renderer* canvas, const Paint& paint)
{
  PathBuilder path;
  canvas->save();
  canvas->translate(0, 500);
  path.moveTo(20, 20);
  path.lineTo(80, 80);
  path.lineTo(20, 80);
  path.moveTo(20, 20);
  path.lineTo(50, 50);
  path.lineTo(20, 50);
  canvas->drawPath(path.detach(), paint);
  canvas->restore();
}
// Coincident edges (small ones first, coincident vert on top).
void test_coincident_edges_2(Renderer* canvas, const Paint& paint)
{
  PathBuilder path;
  canvas->save();
  canvas->translate(100, 500);
  path.moveTo(20, 20);
  path.lineTo(50, 50);
  path.lineTo(20, 50);
  path.moveTo(20, 20);
  path.lineTo(80, 80);
  path.lineTo(20, 80);
  canvas->drawPath(path.detach(), paint);
  canvas->restore();
}
// Coincident edges (small ones first, coincident vert on bottom).
void test_coincident_edges_3(Renderer* canvas, const Paint& paint)
{
  PathBuilder path;
  canvas->save();
  canvas->translate(200, 500);
  path.moveTo(20, 80);
  path.lineTo(20, 50);
  path.lineTo(50, 50);
  path.moveTo(20, 80);
  path.lineTo(20, 20);
  path.lineTo(80, 20);
  canvas->drawPath(path.detach(), paint);
  canvas->restore();
}
// Coincident edges (big ones first, coincident vert on bottom).
void test_coincident_edges_4(Renderer* canvas, const Paint& paint)
{
  PathBuilder path;
  canvas->save();
  canvas->translate(300, 500);
  path.moveTo(20, 80);
  path.lineTo(20, 20);
  path.lineTo(80, 20);
  path.moveTo(20, 80);
  path.lineTo(20, 50);
  path.lineTo(50, 50);
  canvas->drawPath(path.detach(), paint);
  canvas->restore();
}

} // namespace

DEF_SIMPLE_GM(concavepaths, 500, 600, canvas)
{
  Paint paint;
  paint->style(RenderPaintStyle::fill);

  test_concave(canvas, paint);
  test_reverse_concave(canvas, paint);
  test_bowtie(canvas, paint);
  test_fake_bowtie(canvas, paint);
  test_intruding_vertex(canvas, paint);
  test_fish(canvas, paint);
  test_fast_forward(canvas, paint);
  test_hole(canvas, paint);
  test_star(canvas, paint);
  test_twist(canvas, paint);
  test_inversion_repeat_vertex(canvas, paint);
  test_stairstep(canvas, paint);
  test_stairstep2(canvas, paint);
  test_overlapping(canvas, paint);
  test_partners(canvas, paint);
  test_winding_merged_to_zero(canvas, paint);
  test_monotone_1(canvas, paint);
  test_monotone_2(canvas, paint);
  test_monotone_3(canvas, paint);
  test_monotone_4(canvas, paint);
  test_monotone_5(canvas, paint);
  test_degenerate(canvas, paint);
  test_coincident_edge(canvas, paint);
  test_bowtie_coincident_triangle(canvas, paint);
  test_collinear_outer_boundary_edge(canvas, paint);
  test_coincident_edges_1(canvas, paint);
  test_coincident_edges_2(canvas, paint);
  test_coincident_edges_3(canvas, paint);
  test_coincident_edges_4(canvas, paint);
}