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

#include "gm/gm.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPath.h"
#include "include/core/SkPathBuilder.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
#include "include/core/SkTypes.h"
#include "src/core/SkGeometry.h"
#include "src/core/SkRandom.h"

#include <array>
#include <limits>

static constexpr float kStrokeWidth = 30;
static constexpr int kCellSize = 200;
static constexpr int kNumCols = 5;
static constexpr int kNumRows = 5;
static constexpr int kTestWidth = kNumCols * kCellSize;
static constexpr int kTestHeight = kNumRows * kCellSize;

enum class CellFillMode {
    kStretch,
    kCenter
};

struct TrickyCubic {
    SkPoint fPoints[4];
    CellFillMode fFillMode;
    // Entries with 3 points are quads/conics: fPoints[3].fX holds the conic weight (1 == quad)
    // and fPoints[3].fY is unused.
    int fNumPts = 4;
    float fScale = 1;
};

static constexpr CellFillMode kStretch = CellFillMode::kStretch;
static constexpr CellFillMode kCenter = CellFillMode::kCenter;
static constexpr float kNaN = std::numeric_limits<float>::quiet_NaN();

// This is a compilation of cubics that have given strokers grief. Feel free to add more.
// clang-format off
static const auto kTrickyCubics = std::to_array<TrickyCubic>({
        TrickyCubic{{{122, 737}, {348, 553}, {403, 761}, {400, 760}},           kStretch},
        TrickyCubic{{{244, 520}, {244, 518}, {1141, 634}, {394, 688}},          kStretch},
        TrickyCubic{{{550, 194}, {138, 130}, {1035, 246}, {288, 300}},          kStretch},
        TrickyCubic{{{226, 733}, {556, 779}, {-43, 471}, {348, 683}},           kStretch},
        TrickyCubic{{{268, 204}, {492, 304}, {352, 23}, {433, 412}},            kStretch},
        TrickyCubic{{{172, 480}, {396, 580}, {256, 299}, {338, 677}},           kStretch},
        TrickyCubic{{{731, 340}, {318, 252}, {1026, -64}, {367, 265}},          kStretch},
        TrickyCubic{{{475, 708}, {62, 620}, {770, 304}, {220, 659}},            kStretch},
        // Perfect cusp
        TrickyCubic{{{0, 0}, {128, 128}, {128, 0}, {0, 128}},                   kCenter},
        // Near-cusp
        TrickyCubic{{{0, .01f}, {128, 127.999f}, {128, .01f}, {0, 127.99f}},    kCenter},
        // Near-cusp
        TrickyCubic{{{0, -.01f}, {128, 128.001f}, {128, -.01f}, {0, 128.001f}}, kCenter},
        // Flat line with 180
        TrickyCubic{{{0, 0}, {0, -10}, {0, -10}, {0, 10}},                      kCenter, 4,
                    1.098283f},
        // Flat line with 2 180s
        TrickyCubic{{{10, 0}, {0, 0}, {20, 0}, {10, 0}},                        kStretch},
        // Flat diagonal with 180
        TrickyCubic{{{39, -39}, {40, -40}, {40, -40}, {0, 0}},                  kStretch},
        // Near-flat diagonal
        TrickyCubic{{{39, -39}, {40, -40}, {37, -39}, {0, 0}},                  kStretch},
        // Diag w/ an internal 180
        TrickyCubic{{{40, 40}, {0, 0}, {200, 200}, {0, 0}},                     kStretch},
        // Circle
        TrickyCubic{{{0, 0}, {1e-2f, 0}, {-1e-2f, 0}, {0, 0}},                  kCenter},
        // Flat line with no turns
        TrickyCubic{{{400.75f, 100.05f}, {400.75f, 100.05f}, {100.05f, 300.95f},
                     {100.05f, 300.95f}},                                       kStretch},
        // Flat line with 2 180s
        TrickyCubic{{{0.5f, 0}, {0, 0}, {20, 0}, {10, 0}},                      kStretch},
        // Flat line with a 180
        TrickyCubic{{{10, 0}, {0, 0}, {10, 0}, {10, 0}},                        kStretch},
        // Flat QUAD with a cusp
        TrickyCubic{{{1, 1}, {2, 1}, {1, 1}, {1, kNaN}},                        kStretch, 3},
        // Flat CONIC with a cusp
        TrickyCubic{{{1, 1}, {100, 1}, {25, 1}, {.3f, kNaN}},                   kStretch, 3},
        // Flat CONIC with a cusp
        TrickyCubic{{{1, 1}, {100, 1}, {25, 1}, {1.5f, kNaN}},                  kStretch, 3},
});
// clang-format on

static SkRect calc_tight_cubic_bounds(const SkPoint P[4], int depth=5) {
    if (0 == depth) {
        SkRect bounds;
        bounds.fLeft = std::min(std::min(P[0].x(), P[1].x()), std::min(P[2].x(), P[3].x()));
        bounds.fTop = std::min(std::min(P[0].y(), P[1].y()), std::min(P[2].y(), P[3].y()));
        bounds.fRight = std::max(std::max(P[0].x(), P[1].x()), std::max(P[2].x(), P[3].x()));
        bounds.fBottom = std::max(std::max(P[0].y(), P[1].y()), std::max(P[2].y(), P[3].y()));
        return bounds;
    }

    SkPoint chopped[7];
    SkChopCubicAt(P, chopped, .5f);
    SkRect bounds = calc_tight_cubic_bounds(chopped, depth - 1);
    bounds.join(calc_tight_cubic_bounds(chopped+3, depth - 1));
    return bounds;
}

static SkPoint lerp(const SkPoint& a, const SkPoint& b, float T) {
    SkASSERT(1 != T);  // The below does not guarantee lerp(a, b, 1) === b.
    return (b - a) * T + a;
}

enum class FillMode {
    kCenter,
    kScale
};

static void draw_test(SkCanvas* canvas, SkPaint::Cap cap, SkPaint::Join join) {
    SkRandom rand;

    canvas->clear(SK_ColorBLACK);

    SkPaint strokePaint;
    strokePaint.setAntiAlias(true);
    strokePaint.setStrokeWidth(kStrokeWidth);
    strokePaint.setStyle(SkPaint::kStroke_Style);
    strokePaint.setStrokeCap(cap);
    strokePaint.setStrokeJoin(join);

    for (size_t i = 0; i < std::size(kTrickyCubics); ++i) {
        auto [originalPts, fillMode, numPts, scale] = kTrickyCubics[i];

        SkASSERT(numPts <= 4);
        SkPoint p[4];
        memcpy(p, originalPts, sizeof(SkPoint) * numPts);
        for (int j = 0; j < numPts; ++j) {
            p[j] *= scale;
        }
        float w = originalPts[3].fX;

        auto cellRect = SkRect::MakeXYWH((i % kNumCols) * kCellSize, (i / kNumCols) * kCellSize,
                                         kCellSize, kCellSize);

        SkRect strokeBounds;
        if (numPts == 4) {
            strokeBounds = calc_tight_cubic_bounds(p);
        } else {
            SkASSERT(numPts == 3);
            SkPoint asCubic[4] = {p[0], lerp(p[0], p[1], 2/3.f), lerp(p[1], p[2], 1/3.f), p[2]};
            strokeBounds = calc_tight_cubic_bounds(asCubic);
        }
        strokeBounds.outset(kStrokeWidth, kStrokeWidth);

        SkMatrix matrix = (fillMode == CellFillMode::kStretch) ?
            SkMatrix::RectToRectOrIdentity(strokeBounds, cellRect, SkMatrix::kCenter_ScaleToFit) :
            SkMatrix::Translate(cellRect.x() + kStrokeWidth +
                                (cellRect.width() - strokeBounds.width()) / 2,
                                cellRect.y() + kStrokeWidth +
                                (cellRect.height() - strokeBounds.height()) / 2);

        SkAutoCanvasRestore acr(canvas, true);
        canvas->concat(matrix);
        strokePaint.setStrokeWidth(kStrokeWidth / matrix.getMaxScale());
        strokePaint.setColor(rand.nextU() | 0xff808080);
        SkPathBuilder builder;
        builder.moveTo(p[0]);
        if (numPts == 4) {
            builder.cubicTo(p[1], p[2], p[3]);
        } else if (w == 1) {
            SkASSERT(numPts == 3);
            builder.quadTo(p[1], p[2]);
        } else {
            SkASSERT(numPts == 3);
            builder.conicTo(p[1], p[2], w);
        }
        canvas->drawPath(builder.detach(), strokePaint);
    }
}

DEF_SIMPLE_GM(trickycubicstrokes, canvas, kTestWidth, kTestHeight) {
    draw_test(canvas, SkPaint::kButt_Cap, SkPaint::kMiter_Join);
}

DEF_SIMPLE_GM(trickycubicstrokes_roundcaps, canvas, kTestWidth, kTestHeight) {
    draw_test(canvas, SkPaint::kRound_Cap, SkPaint::kRound_Join);
}

// See b/433057370
DEF_SIMPLE_GM(trickycubicstrokes_largeradius, canvas, 128, 256) {
    SkPathBuilder b;

    // Starts as a line with a single tangent direction, with increasing curvature
    for (int y = 0; y < 2; ++y) {
        float shift = 210.f * y;
        float dy = 5.f * y;
        b.moveTo(159.429f, 149.808f + shift)
         .cubicTo({232.5f, 149.808f + dy + shift},
                  {232.5f, 149.808f + dy + shift},
                  {305.572f, 149.808f + shift});
    }

    // A large stroke width is required to show the cusp circle artifacts with
    // the tessellating path renderer
    SkPaint s;
    s.setStroke(true);
    s.setStrokeWidth(200.f);
    s.setAntiAlias(true);
    b.setFillType(SkPathFillType::kWinding);
    canvas->scale(0.5f, 0.5f);
    canvas->translate(-125.f, 0.f);
    canvas->drawPath(b.detach(), s);
}