// Copyright 2017 The Fuchsia 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 <math.h>

#include "garnet/lib/ui/gfx/tests/session_test.h"
#include "garnet/lib/ui/gfx/util/unwrap.h"
#include "lib/ui/scenic/cpp/commands.h"

#include "gtest/gtest.h"

namespace scenic_impl {
namespace gfx {
namespace test {
namespace {
using vec3 = escher::vec3;

constexpr vec3 kDownVector{0.f, 0.f, -1.f};
constexpr vec3 kUpVector{0.f, 0.f, 1.f};
}  // namespace

/*
 * We assume that the various ray-intersection tests for each shape
 * have been covered by other unit tests.  So for ease of testing,
 * we only use rectangles and most use simple downward pointing rays.
 *
 * To make things even easier, the rectangles are all 8x8.
 * The number indicated is the tag id.
 *
 *   +------+  +------+
 *   |      |  |      |   #10 corners: (0, 0, 2) .. (8, 8, 2)
 *   |  10  +--+  30  |   #20 corners: (5, 5, 1) .. (13, 13, 1)
 *   |      |  |      |   #30 corners: (10, 0, 1) .. (18, 8, 1)
 *   +----+-+20+-+----+
 *        |      |
 *        +------+
 *
 * These rectangles are arranged such that their front-to-back drawing
 * order is #30, #20, #10 which forces a tie-break for distance sorting
 * at the intersections of #20 and #30.
 *
 * The node tree looks like this:
 *   @1: entity node
 *   + @2: entity node, tag #100
 *     + @3: entity node, tag #25, translate x+4, y+4
 *       + @4: shape node, tag #10, translate z+2
 *       + @5: entity node, tag #20, translate x+5, y+5, z+1
 *         + @6: shape node
 *     + @7: entity node, tag #35, translate x+10, z+1
 *       + @8: shape node, tag #30, translate x+4, y+4
 *   + @9: entity node, tag #1
 *
 * The 8x8 square used for testing has shape id 20.
 */

class HitTestTest : public SessionTest {
 public:
  void SetUp() override {
    SessionTest::SetUp();

    Apply(scenic::NewCreateRectangleCmd(20, 8.f, 8.f));

    Apply(scenic::NewCreateEntityNodeCmd(1));

    Apply(scenic::NewCreateEntityNodeCmd(2));
    Apply(scenic::NewSetTagCmd(2, 100));
    Apply(scenic::NewAddChildCmd(1, 2));

    Apply(scenic::NewCreateEntityNodeCmd(3));
    Apply(scenic::NewSetTagCmd(3, 25));
    Apply(scenic::NewSetTranslationCmd(3, (float[3]){4.f, 4.f, 0.f}));
    Apply(scenic::NewAddChildCmd(2, 3));

    Apply(scenic::NewCreateShapeNodeCmd(4));
    Apply(scenic::NewSetTagCmd(4, 10));
    Apply(scenic::NewSetShapeCmd(4, 20));
    Apply(scenic::NewSetTranslationCmd(4, (float[3]){0.f, 0.f, 2.f}));
    Apply(scenic::NewAddChildCmd(3, 4));

    Apply(scenic::NewCreateEntityNodeCmd(5));
    Apply(scenic::NewSetTagCmd(5, 20));
    Apply(scenic::NewSetTranslationCmd(5, (float[3]){5.f, 5.f, 1.f}));
    Apply(scenic::NewAddChildCmd(3, 5));

    Apply(scenic::NewCreateShapeNodeCmd(6));
    Apply(scenic::NewSetShapeCmd(6, 20));
    Apply(scenic::NewAddChildCmd(5, 6));

    Apply(scenic::NewCreateEntityNodeCmd(7));
    Apply(scenic::NewSetTagCmd(7, 35));
    Apply(scenic::NewSetTranslationCmd(7, (float[3]){10.f, 0.f, 1.f}));
    Apply(scenic::NewAddChildCmd(2, 7));

    Apply(scenic::NewCreateShapeNodeCmd(8));
    Apply(scenic::NewSetTagCmd(8, 30));
    Apply(scenic::NewSetShapeCmd(8, 20));
    Apply(scenic::NewSetTranslationCmd(8, (float[3]){4.f, 4.f, 0.f}));
    Apply(scenic::NewAddChildCmd(7, 8));

    Apply(scenic::NewCreateEntityNodeCmd(9));
    Apply(scenic::NewSetTagCmd(9, 1));
    Apply(scenic::NewAddChildCmd(1, 9));
  }

 protected:
  struct ExpectedHit {
    uint32_t tag;
    float tx;  // inverse transform translation components
    float ty;
    float tz;
    float d;  // distance
  };

  void ExpectHits(uint32_t node_id, const vec3& ray_origin,
                  const vec3& ray_direction,
                  std::vector<ExpectedHit> expected_hits,
                  bool expected_null = false) {
    ::fuchsia::ui::gfx::vec3 wrapped_ray_origin;
    wrapped_ray_origin.x = ray_origin.x;
    wrapped_ray_origin.y = ray_origin.y;
    wrapped_ray_origin.z = ray_origin.z;

    ::fuchsia::ui::gfx::vec3 wrapped_ray_direction;
    wrapped_ray_direction.x = ray_direction.x;
    wrapped_ray_direction.y = ray_direction.y;
    wrapped_ray_direction.z = ray_direction.z;

    fidl::VectorPtr<::fuchsia::ui::gfx::Hit> actual_hits;
    session_->HitTest(
        node_id, wrapped_ray_origin, wrapped_ray_direction,
        [&actual_hits](fidl::VectorPtr<::fuchsia::ui::gfx::Hit> hits) {
          actual_hits = std::move(hits);
        });

    EXPECT_EQ(expected_null, actual_hits.is_null());
    EXPECT_EQ(expected_hits.size(), actual_hits->size());
    for (uint32_t i = 0;
         i < std::min(expected_hits.size(), actual_hits->size()); i++) {
      EXPECT_EQ(expected_hits[i].tag, actual_hits->at(i).tag_value)
          << "i=" << i;
      const auto& m = actual_hits->at(i).inverse_transform.matrix;
      EXPECT_EQ(1.f, m[0]) << "i=" << i;
      EXPECT_EQ(0.f, m[1]) << "i=" << i;
      EXPECT_EQ(0.f, m[2]) << "i=" << i;
      EXPECT_EQ(0.f, m[3]) << "i=" << i;
      EXPECT_EQ(0.f, m[4]) << "i=" << i;
      EXPECT_EQ(1.f, m[5]) << "i=" << i;
      EXPECT_EQ(0.f, m[6]) << "i=" << i;
      EXPECT_EQ(0.f, m[7]) << "i=" << i;
      EXPECT_EQ(0.f, m[8]) << "i=" << i;
      EXPECT_EQ(0.f, m[9]) << "i=" << i;
      EXPECT_EQ(1.f, m[10]) << "i=" << i;
      EXPECT_EQ(0.f, m[11]) << "i=" << i;
      EXPECT_EQ(expected_hits[i].tx, m[12]) << "i=" << i;
      EXPECT_EQ(expected_hits[i].ty, m[13]) << "i=" << i;
      EXPECT_EQ(expected_hits[i].tz, m[14]) << "i=" << i;
      EXPECT_EQ(1.f, m[15]) << "i=" << i;
      EXPECT_EQ(expected_hits[i].d, actual_hits->at(i).distance) << "i=" << i;
    }
  }
};

TEST_F(HitTestTest, InvalidNodeId) {
  ExpectHits(0, vec3(0.f, 0.f, 0.f), kDownVector, {}, true);
}

TEST_F(HitTestTest, RayBelowScenePointingDown) {
  ExpectHits(1, vec3(0.f, 0.f, -10.f), kDownVector, {});
}

TEST_F(HitTestTest, RayBelowScenePointingUp) {
  ExpectHits(1, vec3(0.f, 0.f, -10.f), kUpVector, {});
}

TEST_F(HitTestTest, RayAboveScenePointingUp) {
  ExpectHits(1, vec3(0.f, 0.f, 10.f), kUpVector, {});
}

TEST_F(HitTestTest, Hit10InTopLeftCornerFromNode1) {
  ExpectHits(1, vec3(0.f, 0.f, 10.f), kDownVector,
             {{.tag = 10, .tx = -4.f, .ty = -4.f, .tz = -2.f, .d = 8.f},
              {.tag = 25, .tx = -4.f, .ty = -4.f, .tz = 0.f, .d = 8.f},
              {.tag = 100, .tx = 0.f, .ty = 0.f, .tz = 0.f, .d = 8.f}});
}

TEST_F(HitTestTest, Hit10InTopLeftCornerFromNode2) {
  ExpectHits(2, vec3(0.f, 0.f, 10.f), kDownVector,
             {{.tag = 10, .tx = -4.f, .ty = -4.f, .tz = -2.f, .d = 8.f},
              {.tag = 25, .tx = -4.f, .ty = -4.f, .tz = 0.f, .d = 8.f},
              {.tag = 100, .tx = 0.f, .ty = 0.f, .tz = 0.f, .d = 8.f}});
}

TEST_F(HitTestTest, Hit10InTopLeftCornerFromNode3) {
  ExpectHits(3, vec3(-4.f, -4.f, 10.f), kDownVector,
             {{.tag = 10, .tx = 0.f, .ty = 0.f, .tz = -2.f, .d = 8.f},
              {.tag = 25, .tx = 0.f, .ty = 0.f, .tz = 0.f, .d = 8.f}});
}

TEST_F(HitTestTest, Hit10InTopLeftCornerFromNode4) {
  ExpectHits(4, vec3(-4.f, -4.f, 10.f), kDownVector,
             {{.tag = 10, .tx = 0.f, .ty = 0.f, .tz = 0.f, .d = 10.f}});
}

TEST_F(HitTestTest, Hit20InMiddleFromNode1) {
  ExpectHits(1, vec3(9.f, 9.f, 10.f), kDownVector,
             {{.tag = 20, .tx = -9.f, .ty = -9.f, .tz = -1.f, .d = 9.f},
              {.tag = 25, .tx = -4.f, .ty = -4.f, .tz = 0.f, .d = 9.f},
              {.tag = 100, .tx = 0.f, .ty = 0.f, .tz = 0.f, .d = 9.f}});
}

TEST_F(HitTestTest, Hit20InMiddleFromNode2) {
  ExpectHits(2, vec3(9.f, 9.f, 10.f), kDownVector,
             {{.tag = 20, .tx = -9.f, .ty = -9.f, .tz = -1.f, .d = 9.f},
              {.tag = 25, .tx = -4.f, .ty = -4.f, .tz = 0.f, .d = 9.f},
              {.tag = 100, .tx = 0.f, .ty = 0.f, .tz = 0.f, .d = 9.f}});
}

TEST_F(HitTestTest, Hit20InMiddleFromNode3) {
  ExpectHits(3, vec3(5.f, 5.f, 10.f), kDownVector,
             {{.tag = 20, .tx = -5.f, .ty = -5.f, .tz = -1.f, .d = 9.f},
              {.tag = 25, .tx = 0.f, .ty = 0.f, .tz = 0.f, .d = 9.f}});
}

TEST_F(HitTestTest, Hit20InMiddleFromNode5) {
  ExpectHits(5, vec3(0.f, 0.f, 10.f), kDownVector,
             {{.tag = 20, .tx = 0.f, .ty = 0.f, .tz = 0.f, .d = 10.f}});
}

TEST_F(HitTestTest, Hit20InMiddleFromNode6) {
  ExpectHits(6, vec3(0.f, 0.f, 10.f), kDownVector, {});
}

TEST_F(HitTestTest, HitBoth10And20FromNode1) {
  // 10 is nearer so it comes before 20
  ExpectHits(1, vec3(6.f, 6.f, 10.f), kDownVector,
             {{.tag = 10, .tx = -4.f, .ty = -4.f, .tz = -2.f, .d = 8.f},
              {.tag = 25, .tx = -4.f, .ty = -4.f, .tz = 0.f, .d = 8.f},
              {.tag = 100, .tx = 0.f, .ty = 0.f, .tz = 0.f, .d = 8.f},
              {.tag = 20, .tx = -9.f, .ty = -9.f, .tz = -1.f, .d = 9.f}});
}

TEST_F(HitTestTest, HitBoth20And30FromNode1) {
  // 20 and 30 are same distance but 30 is closer in draw order so it
  // comes before 20
  ExpectHits(1, vec3(12.f, 6.f, 10.f), kDownVector,
             {{.tag = 30, .tx = -14.f, .ty = -4.f, .tz = -1.f, .d = 9.f},
              {.tag = 35, .tx = -10.f, .ty = 0.f, .tz = -1.f, .d = 9.f},
              {.tag = 20, .tx = -9.f, .ty = -9.f, .tz = -1.f, .d = 9.f},
              {.tag = 25, .tx = -4.f, .ty = -4.f, .tz = 0.f, .d = 9.f},
              {.tag = 100, .tx = 0.f, .ty = 0.f, .tz = 0.f, .d = 9.f}});
}

TEST_F(HitTestTest, SuppressNode25FromNode1) {
  Apply(scenic::NewSetHitTestBehaviorCmd(
      3, ::fuchsia::ui::gfx::HitTestBehavior::kSuppress));

  // While we would have hit 20 and 25, we suppressed node 3 so neither appears.
  ExpectHits(1, vec3(12.f, 6.f, 10.f), kDownVector,
             {{.tag = 30, .tx = -14.f, .ty = -4.f, .tz = -1.f, .d = 9.f},
              {.tag = 35, .tx = -10.f, .ty = 0.f, .tz = -1.f, .d = 9.f},
              {.tag = 100, .tx = 0.f, .ty = 0.f, .tz = 0.f, .d = 9.f}});
}

TEST_F(HitTestTest, Clipping) {
  // Try to hit 10 from the top left corner, with clipping applied
  // to a rectangle added as a part in 25, which contains 10.
  // We move this part around and turn clipping on and off to see what happens
  // when the clip is intersected or not.
  Apply(scenic::NewCreateEntityNodeCmd(11));
  Apply(scenic::NewAddPartCmd(3, 11));
  Apply(scenic::NewCreateShapeNodeCmd(12));
  Apply(scenic::NewSetShapeCmd(12, 20));
  Apply(scenic::NewAddChildCmd(11, 12));

  // Initially, position the clip shape someplace far away from the content.
  // This causes 10 to be outside of its containing clip region.
  Apply(scenic::NewSetTranslationCmd(11, (float[3]){20.f, 20.f, 0.f}));
  Apply(scenic::NewSetClipCmd(3, 0, true));
  ExpectHits(1, vec3(0.f, 0.f, 10.f), kDownVector, {});

  // Now disable clipping and try again.
  Apply(scenic::NewSetClipCmd(3, 0, false));
  ExpectHits(1, vec3(0.f, 0.f, 10.f), kDownVector,
             {{.tag = 10, .tx = -4.f, .ty = -4.f, .tz = -2.f, .d = 8.f},
              {.tag = 25, .tx = -4.f, .ty = -4.f, .tz = 0.f, .d = 8.f},
              {.tag = 100, .tx = 0.f, .ty = 0.f, .tz = 0.f, .d = 8.f}});

  // Move the clip shape so it covers the part of 10 that we're hitting
  // and reenable clipping.
  Apply(scenic::NewSetTranslationCmd(11, (float[3]){-4.f, -4.f, 0.f}));
  Apply(scenic::NewSetClipCmd(3, 0, true));
  ExpectHits(1, vec3(0.f, 0.f, 10.f), kDownVector,
             {{.tag = 10, .tx = -4.f, .ty = -4.f, .tz = -2.f, .d = 8.f},
              {.tag = 25, .tx = -4.f, .ty = -4.f, .tz = 0.f, .d = 8.f},
              {.tag = 100, .tx = 0.f, .ty = 0.f, .tz = 0.f, .d = 8.f}});
}

}  // namespace test
}  // namespace gfx
}  // namespace scenic_impl