/*
 * Copyright 2021 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/SkBlendMode.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkImageFilter.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPathEffect.h"
#include "include/core/SkRect.h"
#include "include/core/SkSurface.h"
#include "include/effects/SkDashPathEffect.h"
#include "include/effects/SkGradient.h"
#include "include/effects/SkImageFilters.h"
#include "tools/GpuToolUtils.h"
#include "tools/Resources.h"
#include "tools/ToolUtils.h"


namespace {

static constexpr SkColor kOutputBoundsColor  = SK_ColorRED;
static constexpr SkColor kCropRectColor      = SK_ColorGREEN;
static constexpr SkColor kContentBoundsColor = SK_ColorBLUE;

static constexpr SkRect kExampleBounds = {0.f, 0.f, 100.f, 100.f};

// "Crop" refers to the rect passed to the crop image filter, "Rect" refers to some other rect
// from context, likely the output bounds or the content bounds.
enum class CropRelation {
    kCropOverlapsRect, // Intersect but doesn't fully contain one way or the other
    kCropContainsRect,
    kRectContainsCrop,
    kCropRectDisjoint,
};

SkRect make_overlap(const SkRect& r, float amountX, float amountY) {
    return r.makeOffset(r.width() * amountX, r.height() * amountY);
}

SkRect make_inset(const SkRect& r, float amountX, float amountY) {
    return r.makeInset(r.width() * amountX, r.height() * amountY);
}

SkRect make_outset(const SkRect& r, float amountX, float amountY) {
    return r.makeOutset(r.width() * amountX, r.height() * amountY);
}

SkRect make_disjoint(const SkRect& r, float amountX, float amountY) {
    float xOffset = (amountX > 0.f ? (r.width() + r.width() * amountX) :
                    (amountX < 0.f ? (-r.width() + r.width() * amountX) : 0.f));
    float yOffset = (amountY > 0.f ? (r.height() + r.height() * amountY) :
                    (amountY < 0.f ? (-r.height() + r.height() * amountY) : 0.f));
    return r.makeOffset(xOffset, yOffset);
}

void get_example_rects(CropRelation outputRelation, CropRelation inputRelation, bool hintContent,
                       SkRect* outputBounds, SkRect* cropRect, SkRect* contentBounds) {
    *outputBounds = kExampleBounds.makeInset(20.f, 20.f);
    switch(outputRelation) {
        case CropRelation::kCropOverlapsRect:
            *cropRect = make_overlap(*outputBounds, -0.15f, 0.15f);
            SkASSERT(cropRect->intersects(*outputBounds) &&
                     !cropRect->contains(*outputBounds) &&
                     !outputBounds->contains(*cropRect));
            break;
        case CropRelation::kCropContainsRect:
            *cropRect = make_outset(*outputBounds, 0.15f, 0.15f);
            SkASSERT(cropRect->contains(*outputBounds));
            break;
        case CropRelation::kRectContainsCrop:
            *cropRect = make_inset(*outputBounds, 0.15f, 0.15f);
            SkASSERT(outputBounds->contains(*cropRect));
            break;
        case CropRelation::kCropRectDisjoint:
            *cropRect = make_disjoint(*outputBounds, 0.15f, 0.0f);
            SkASSERT(!cropRect->intersects(*outputBounds));
            break;
    }

    SkAssertResult(cropRect->intersect(kExampleBounds));

    // Determine content bounds for example based on computed crop rect and input relation
    if (hintContent) {
        switch(inputRelation) {
            case CropRelation::kCropOverlapsRect:
                *contentBounds = make_overlap(*cropRect, 0.075f, -0.75f);
                SkASSERT(contentBounds->intersects(*cropRect) &&
                        !contentBounds->contains(*cropRect) &&
                        !cropRect->contains(*contentBounds));
                break;
            case CropRelation::kCropContainsRect:
                *contentBounds = make_inset(*cropRect, 0.075f, 0.075f);
                SkASSERT(cropRect->contains(*contentBounds));
                break;
            case CropRelation::kRectContainsCrop:
                *contentBounds = make_outset(*cropRect, 0.1f, 0.1f);
                SkASSERT(contentBounds->contains(*cropRect));
                break;
            case CropRelation::kCropRectDisjoint:
                *contentBounds = make_disjoint(*cropRect, 0.0f, 0.075f);
                SkASSERT(!contentBounds->intersects(*cropRect));
                break;
        }

        SkAssertResult(contentBounds->intersect(kExampleBounds));
    } else {
        *contentBounds = kExampleBounds;
    }
}

// TODO(michaelludwig) - This is a useful test pattern for tile modes and filtering; should
// consolidate it with the similar version in gpu_blur_utils if the GMs remain separate at the end.
sk_sp<SkImage> make_image(SkCanvas* canvas, const SkRect* contentBounds) {
    const float w = kExampleBounds.width();
    const float h = kExampleBounds.height();

    const auto srcII = SkImageInfo::Make(SkISize::Make(SkScalarCeilToInt(w), SkScalarCeilToInt(h)),
                                         kN32_SkColorType, kPremul_SkAlphaType);
    auto surf = SkSurfaces::Raster(srcII);

    surf->getCanvas()->drawColor(SK_ColorDKGRAY);
    SkPaint paint;
    paint.setAntiAlias(true);
    paint.setStyle(SkPaint::kStroke_Style);
    // Draw four horizontal lines at 1/4, 3/8, 5/8, 3/4.
    paint.setStrokeWidth(h/16.f);
    paint.setColor(SK_ColorRED);
    surf->getCanvas()->drawLine({0.f, 1.f*h/4.f}, {w, 1.f*h/4.f}, paint);
    paint.setColor(/* sea foam */ 0xFF71EEB8);
    surf->getCanvas()->drawLine({0.f, 3.f*h/8.f}, {w, 3.f*h/8.f}, paint);
    paint.setColor(SK_ColorYELLOW);
    surf->getCanvas()->drawLine({0.f, 5.f*h/8.f}, {w, 5.f*h/8.f}, paint);
    paint.setColor(SK_ColorCYAN);
    surf->getCanvas()->drawLine({0.f, 3.f*h/4.f}, {w, 3.f*h/4.f}, paint);

    // Draw four vertical lines at 1/4, 3/8, 5/8, 3/4.
    paint.setStrokeWidth(w/16.f);
    paint.setColor(/* orange */ 0xFFFFA500);
    surf->getCanvas()->drawLine({1.f*w/4.f, 0.f}, {1.f*h/4.f, h}, paint);
    paint.setColor(SK_ColorBLUE);
    surf->getCanvas()->drawLine({3.f*w/8.f, 0.f}, {3.f*h/8.f, h}, paint);
    paint.setColor(SK_ColorMAGENTA);
    surf->getCanvas()->drawLine({5.f*w/8.f, 0.f}, {5.f*h/8.f, h}, paint);
    paint.setColor(SK_ColorGREEN);
    surf->getCanvas()->drawLine({3.f*w/4.f, 0.f}, {3.f*h/4.f, h}, paint);

    // Fill everything outside of the content bounds with red since it shouldn't be sampled from.
    if (contentBounds) {
        SkRect buffer = contentBounds->makeOutset(1.f, 1.f);
        surf->getCanvas()->clipRect(buffer, SkClipOp::kDifference);
        surf->getCanvas()->clear(SK_ColorRED);
    }

    return surf->makeImageSnapshot();
}

// Subset 'image' to contentBounds, apply 'contentTile' mode to fill 'cropRect'-sized image.
sk_sp<SkImage> make_cropped_image(sk_sp<SkImage> image,
                                  const SkRect& contentBounds,
                                  SkTileMode contentTile,
                                  const SkRect& cropRect) {
    auto surface = SkSurfaces::Raster(
            image->imageInfo().makeWH(SkScalarCeilToInt(cropRect.width()),
                                      SkScalarCeilToInt(cropRect.height())));
    auto content = image->makeSubset(
            nullptr,
            contentTile == SkTileMode::kDecal ? contentBounds.roundOut() : contentBounds.roundIn(),
            {});
    if (!content || !surface) {
        return nullptr;
    }
    SkPaint tiledContent;
    tiledContent.setShader(content->makeShader(contentTile, contentTile,
                                               SkFilterMode::kNearest,
                                               SkMatrix::Translate(contentBounds.left(),
                                                                   contentBounds.top())));
    surface->getCanvas()->translate(-cropRect.left(), -cropRect.top());
    surface->getCanvas()->drawPaint(tiledContent);
    return surface->makeImageSnapshot();
}

void draw_example_tile(
        SkCanvas* canvas,
        SkTileMode inputMode,         // the tile mode applied to content bounds
        CropRelation inputRelation,   // how crop rect relates to content bounds
        bool hintContent,             // whether or not contentBounds is hinted to saveLayer()
        SkTileMode outputMode,        // the tile mode applied to the crop rect output
        CropRelation outputRelation) {// how crop rect relates to output bounds (clip pre-saveLayer)

    // Determine crop rect for example based on output relation
    SkRect outputBounds, cropRect, contentBounds;
    get_example_rects(outputRelation, inputRelation, hintContent,
                      &outputBounds, &cropRect, &contentBounds);
    SkASSERT(kExampleBounds.contains(outputBounds) &&
             kExampleBounds.contains(cropRect) &&
             kExampleBounds.contains(contentBounds));

    auto image = make_image(canvas, hintContent ? &contentBounds : nullptr);

    canvas->save();
    // Visualize the image tiled on the content bounds (blue border) and then tiled on the crop
    // rect (green) border, semi-transparent
    {
        auto cropImage = ToolUtils::MakeTextureImage(
                canvas, make_cropped_image(image, contentBounds, inputMode, cropRect));
        if (cropImage) {
            SkPaint tiledPaint;
            tiledPaint.setShader(cropImage->makeShader(outputMode, outputMode,
                                                       SkFilterMode::kNearest,
                                                       SkMatrix::Translate(cropRect.left(),
                                                                           cropRect.top())));
            tiledPaint.setAlphaf(0.25f);

            canvas->save();
            canvas->clipRect(kExampleBounds);
            canvas->drawPaint(tiledPaint);
            canvas->restore();
        }
    }

    // Build filter, clip, save layer, draw, restore - the interesting part is in the tile modes
    // and how the various bounds intersect each other.
    {
        sk_sp<SkImageFilter> filter = SkImageFilters::Crop(contentBounds, inputMode, nullptr);
        filter = SkImageFilters::Blur(4.f, 4.f, std::move(filter));
        filter = SkImageFilters::Crop(cropRect, outputMode, std::move(filter));
        SkPaint layerPaint;
        layerPaint.setImageFilter(std::move(filter));

        canvas->save();
        canvas->clipRect(outputBounds);
        canvas->saveLayer(hintContent ? &contentBounds : nullptr, &layerPaint);

        auto tmp = ToolUtils::MakeTextureImage(canvas, image);
        canvas->drawImageRect(tmp, contentBounds, contentBounds,
                              SkSamplingOptions(SkFilterMode::kNearest), nullptr,
                              SkCanvas::kStrict_SrcRectConstraint);
        canvas->restore();
        canvas->restore();
    }

    // Visualize bounds after the actual rendering.
    {
        SkPaint border;
        border.setStyle(SkPaint::kStroke_Style);

        border.setColor(kOutputBoundsColor);
        canvas->drawRect(outputBounds, border);

        border.setColor(kCropRectColor);
        canvas->drawRect(cropRect, border);

        if (hintContent) {
            border.setColor(kContentBoundsColor);
            canvas->drawRect(contentBounds, border);
        }
    }

    canvas->restore();
}

// Draw 5 example tiles in a column for 5 relationships between content bounds and crop rect:
// no content hint, intersect, content contains crop, crop contains content, and no intersection
void draw_example_column(
        SkCanvas* canvas,
        SkTileMode inputMode,
        SkTileMode outputMode,
        CropRelation outputRelation) {
    const std::pair<CropRelation, bool> inputRelations[5] = {
            { CropRelation::kCropOverlapsRect, false },
            { CropRelation::kCropOverlapsRect, true },
            { CropRelation::kCropContainsRect, true },
            { CropRelation::kRectContainsCrop, true },
            { CropRelation::kCropRectDisjoint, true }
        };

    canvas->save();
    for (auto [inputRelation, hintContent] : inputRelations) {
        draw_example_tile(canvas, inputMode, inputRelation, hintContent,
                          outputMode, outputRelation);
        canvas->translate(0.f, kExampleBounds.fBottom + 1.f);
    }

    canvas->restore();
}

// Draw 5x4 grid of examples covering supported input tile modes and crop rect relations
static constexpr int kNumRows = 5;
static constexpr int kNumCols = 4;
static constexpr float kGridWidth = kNumCols * (kExampleBounds.fRight+1.f) - 1.f;
static constexpr float kGridHeight = kNumRows * (kExampleBounds.fBottom+1.f) - 1.f;

void draw_example_grid(
        SkCanvas* canvas,
        SkTileMode inputMode,
        SkTileMode outputMode) {
    canvas->save();
    for (auto outputRelation : { CropRelation::kCropOverlapsRect,
                                 CropRelation::kCropContainsRect,
                                 CropRelation::kRectContainsCrop,
                                 CropRelation::kCropRectDisjoint }) {
        draw_example_column(canvas, inputMode, outputMode, outputRelation);
        canvas->translate(kExampleBounds.fRight + 1.f, 0.f);
    }
    canvas->restore();

    // Draw dashed lines between rows and columns
    SkPaint dashedLine;
    dashedLine.setColor(SK_ColorGRAY);
    dashedLine.setStyle(SkPaint::kStroke_Style);
    dashedLine.setStrokeCap(SkPaint::kSquare_Cap);
    static const float kDashes[2] = {5.f, 15.f};
    dashedLine.setPathEffect(SkDashPathEffect::Make(kDashes, 0.f));

    for (int y = 1; y < kNumRows; ++y) {
        canvas->drawLine({0.5f, y * (kExampleBounds.fBottom+1.f) - 0.5f},
                         {kGridWidth - 0.5f, y * (kExampleBounds.fBottom+1.f) - 0.5f},
                         dashedLine);
    }
    for (int x = 1; x < kNumCols; ++x) {
        canvas->drawLine({x * (kExampleBounds.fRight+1.f) - 0.5f, 0.5f},
                         {x * (kExampleBounds.fRight+1.f) - 0.5f, kGridHeight - 0.5f},
                         dashedLine);
    }
}

}  // namespace

namespace skiagm {

class CropImageFilterGM : public GM {
public:
    CropImageFilterGM(SkTileMode inputMode, SkTileMode outputMode)
            : fInputMode(inputMode)
            , fOutputMode(outputMode) {}

protected:
    SkISize getISize() override {
        return {SkScalarRoundToInt(4.f * (kExampleBounds.fRight + 1.f) - 1.f),
                SkScalarRoundToInt(5.f * (kExampleBounds.fBottom + 1.f) - 1.f)};
    }
    SkString getName() const override {
        SkString name("crop_imagefilter_");
        switch(fInputMode) {
            case SkTileMode::kDecal:  name.append("decal");  break;
            case SkTileMode::kClamp:  name.append("clamp");  break;
            case SkTileMode::kRepeat: name.append("repeat"); break;
            case SkTileMode::kMirror: name.append("mirror"); break;
        }
        name.append("-in_");

        switch (fOutputMode) {
            case SkTileMode::kDecal:  name.append("decal");  break;
            case SkTileMode::kClamp:  name.append("clamp");  break;
            case SkTileMode::kRepeat: name.append("repeat"); break;
            case SkTileMode::kMirror: name.append("mirror"); break;
        }
        name.append("-out");
        return name;
    }

    void onDraw(SkCanvas* canvas) override {
        draw_example_grid(canvas, fInputMode, fOutputMode);
    }

private:
    SkTileMode fInputMode;
    SkTileMode fOutputMode;
};

DEF_GM( return new CropImageFilterGM(SkTileMode::kDecal, SkTileMode::kDecal); )
DEF_GM( return new CropImageFilterGM(SkTileMode::kDecal, SkTileMode::kClamp); )
DEF_GM( return new CropImageFilterGM(SkTileMode::kDecal, SkTileMode::kRepeat); )
DEF_GM( return new CropImageFilterGM(SkTileMode::kDecal, SkTileMode::kMirror); )

DEF_GM( return new CropImageFilterGM(SkTileMode::kClamp, SkTileMode::kDecal); )
DEF_GM( return new CropImageFilterGM(SkTileMode::kClamp, SkTileMode::kClamp); )
DEF_GM( return new CropImageFilterGM(SkTileMode::kClamp, SkTileMode::kRepeat); )
DEF_GM( return new CropImageFilterGM(SkTileMode::kClamp, SkTileMode::kMirror); )

DEF_GM( return new CropImageFilterGM(SkTileMode::kRepeat, SkTileMode::kDecal); )
DEF_GM( return new CropImageFilterGM(SkTileMode::kRepeat, SkTileMode::kClamp); )
DEF_GM( return new CropImageFilterGM(SkTileMode::kRepeat, SkTileMode::kRepeat); )
DEF_GM( return new CropImageFilterGM(SkTileMode::kRepeat, SkTileMode::kMirror); )

DEF_GM( return new CropImageFilterGM(SkTileMode::kMirror, SkTileMode::kDecal); )
DEF_GM( return new CropImageFilterGM(SkTileMode::kMirror, SkTileMode::kClamp); )
DEF_GM( return new CropImageFilterGM(SkTileMode::kMirror, SkTileMode::kRepeat); )
DEF_GM( return new CropImageFilterGM(SkTileMode::kMirror, SkTileMode::kMirror); )

}  // namespace skiagm
