// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "ui/ozone/platform/flatland/flatland_window.h"

#include <fidl/fuchsia.ui.pointer/cpp/fidl.h>
#include <fidl/fuchsia.ui.pointer/cpp/hlcpp_conversion.h>
#include <fuchsia/ui/composition/cpp/fidl.h>
#include <fuchsia/ui/views/cpp/fidl.h>
#include <lib/ui/scenic/cpp/testing/fake_flatland.h>
#include <lib/ui/scenic/cpp/testing/fake_touch_source.h>
#include <lib/ui/scenic/cpp/testing/fake_view_ref_focused.h>
#include <lib/zx/channel.h>

#include <memory>
#include <string>

#include "base/fuchsia/koid.h"
#include "base/fuchsia/scoped_service_publisher.h"
#include "base/fuchsia/test_component_context_for_process.h"
#include "base/logging.h"
#include "base/test/fidl_matchers.h"
#include "base/test/task_environment.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "ui/events/fuchsia/util/pointer_event_utility.h"
#include "ui/ozone/platform/flatland/flatland_window_manager.h"
#include "ui/ozone/test/mock_platform_window_delegate.h"
#include "ui/platform_window/fuchsia/view_ref_pair.h"

using ::scenic::FakeGraph;
using ::scenic::FakeTransform;
using ::scenic::FakeTransformPtr;
using ::scenic::FakeView;
using ::scenic::FakeViewport;
using ::testing::_;
using ::testing::AllOf;
using ::testing::Contains;
using ::testing::Field;
using ::testing::IsEmpty;
using ::testing::Matcher;
using ::testing::Property;
using ::testing::SaveArg;
using ::testing::VariantWith;

namespace ui {

namespace {

Matcher<FakeGraph> IsWindowGraph(
    const fuchsia::ui::composition::ParentViewportWatcherPtr&
        parent_viewport_watcher,
    const fuchsia::ui::views::ViewportCreationToken& viewport_creation_token,
    Matcher<std::vector<FakeTransformPtr>> children_transform_matcher) {
  std::optional<zx_koid_t> view_token_koid =
      base::GetRelatedKoid(viewport_creation_token.value);
  EXPECT_TRUE(view_token_koid.has_value());
  std::optional<zx_koid_t> watcher_koid =
      base::GetRelatedKoid(parent_viewport_watcher.channel());
  EXPECT_TRUE(watcher_koid.has_value());

  return AllOf(
      Field("root_transform", &FakeGraph::root_transform,
            Pointee(AllOf(
                Field("translation", &FakeTransform::translation,
                      ::base::test::FidlEq(FakeTransform::kDefaultTranslation)),
                Field("scale", &FakeTransform::scale,
                      ::base::test::FidlEq(FakeTransform::kDefaultScale)),
                Field("opacity", &FakeTransform::opacity,
                      FakeTransform::kDefaultOpacity),
                Field("children", &FakeTransform::children,
                      children_transform_matcher)))),
      Field("view", &FakeGraph::view,
            Optional(AllOf(
                Field("view_token", &FakeView::view_token, view_token_koid),
                Field("parent_viewport_watcher",
                      &FakeView::parent_viewport_watcher, watcher_koid)))));
}

Matcher<fuchsia::ui::composition::ViewportProperties> IsViewportProperties(
    const fuchsia::math::SizeU& logical_size) {
  return AllOf(
      Property("has_logical_size",
               &fuchsia::ui::composition::ViewportProperties::has_logical_size,
               true),
      Property("logical_size",
               &fuchsia::ui::composition::ViewportProperties::logical_size,
               ::base::test::FidlEq(logical_size)));
}

Matcher<FakeTransformPtr> IsViewport(
    const fuchsia::ui::views::ViewCreationToken& view_token,
    const fuchsia::math::SizeU& viewport_logical_size) {
  auto viewport_koid = base::GetRelatedKoid(view_token.value);

  return Pointee(AllOf(
      Field("translation", &FakeTransform::translation,
            ::base::test::FidlEq(FakeTransform::kDefaultTranslation)),
      Field("scale", &FakeTransform::scale,
            ::base::test::FidlEq(FakeTransform::kDefaultScale)),
      Field("opacity", &FakeTransform::opacity, FakeTransform::kDefaultOpacity),
      Field("children", &FakeTransform::children, IsEmpty()),
      Field("content", &FakeTransform::content,
            Pointee(VariantWith<FakeViewport>(AllOf(
                Field("viewport_properties", &FakeViewport::viewport_properties,
                      IsViewportProperties(viewport_logical_size)),
                Field("viewport_token", &FakeViewport::viewport_token,
                      viewport_koid)))))));
}

Matcher<FakeTransformPtr> IsHitShield() {
  return Pointee(AllOf(
      // Must not clip the hit region.
      Field("clip_bounds", &FakeTransform::clip_bounds,
            testing::Eq(std::nullopt)),
      // Hit region must be "infinite".
      Field("hit_regions", &FakeTransform::hit_regions,
            testing::Contains(
                ::base::test::FidlEq(scenic::kInfiniteHitRegion)))));
}

}  // namespace

class FlatlandWindowTest : public ::testing::Test {
 protected:
  FlatlandWindowTest()
      : fake_flatland_publisher_(test_context_.additional_services(),
                                 fake_flatland_.GetFlatlandRequestHandler()) {}
  ~FlatlandWindowTest() override = default;

  void CreateWindow() {
    EXPECT_FALSE(flatland_window_);

    fuchsia::ui::views::ViewCreationToken view_token;
    fuchsia::ui::views::ViewportCreationToken viewport_token;
    auto status =
        zx::channel::create(0, &viewport_token.value, &view_token.value);
    CHECK_EQ(ZX_OK, status);
    viewport_token_ = std::move(viewport_token);

    EXPECT_CALL(window_delegate_, OnAcceleratedWidgetAvailable(_))
        .WillOnce(SaveArg<0>(&window_widget_));

    PlatformWindowInitProperties properties;
    properties.view_ref_pair = ViewRefPair::New();
    properties.view_creation_token = std::move(view_token);
    flatland_window_ = std::make_unique<FlatlandWindow>(
        &window_manager_, &window_delegate_, std::move(properties));
  }

  void SetLayoutInfo(uint32_t width,
                     uint32_t height,
                     float dpr,
                     fuchsia::math::Inset inset = {0, 0, 0, 0}) {
    fuchsia::ui::composition::LayoutInfo layout_info;
    layout_info.set_logical_size({width, height});
    layout_info.set_device_pixel_ratio({dpr, dpr});
    layout_info.set_inset(inset);
    flatland_window_->OnGetLayout(std::move(layout_info));
  }

  void SetWindowStatus(fuchsia::ui::composition::ParentViewportStatus status) {
    flatland_window_->OnGetStatus(status);
  }

  void SetViewRefFocusedHandle(
      fuchsia::ui::views::ViewRefFocusedHandle view_ref_focused_handle) {
    flatland_window_->view_ref_focused_.Bind(
        std::move(view_ref_focused_handle));
    flatland_window_->view_ref_focused_->Watch(fit::bind_member(
        flatland_window_.get(), &FlatlandWindow::OnViewRefFocusedWatchResult));
  }

  void SetTouchSource(
      fidl::ClientEnd<fuchsia_ui_pointer::TouchSource> touch_source) {
    auto mouse_endpoints =
        fidl::CreateEndpoints<fuchsia_ui_pointer::MouseSource>();
    EXPECT_TRUE(mouse_endpoints.is_ok()) << mouse_endpoints.status_string();
    flatland_window_->pointer_handler_ = std::make_unique<PointerEventsHandler>(
        std::move(touch_source), std::move(mouse_endpoints->client));
    flatland_window_->pointer_handler_->StartWatching(base::BindRepeating(
        &FlatlandWindow::DispatchEvent,
        // This is safe since |flatland_window_| is a class member.
        base::Unretained(flatland_window_.get())));
  }

  bool HasPendingAttachSurfaceContentClosure() {
    return !!flatland_window_->pending_attach_surface_content_closure_;
  }

  const fuchsia::ui::composition::ParentViewportWatcherPtr&
  parent_viewport_watcher() {
    return flatland_window_->parent_viewport_watcher_;
  }

  base::test::SingleThreadTaskEnvironment task_environment_{
      base::test::SingleThreadTaskEnvironment::MainThreadType::IO};
  scenic::FakeFlatland fake_flatland_;

  base::TestComponentContextForProcess test_context_;
  // Injects binding for responding to Flatland protocol connection requests.
  const base::ScopedServicePublisher<fuchsia::ui::composition::Flatland>
      fake_flatland_publisher_;

  FlatlandWindowManager window_manager_;

  MockPlatformWindowDelegate window_delegate_;
  std::unique_ptr<FlatlandWindow> flatland_window_;

  gfx::AcceleratedWidget window_widget_ = gfx::kNullAcceleratedWidget;

  fuchsia::ui::views::ViewportCreationToken viewport_token_;
};

TEST_F(FlatlandWindowTest, Initialization) {
  CreateWindow();
  ASSERT_NE(window_widget_, gfx::kNullAcceleratedWidget);

  // Check that there are no crashes after flushing tasks.
  task_environment_.RunUntilIdle();
}

TEST_F(FlatlandWindowTest, PresentsOnShow) {
  size_t presents_called = 0u;
  fake_flatland_.SetPresentHandler(
      [&presents_called](auto) { ++presents_called; });

  CreateWindow();
  ASSERT_NE(window_widget_, gfx::kNullAcceleratedWidget);

  task_environment_.RunUntilIdle();
  EXPECT_EQ(0u, presents_called);

  flatland_window_->Show(/*inactive=*/false);
  EXPECT_EQ(0u, presents_called);
  task_environment_.RunUntilIdle();
  EXPECT_EQ(1u, presents_called);
  EXPECT_THAT(
      fake_flatland_.graph(),
      IsWindowGraph(parent_viewport_watcher(), viewport_token_, IsEmpty()));
}

// Tests that FlatlandWindow processes and delegates focus signal.
TEST_F(FlatlandWindowTest, ProcessesFocusedSignal) {
  CreateWindow();
  flatland_window_->Show(/*inactive=*/false);
  task_environment_.RunUntilIdle();

  scenic::FakeViewRefFocused fake_view_ref_focused;
  fidl::Binding<fuchsia::ui::views::ViewRefFocused>
      fake_view_ref_focused_binding(&fake_view_ref_focused);
  SetViewRefFocusedHandle(fake_view_ref_focused_binding.NewBinding());

  // FlatlandWindow should start watching.
  task_environment_.RunUntilIdle();
  EXPECT_EQ(fake_view_ref_focused.times_watched(), 1u);

  // Send focused=true signal.
  bool focus_delegated = false;
  EXPECT_CALL(window_delegate_, OnActivationChanged(_))
      .WillRepeatedly(SaveArg<0>(&focus_delegated));
  fake_view_ref_focused.ScheduleCallback(true);
  task_environment_.RunUntilIdle();
  EXPECT_EQ(fake_view_ref_focused.times_watched(), 2u);
  EXPECT_TRUE(focus_delegated);

  // Send focused=false signal.
  fake_view_ref_focused.ScheduleCallback(false);
  task_environment_.RunUntilIdle();
  EXPECT_EQ(fake_view_ref_focused.times_watched(), 3u);
  EXPECT_FALSE(focus_delegated);
}

TEST_F(FlatlandWindowTest, AppliesDevicePixelRatio) {
  CreateWindow();
  EXPECT_CALL(window_delegate_, OnBoundsChanged(_)).Times(1);
  SetLayoutInfo(100, 100, 1.f);

  scenic::FakeTouchSource fake_touch_source;
  fidl::Binding<fuchsia::ui::pointer::TouchSource> fake_touch_source_binding(
      &fake_touch_source);
  SetTouchSource(fidl::HLCPPToNatural(fake_touch_source_binding.NewBinding()));
  task_environment_.RunUntilIdle();

  // Send a touch event and expect coordinates to be the same as TouchEvent.
  const float kLocationX = 9.f;
  const float kLocationY = 10.f;
  bool event_received = false;
  EXPECT_CALL(window_delegate_, DispatchEvent(_))
      .WillOnce([&event_received, kLocationX, kLocationY](ui::Event* event) {
        EXPECT_EQ(event->AsTouchEvent()->location_f().x(), kLocationX);
        EXPECT_EQ(event->AsTouchEvent()->location_f().y(), kLocationY);
        event_received = true;
      });
  std::vector<fuchsia_ui_pointer::TouchEvent> events;
  events.push_back(TouchEventBuilder()
                       .SetPosition({kLocationX, kLocationY})
                       .SetTouchInteractionStatus(
                           fuchsia_ui_pointer::TouchInteractionStatus::kGranted)
                       .Build());
  fake_touch_source.ScheduleCallback(fidl::NaturalToHLCPP(std::move(events)));
  task_environment_.RunUntilIdle();
  EXPECT_TRUE(event_received);

  // Update device pixel ratio.
  const float kDPR = 2.f;
  EXPECT_CALL(window_delegate_, OnBoundsChanged(_)).Times(1);
  SetLayoutInfo(100, 100, kDPR);

  // Send the same touch event and expect coordinates to be scaled from
  // TouchEvent.
  event_received = false;
  EXPECT_CALL(window_delegate_, DispatchEvent(_))
      .WillOnce([&event_received, kLocationX, kLocationY,
                 kDPR](ui::Event* event) {
        EXPECT_EQ(event->AsTouchEvent()->location_f().x(), kLocationX * kDPR);
        EXPECT_EQ(event->AsTouchEvent()->location_f().y(), kLocationY * kDPR);
        event_received = true;
      });
  events.clear();
  events.push_back(TouchEventBuilder()
                       .SetPosition({kLocationX, kLocationY})
                       .SetTouchInteractionStatus(
                           fuchsia_ui_pointer::TouchInteractionStatus::kGranted)
                       .Build());
  fake_touch_source.ScheduleCallback(fidl::NaturalToHLCPP(std::move(events)));
  task_environment_.RunUntilIdle();
  EXPECT_TRUE(event_received);
}

TEST_F(FlatlandWindowTest, WaitsForNonZeroSizeToAttachSurfaceContent) {
  size_t presents_called = 0u;
  fake_flatland_.SetPresentHandler(
      [&presents_called](auto) { ++presents_called; });

  CreateWindow();

  // FlatlandWindow should start watching callbacks in ctor.
  task_environment_.RunUntilIdle();

  // Try attaching the content. It should only be a closure.
  fuchsia::ui::views::ViewCreationToken view_token;
  fuchsia::ui::views::ViewportCreationToken viewport_token;
  auto status =
      zx::channel::create(0, &viewport_token.value, &view_token.value);
  CHECK_EQ(ZX_OK, status);
  flatland_window_->AttachSurfaceContent(std::move(viewport_token));
  EXPECT_TRUE(HasPendingAttachSurfaceContentClosure());

  // Setting layout info should trigger the closure and delegate calls.
  EXPECT_CALL(window_delegate_, OnWindowStateChanged(_, _)).Times(1);
  EXPECT_CALL(window_delegate_, OnBoundsChanged(_)).Times(1);

  const uint32_t kWidth = 200;
  const uint32_t kHeight = 100;
  const fuchsia::math::SizeU expected_size = {kWidth, kHeight};

  SetWindowStatus(
      fuchsia::ui::composition::ParentViewportStatus::CONNECTED_TO_DISPLAY);
  SetLayoutInfo(kWidth, kHeight, 1.f);
  EXPECT_FALSE(HasPendingAttachSurfaceContentClosure());

  // There should be a present call in FakeFlatland after flushing the tasks.
  EXPECT_EQ(0u, presents_called);
  task_environment_.RunUntilIdle();
  EXPECT_EQ(1u, presents_called);

  // Show to attach the scene graph.
  flatland_window_->Show(/*inactive=*/false);
  fuchsia::ui::composition::OnNextFrameBeginValues on_next_frame_begin_values;
  on_next_frame_begin_values.set_additional_present_credits(1);
  fake_flatland_.FireOnNextFrameBeginEvent(
      std::move(on_next_frame_begin_values));

  // Spin the loop to process Present().
  task_environment_.RunUntilIdle();
  EXPECT_EQ(2u, presents_called);
  EXPECT_THAT(fake_flatland_.graph(),
              IsWindowGraph(parent_viewport_watcher(), viewport_token_,
                            Contains(IsViewport(view_token, expected_size))));
}

// Verify that surface is cleared when the window is disconnected from the
// display.
TEST_F(FlatlandWindowTest, ResetSurfaceOnDisconnect) {
  CreateWindow();

  EXPECT_CALL(window_delegate_, OnBoundsChanged(_));
  SetLayoutInfo(100, 100, 1.f);
  task_environment_.RunUntilIdle();

  // Try attaching the content. It should only be a closure.
  fuchsia::ui::views::ViewCreationToken view_token;
  fuchsia::ui::views::ViewportCreationToken viewport_token;
  auto status =
      zx::channel::create(0, &viewport_token.value, &view_token.value);
  CHECK_EQ(ZX_OK, status);
  flatland_window_->AttachSurfaceContent(std::move(viewport_token));

  SetWindowStatus(
      fuchsia::ui::composition::ParentViewportStatus::CONNECTED_TO_DISPLAY);

  // Show to attach the scene graph.
  flatland_window_->Show(/*inactive=*/false);
  fuchsia::ui::composition::OnNextFrameBeginValues on_next_frame_begin_values;
  on_next_frame_begin_values.set_additional_present_credits(1);
  fake_flatland_.FireOnNextFrameBeginEvent(
      std::move(on_next_frame_begin_values));

  // Spin the loop to process Present().
  task_environment_.RunUntilIdle();

  // surface view should be attached once the window is shown.
  EXPECT_THAT(fake_flatland_.graph(),
              IsWindowGraph(parent_viewport_watcher(), viewport_token_, _));

  // Remove the window from the screen and verify that it simulates destruction
  // of AcceleratedWidget, which is necessary to ensure that WindowSurface is
  // re-initialized.
  testing::Mock::VerifyAndClearExpectations(&window_delegate_);
  EXPECT_CALL(window_delegate_, OnAcceleratedWidgetDestroyed());
  EXPECT_CALL(window_delegate_, OnAcceleratedWidgetAvailable(window_widget_));

  SetWindowStatus(fuchsia::ui::composition::ParentViewportStatus::
                      DISCONNECTED_FROM_DISPLAY);

  on_next_frame_begin_values.set_additional_present_credits(1);
  fake_flatland_.FireOnNextFrameBeginEvent(
      std::move(on_next_frame_begin_values));

  // Spin the loop to process Present().
  task_environment_.RunUntilIdle();

  // Verify that the surface view is cleared.
  EXPECT_THAT(
      fake_flatland_.graph(),
      IsWindowGraph(parent_viewport_watcher(), viewport_token_, IsEmpty()));
}

// Verify that when surface is attached, a hit region accompanies the surface.
TEST_F(FlatlandWindowTest, SurfaceHasHitTestHitShield) {
  CreateWindow();

  EXPECT_CALL(window_delegate_, OnBoundsChanged(_));
  const uint32_t kWidth = 200;
  const uint32_t kHeight = 100;
  const fuchsia::math::SizeU expected_size = {kWidth, kHeight};
  SetLayoutInfo(kWidth, kHeight, 1.f);

  // Spin the loop to propagate layout.
  task_environment_.RunUntilIdle();

  fuchsia::ui::views::ViewCreationToken view_token;
  fuchsia::ui::views::ViewportCreationToken viewport_token;
  auto status =
      zx::channel::create(0, &viewport_token.value, &view_token.value);
  CHECK_EQ(ZX_OK, status);
  flatland_window_->AttachSurfaceContent(std::move(viewport_token));

  // Show() the window, to trigger creation of the scene graph, including
  // surface and hit shield.
  flatland_window_->Show(/*inactive=*/false);
  fuchsia::ui::composition::OnNextFrameBeginValues on_next_frame_begin_values;
  on_next_frame_begin_values.set_additional_present_credits(1);
  fake_flatland_.FireOnNextFrameBeginEvent(
      std::move(on_next_frame_begin_values));

  // Spin the loop to process Present().
  task_environment_.RunUntilIdle();

  // Surface should be accompanied by input shield, in that order.
  EXPECT_THAT(
      fake_flatland_.graph(),
      Field("root_transform", &FakeGraph::root_transform,
            Pointee(Field("children", &FakeTransform::children,
                          ElementsAre(IsViewport(view_token, expected_size),
                                      IsHitShield())))));
}

class ParameterizedViewInsetTest : public FlatlandWindowTest,
                                   public testing::WithParamInterface<float> {};

INSTANTIATE_TEST_SUITE_P(ViewInsetTest,
                         ParameterizedViewInsetTest,
                         testing::Values(1.f, 2.f, 3.f));

// Tests whether view insets are properly set in |FlatlandWindow|.
TEST_P(ParameterizedViewInsetTest, ViewInsetsTest) {
  CreateWindow();
  EXPECT_CALL(window_delegate_, OnBoundsChanged(_)).Times(1);
  SetLayoutInfo(100, 100, 1.f);

  const fuchsia::math::Inset inset = {1, 1, 1, 1};
  const float dpr = GetParam();

  // Setting LayoutInfo should trigger a change in the bounds.
  PlatformWindowDelegate::BoundsChange bounds(false);
  EXPECT_CALL(window_delegate_, OnBoundsChanged(_))
      .WillOnce(SaveArg<0>(&bounds));
  SetLayoutInfo(100, 100, dpr, inset);

  EXPECT_EQ(bounds.system_ui_overlap.top(), dpr * inset.top);
  EXPECT_EQ(bounds.system_ui_overlap.left(), dpr * inset.left);
  EXPECT_EQ(bounds.system_ui_overlap.bottom(), dpr * inset.bottom);
  EXPECT_EQ(bounds.system_ui_overlap.right(), dpr * inset.right);
}

}  // namespace ui