// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "flutter/flow/layers/physical_shape_layer.h"

#include "flutter/flow/testing/diff_context_test.h"
#include "flutter/flow/testing/layer_test.h"
#include "flutter/flow/testing/mock_layer.h"
#include "flutter/fml/macros.h"
#include "flutter/testing/mock_canvas.h"

#include "third_party/skia/include/core/SkSurface.h"

namespace flutter {
namespace testing {

using PhysicalShapeLayerTest = LayerTest;

using ClipOp = DlCanvas::ClipOp;

#ifndef NDEBUG
TEST_F(PhysicalShapeLayerTest, PaintingEmptyLayerDies) {
  auto layer =
      std::make_shared<PhysicalShapeLayer>(DlColor::kBlack(), DlColor::kBlack(),
                                           0.0f,  // elevation
                                           SkPath(), Clip::none);

  layer->Preroll(preroll_context());
  EXPECT_EQ(layer->paint_bounds(), SkRect::MakeEmpty());
  EXPECT_EQ(layer->child_paint_bounds(), SkRect::MakeEmpty());
  EXPECT_FALSE(layer->needs_painting(paint_context()));

  EXPECT_DEATH_IF_SUPPORTED(layer->Paint(paint_context()),
                            "needs_painting\\(context\\)");
}

TEST_F(PhysicalShapeLayerTest, PaintBeforePrerollDies) {
  SkPath child_path;
  child_path.addRect(5.0f, 6.0f, 20.5f, 21.5f);
  auto mock_layer = std::make_shared<MockLayer>(child_path, DlPaint());
  auto layer =
      std::make_shared<PhysicalShapeLayer>(DlColor::kBlack(), DlColor::kBlack(),
                                           0.0f,  // elevation
                                           SkPath(), Clip::none);
  layer->Add(mock_layer);

  EXPECT_DEATH_IF_SUPPORTED(layer->Paint(paint_context()),
                            "needs_painting\\(context\\)");
}
#endif

TEST_F(PhysicalShapeLayerTest, NonEmptyLayer) {
  SkPath layer_path;
  layer_path.addRect(5.0f, 6.0f, 20.5f, 21.5f);
  auto layer =
      std::make_shared<PhysicalShapeLayer>(DlColor::kGreen(), DlColor::kBlack(),
                                           0.0f,  // elevation
                                           layer_path, Clip::none);
  layer->Preroll(preroll_context());
  EXPECT_EQ(layer->paint_bounds(), layer_path.getBounds());
  EXPECT_EQ(layer->child_paint_bounds(), SkRect::MakeEmpty());
  EXPECT_TRUE(layer->needs_painting(paint_context()));

  DlPaint layer_paint;
  layer_paint.setColor(DlColor::kGreen());
  layer_paint.setAntiAlias(true);
  layer->Paint(paint_context());
  EXPECT_EQ(mock_canvas().draw_calls(),
            std::vector({MockCanvas::DrawCall{
                0, MockCanvas::DrawPathData{layer_path, layer_paint}}}));
}

TEST_F(PhysicalShapeLayerTest, ChildrenLargerThanPathClip) {
  const SkRect layer_bounds = SkRect::MakeLTRB(5.0f, 6.0f, 20.5f, 21.5f);
  const SkRect child_bounds1 = SkRect::MakeLTRB(4, 0, 12, 12);
  const SkRect child_bounds2 = SkRect::MakeLTRB(3, 2, 5, 15);
  SkPath layer_path =
      SkPath().addRect(layer_bounds).addOval(layer_bounds.makeInset(0.1, 0.1));
  SkPath child1_path = SkPath()
                           .addRect(child_bounds1)
                           .addOval(child_bounds1.makeInset(0.1, 0.1));
  SkPath child2_path = SkPath()
                           .addRect(child_bounds2)
                           .addOval(child_bounds2.makeInset(0.1, 0.1));
  auto child1 =
      std::make_shared<PhysicalShapeLayer>(DlColor::kRed(), DlColor::kBlack(),
                                           0.0f,  // elevation
                                           child1_path, Clip::none);
  auto child2 =
      std::make_shared<PhysicalShapeLayer>(DlColor::kBlue(), DlColor::kBlack(),
                                           0.0f,  // elevation
                                           child2_path, Clip::none);
  auto layer =
      std::make_shared<PhysicalShapeLayer>(DlColor::kGreen(), DlColor::kBlack(),
                                           0.0f,  // elevation
                                           layer_path, Clip::hardEdge);
  layer->Add(child1);
  layer->Add(child2);

  SkRect child_paint_bounds = SkRect::MakeEmpty();
  layer->Preroll(preroll_context());
  child_paint_bounds.join(child1->paint_bounds());
  child_paint_bounds.join(child2->paint_bounds());
  EXPECT_EQ(layer->paint_bounds(), layer_path.getBounds());
  EXPECT_NE(layer->paint_bounds(), child_paint_bounds);
  EXPECT_EQ(layer->child_paint_bounds(), child_paint_bounds);
  EXPECT_TRUE(layer->needs_painting(paint_context()));

  DlPaint layer_paint;
  layer_paint.setColor(DlColor::kGreen());
  layer_paint.setAntiAlias(true);
  DlPaint child1_paint;
  child1_paint.setColor(DlColor::kRed());
  child1_paint.setAntiAlias(true);
  DlPaint child2_paint;
  child2_paint.setColor(DlColor::kBlue());
  child2_paint.setAntiAlias(true);
  layer->Paint(paint_context());
  EXPECT_EQ(
      mock_canvas().draw_calls(),
      std::vector({
          MockCanvas::DrawCall{
              0, MockCanvas::DrawPathData{layer_path, layer_paint}},
          MockCanvas::DrawCall{0, MockCanvas::SaveData{1}},
          MockCanvas::DrawCall{
              1, MockCanvas::ClipPathData{layer_path, ClipOp::kIntersect}},
          MockCanvas::DrawCall{
              1, MockCanvas::DrawPathData{child1_path, child1_paint}},
          MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}},
      }));
  DisplayListBuilder expected_builder;
  {  // layer::Paint()
    expected_builder.DrawPath(layer_path,
                              DlPaint(DlColor::kGreen()).setAntiAlias(true));
    expected_builder.Save();
    {
      expected_builder.ClipPath(layer_path, ClipOp::kIntersect, false);
      {  // child1::Paint()
        expected_builder.DrawPath(child1_path,
                                  DlPaint(DlColor::kRed()).setAntiAlias(true));
      }
      // child2::Paint() is not called due to layer cullling
      // This is the expected and intended behavior.
    }
    expected_builder.Restore();
  }
  layer->Paint(display_list_paint_context());
  EXPECT_TRUE(DisplayListsEQ_Verbose(display_list(), expected_builder.Build()));
}

TEST_F(PhysicalShapeLayerTest, ChildrenLargerThanPathNoClip) {
  SkPath layer_path;
  layer_path.addRect(5.0f, 6.0f, 20.5f, 21.5f);
  SkPath child1_path;
  child1_path.addRect(4, 0, 12, 12).close();
  SkPath child2_path;
  child2_path.addRect(3, 2, 5, 15).close();
  auto child1 =
      std::make_shared<PhysicalShapeLayer>(DlColor::kRed(), DlColor::kBlack(),
                                           0.0f,  // elevation
                                           child1_path, Clip::none);
  auto child2 =
      std::make_shared<PhysicalShapeLayer>(DlColor::kBlue(), DlColor::kBlack(),
                                           0.0f,  // elevation
                                           child2_path, Clip::none);
  auto layer =
      std::make_shared<PhysicalShapeLayer>(DlColor::kGreen(), DlColor::kBlack(),
                                           0.0f,  // elevation
                                           layer_path, Clip::none);
  layer->Add(child1);
  layer->Add(child2);

  layer->Preroll(preroll_context());
  SkRect child_bounds = child1->paint_bounds();
  child_bounds.join(child2->paint_bounds());
  SkRect total_bounds = child_bounds;
  total_bounds.join(layer_path.getBounds());
  EXPECT_NE(layer->paint_bounds(), layer_path.getBounds());
  EXPECT_EQ(layer->paint_bounds(), total_bounds);
  EXPECT_EQ(layer->child_paint_bounds(), child_bounds);
  EXPECT_TRUE(layer->needs_painting(paint_context()));

  DlPaint layer_paint;
  layer_paint.setColor(DlColor::kGreen());
  layer_paint.setAntiAlias(true);
  DlPaint child1_paint;
  child1_paint.setColor(DlColor::kRed());
  child1_paint.setAntiAlias(true);
  DlPaint child2_paint;
  child2_paint.setColor(DlColor::kBlue());
  child2_paint.setAntiAlias(true);
  layer->Paint(paint_context());
  EXPECT_EQ(
      mock_canvas().draw_calls(),
      std::vector({MockCanvas::DrawCall{
                       0, MockCanvas::DrawPathData{layer_path, layer_paint}},
                   MockCanvas::DrawCall{
                       0, MockCanvas::DrawPathData{child1_path, child1_paint}},
                   MockCanvas::DrawCall{0, MockCanvas::DrawPathData{
                                               child2_path, child2_paint}}}));
}

TEST_F(PhysicalShapeLayerTest, ElevationSimple) {
  constexpr float initial_elevation = 20.0f;
  SkPath layer_path;
  layer_path.addRect(0, 0, 8, 8).close();
  auto layer = std::make_shared<PhysicalShapeLayer>(
      DlColor::kGreen(), DlColor::kBlack(), initial_elevation, layer_path,
      Clip::none);

  layer->Preroll(preroll_context());
  // The Fuchsia system compositor handles all elevated PhysicalShapeLayers and
  // their shadows , so we do not do any painting there.
  EXPECT_EQ(layer->paint_bounds(),
            DlCanvas::ComputeShadowBounds(layer_path, initial_elevation, 1.0f,
                                          SkMatrix()));
  EXPECT_TRUE(layer->needs_painting(paint_context()));
  EXPECT_EQ(layer->elevation(), initial_elevation);

  DlPaint layer_paint;
  layer_paint.setColor(DlColor::kGreen());
  layer_paint.setAntiAlias(true);
  layer->Paint(paint_context());
  EXPECT_EQ(
      mock_canvas().draw_calls(),
      std::vector(
          {MockCanvas::DrawCall{
               0, MockCanvas::DrawShadowData{layer_path, DlColor::kBlack(),
                                             initial_elevation, false, 1}},
           MockCanvas::DrawCall{
               0, MockCanvas::DrawPathData{layer_path, layer_paint}}}));
}

TEST_F(PhysicalShapeLayerTest, ElevationComplex) {
  // The layer tree should look like this:
  // layers[0] +1.0f = 1.0f
  // |       \
  // |        \
  // |         \
  // |       layers[2] +3.0f = 4.0f
  // |          |
  // |       layers[3] +4.0f = 8.0f
  // |
  // |
  // layers[1] + 2.0f = 3.0f
  constexpr float initial_elevations[4] = {1.0f, 2.0f, 3.0f, 4.0f};
  SkPath layer_path;
  layer_path.addRect(0, 0, 80, 80).close();

  std::shared_ptr<PhysicalShapeLayer> layers[4];
  for (int i = 0; i < 4; i += 1) {
    layers[i] = std::make_shared<PhysicalShapeLayer>(
        DlColor::kBlack(), DlColor::kBlack(), initial_elevations[i], layer_path,
        Clip::none);
  }
  layers[0]->Add(layers[1]);
  layers[0]->Add(layers[2]);
  layers[2]->Add(layers[3]);

  layers[0]->Preroll(preroll_context());
  for (int i = 0; i < 4; i += 1) {
    // On Fuchsia, the system compositor handles all elevated
    // PhysicalShapeLayers and their shadows , so we do not do any painting
    // there.
    SkRect paint_bounds = DlCanvas::ComputeShadowBounds(
        layer_path, initial_elevations[i], 1.0f /* pixel_ratio */, SkMatrix());

    // Without clipping the children will be painted as well
    for (auto layer : layers[i]->layers()) {
      paint_bounds.join(layer->paint_bounds());
    }
    EXPECT_EQ(layers[i]->paint_bounds(), paint_bounds);
    EXPECT_TRUE(layers[i]->needs_painting(paint_context()));
  }

  DlPaint layer_paint;
  layer_paint.setColor(DlColor::kBlack());
  layer_paint.setAntiAlias(true);
  layers[0]->Paint(paint_context());
  EXPECT_EQ(
      mock_canvas().draw_calls(),
      std::vector(
          {MockCanvas::DrawCall{
               0, MockCanvas::DrawShadowData{layer_path, DlColor::kBlack(),
                                             initial_elevations[0], false, 1}},
           MockCanvas::DrawCall{
               0, MockCanvas::DrawPathData{layer_path, layer_paint}},
           MockCanvas::DrawCall{
               0, MockCanvas::DrawShadowData{layer_path, DlColor::kBlack(),
                                             initial_elevations[1], false, 1}},
           MockCanvas::DrawCall{
               0, MockCanvas::DrawPathData{layer_path, layer_paint}},
           MockCanvas::DrawCall{
               0, MockCanvas::DrawShadowData{layer_path, DlColor::kBlack(),
                                             initial_elevations[2], false, 1}},
           MockCanvas::DrawCall{
               0, MockCanvas::DrawPathData{layer_path, layer_paint}},
           MockCanvas::DrawCall{
               0, MockCanvas::DrawShadowData{layer_path, DlColor::kBlack(),
                                             initial_elevations[3], false, 1}},
           MockCanvas::DrawCall{
               0, MockCanvas::DrawPathData{layer_path, layer_paint}}}));
}

TEST_F(PhysicalShapeLayerTest, ShadowNotDependsCtm) {
  constexpr SkScalar elevations[] = {1, 2, 3, 4, 5, 10};
  constexpr SkScalar scales[] = {0.5, 1, 1.5, 2, 3, 5};
  constexpr SkScalar translates[] = {0, 1, -1, 0.5, 2, 10};

  SkPath path;
  path.addRect(0, 0, 8, 8).close();

  for (SkScalar elevation : elevations) {
    SkRect baseline_bounds =
        DlCanvas::ComputeShadowBounds(path, elevation, 1.0f, SkMatrix());
    for (SkScalar scale : scales) {
      for (SkScalar translate_x : translates) {
        for (SkScalar translate_y : translates) {
          SkMatrix ctm;
          ctm.setScaleTranslate(scale, scale, translate_x, translate_y);
          SkRect bounds =
              DlCanvas::ComputeShadowBounds(path, elevation, scale, ctm);
          EXPECT_FLOAT_EQ(bounds.fLeft, baseline_bounds.fLeft);
          EXPECT_FLOAT_EQ(bounds.fTop, baseline_bounds.fTop);
          EXPECT_FLOAT_EQ(bounds.fRight, baseline_bounds.fRight);
          EXPECT_FLOAT_EQ(bounds.fBottom, baseline_bounds.fBottom);
        }
      }
    }
  }
}

static int RasterizedDifferenceInPixels(
    const std::function<void(SkCanvas*)>& actual_draw_function,
    const std::function<void(SkCanvas*)>& expected_draw_function,
    const SkSize& canvas_size) {
  sk_sp<SkSurface> actual_surface =
      SkSurface::MakeRasterN32Premul(canvas_size.width(), canvas_size.height());
  sk_sp<SkSurface> expected_surface =
      SkSurface::MakeRasterN32Premul(canvas_size.width(), canvas_size.height());

  actual_surface->getCanvas()->drawColor(SK_ColorWHITE);
  expected_surface->getCanvas()->drawColor(SK_ColorWHITE);

  actual_draw_function(actual_surface->getCanvas());
  expected_draw_function(expected_surface->getCanvas());

  SkPixmap actual_pixels;
  EXPECT_TRUE(actual_surface->peekPixels(&actual_pixels));

  SkPixmap expected_pixels;
  EXPECT_TRUE(expected_surface->peekPixels(&expected_pixels));

  int different_pixels = 0;
  for (int y = 0; y < canvas_size.height(); y++) {
    const uint32_t* actual_row = actual_pixels.addr32(0, y);
    const uint32_t* expected_row = expected_pixels.addr32(0, y);
    for (int x = 0; x < canvas_size.width(); x++) {
      if (actual_row[x] != expected_row[x]) {
        different_pixels++;
      }
    }
  }
  return different_pixels;
}

TEST_F(PhysicalShapeLayerTest, ShadowNotDependsPathSize) {
  constexpr SkRect test_cases[][2] = {
      {{20, -100, 80, 80}, {20, -1000, 80, 80}},
      {{20, 20, 80, 200}, {20, 20, 80, 2000}},
  };

  for (const SkRect* test_case : test_cases) {
    EXPECT_EQ(RasterizedDifferenceInPixels(
                  [=](SkCanvas* canvas) {
                    SkPath path;
                    path.addRect(test_case[0]).close();
                    DlSkCanvasAdapter(canvas).DrawShadow(
                        path, DlColor::kBlack(), 1.0f, false, 1.0f);
                  },
                  [=](SkCanvas* canvas) {
                    SkPath path;
                    path.addRect(test_case[1]).close();
                    DlSkCanvasAdapter(canvas).DrawShadow(
                        path, DlColor::kBlack(), 1.0f, false, 1.0f);
                  },
                  SkSize::Make(100, 100)),
              0);
  }
}

static bool ReadbackResult(PrerollContext* context,
                           Clip clip_behavior,
                           const std::shared_ptr<Layer>& child,
                           bool before) {
  const SkRect layer_bounds = SkRect::MakeXYWH(0.5, 1.0, 5.0, 6.0);
  const SkPath layer_path = SkPath().addRect(layer_bounds);
  auto layer =
      std::make_shared<PhysicalShapeLayer>(DlColor::kGreen(), DlColor::kBlack(),
                                           0.0f,  // elevation
                                           layer_path, clip_behavior);
  if (child != nullptr) {
    layer->Add(child);
  }
  context->surface_needs_readback = before;
  layer->Preroll(context);
  return context->surface_needs_readback;
}

TEST_F(PhysicalShapeLayerTest, Readback) {
  PrerollContext* context = preroll_context();
  SkPath path;
  DlPaint paint;

  const Clip hard = Clip::hardEdge;
  const Clip soft = Clip::antiAlias;
  const Clip save_layer = Clip::antiAliasWithSaveLayer;

  std::shared_ptr<MockLayer> nochild;
  auto reader = std::make_shared<MockLayer>(path, paint);
  reader->set_fake_reads_surface(true);
  auto nonreader = std::make_shared<MockLayer>(path, paint);

  // No children, no prior readback -> no readback after
  EXPECT_FALSE(ReadbackResult(context, hard, nochild, false));
  EXPECT_FALSE(ReadbackResult(context, soft, nochild, false));
  EXPECT_FALSE(ReadbackResult(context, save_layer, nochild, false));

  // No children, prior readback -> readback after
  EXPECT_TRUE(ReadbackResult(context, hard, nochild, true));
  EXPECT_TRUE(ReadbackResult(context, soft, nochild, true));
  EXPECT_TRUE(ReadbackResult(context, save_layer, nochild, true));

  // Non readback child, no prior readback -> no readback after
  EXPECT_FALSE(ReadbackResult(context, hard, nonreader, false));
  EXPECT_FALSE(ReadbackResult(context, soft, nonreader, false));
  EXPECT_FALSE(ReadbackResult(context, save_layer, nonreader, false));

  // Non readback child, prior readback -> readback after
  EXPECT_TRUE(ReadbackResult(context, hard, nonreader, true));
  EXPECT_TRUE(ReadbackResult(context, soft, nonreader, true));
  EXPECT_TRUE(ReadbackResult(context, save_layer, nonreader, true));

  // Readback child, no prior readback -> readback after unless SaveLayer
  EXPECT_TRUE(ReadbackResult(context, hard, reader, false));
  EXPECT_TRUE(ReadbackResult(context, soft, reader, false));
  EXPECT_FALSE(ReadbackResult(context, save_layer, reader, false));

  // Readback child, prior readback -> readback after
  EXPECT_TRUE(ReadbackResult(context, hard, reader, true));
  EXPECT_TRUE(ReadbackResult(context, soft, reader, true));
  EXPECT_TRUE(ReadbackResult(context, save_layer, reader, true));
}

TEST_F(PhysicalShapeLayerTest, OpacityInheritance) {
  SkPath layer_path;
  layer_path.addRect(5.0f, 6.0f, 20.5f, 21.5f);
  auto layer =
      std::make_shared<PhysicalShapeLayer>(DlColor::kGreen(), DlColor::kBlack(),
                                           0.0f,  // elevation
                                           layer_path, Clip::none);

  PrerollContext* context = preroll_context();
  context->renderable_state_flags = 0;
  layer->Preroll(context);
  EXPECT_EQ(context->renderable_state_flags, 0);
}

using PhysicalShapeLayerDiffTest = DiffContextTest;

TEST_F(PhysicalShapeLayerDiffTest, NoClipPaintRegion) {
  MockLayerTree tree1;
  const SkPath layer_path = SkPath().addRect(SkRect::MakeXYWH(0, 0, 100, 100));
  auto layer =
      std::make_shared<PhysicalShapeLayer>(DlColor::kGreen(), DlColor::kBlack(),
                                           0.0f,  // elevation
                                           layer_path, Clip::none);

  const SkPath layer_path2 =
      SkPath().addRect(SkRect::MakeXYWH(200, 200, 200, 200));
  auto layer2 = std::make_shared<MockLayer>(layer_path2);
  layer->Add(layer2);
  tree1.root()->Add(layer);

  auto damage = DiffLayerTree(tree1, MockLayerTree());
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(0, 0, 400, 400));
}

TEST_F(PhysicalShapeLayerDiffTest, ClipPaintRegion) {
  MockLayerTree tree1;
  const SkPath layer_path = SkPath().addRect(SkRect::MakeXYWH(0, 0, 100, 100));
  auto layer =
      std::make_shared<PhysicalShapeLayer>(DlColor::kGreen(), DlColor::kBlack(),
                                           0.0f,  // elevation
                                           layer_path, Clip::hardEdge);

  const SkPath layer_path2 =
      SkPath().addRect(SkRect::MakeXYWH(200, 200, 200, 200));
  auto layer2 = std::make_shared<MockLayer>(layer_path2);
  layer->Add(layer2);
  tree1.root()->Add(layer);

  auto damage = DiffLayerTree(tree1, MockLayerTree());
  EXPECT_EQ(damage.frame_damage, SkIRect::MakeLTRB(0, 0, 100, 100));
}

}  // namespace testing
}  // namespace flutter