// Copyright 2022 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 <fuchsia/accessibility/semantics/cpp/fidl.h>
#include <fuchsia/buildinfo/cpp/fidl.h>
#include <fuchsia/cobalt/cpp/fidl.h>
#include <fuchsia/component/cpp/fidl.h>
#include <fuchsia/fonts/cpp/fidl.h>
#include <fuchsia/input/report/cpp/fidl.h>
#include <fuchsia/kernel/cpp/fidl.h>
#include <fuchsia/memorypressure/cpp/fidl.h>
#include <fuchsia/net/interfaces/cpp/fidl.h>
#include <fuchsia/netstack/cpp/fidl.h>
#include <fuchsia/posix/socket/cpp/fidl.h>
#include <fuchsia/scheduler/cpp/fidl.h>
#include <fuchsia/session/scene/cpp/fidl.h>
#include <fuchsia/sys/cpp/fidl.h>
#include <fuchsia/tracing/provider/cpp/fidl.h>
#include <fuchsia/ui/app/cpp/fidl.h>
#include <fuchsia/ui/input/cpp/fidl.h>
#include <fuchsia/ui/scenic/cpp/fidl.h>
#include <fuchsia/vulkan/loader/cpp/fidl.h>
#include <fuchsia/web/cpp/fidl.h>
#include <lib/async/cpp/task.h>
#include <lib/fidl/cpp/binding_set.h>
#include <lib/sys/component/cpp/testing/realm_builder.h>
#include <lib/sys/component/cpp/testing/realm_builder_types.h>
#include <lib/syslog/cpp/macros.h>
#include <lib/zx/clock.h>
#include <lib/zx/time.h>
#include <zircon/status.h>
#include <zircon/types.h>
#include <zircon/utc.h>

#include <cstddef>
#include <cstdint>
#include <iostream>
#include <memory>
#include <optional>
#include <queue>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>

#include <gtest/gtest.h>
#include <test/inputsynthesis/cpp/fidl.h>
#include <test/mouse/cpp/fidl.h>

#include "lib/fidl/cpp/interface_ptr.h"
#include "src/lib/testing/loop_fixture/real_loop_fixture.h"
#include "src/ui/testing/ui_test_manager/ui_test_manager.h"

namespace {

// Types imported for the realm_builder library.
using component_testing::ChildRef;
using component_testing::LocalComponent;
using component_testing::LocalComponentHandles;
using component_testing::ParentRef;
using component_testing::Protocol;
using component_testing::Realm;
using component_testing::Route;

// Alias for Component child name as provided to Realm Builder.
using ChildName = std::string;

// Alias for Component Legacy URL as provided to Realm Builder.
using LegacyUrl = std::string;

// Maximum pointer movement during a clickpad press for the gesture to
// be guaranteed to be interpreted as a click. For movement greater than
// this value, upper layers may, e.g., interpret the gesture as a drag.
//
// This value corresponds to the one used to instantiate the ClickDragHandler
// registered by Input Pipeline in Scene Manager.
constexpr int64_t kClickToDragThreshold = 16.0;

// Max timeout in failure cases.
// Set this as low as you can that still works across all test platforms.
constexpr zx::duration kTimeout = zx::min(5);

// Combines all vectors in `vecs` into one.
template <typename T>
std::vector<T> merge(std::initializer_list<std::vector<T>> vecs) {
  std::vector<T> result;
  for (auto v : vecs) {
    result.insert(result.end(), v.begin(), v.end());
  }
  return result;
}

// `ResponseListener` is a local test protocol that our test Flutter app uses to let us know
// what position and button press state the mouse cursor has.
// No need to use mutex in ResponseListenerServer because `MouseInputBase` inherits from
// `gtest::RealLoopFixture`, `RealLoopFixture` inherits from `RealLoop`, `RealLoop` has-an
// `async::Loop`, `Loop::Run()` Runs the message loop on the same thread with test.
class ResponseListenerServer : public test::mouse::ResponseListener, public LocalComponent {
 public:
  explicit ResponseListenerServer(async_dispatcher_t* dispatcher) : dispatcher_(dispatcher) {}

  // |test::mouse::ResponseListener|
  void Respond(test::mouse::PointerData pointer_data) override {
    events_.push(std::move(pointer_data));
  }

  // |test::mouse::ResponseListener|
  void NotifyWebEngineReady() override { web_engine_ready_ = true; }

  bool IsWebEngineReady() const { return web_engine_ready_; }

  // |MockComponent::Start|
  // When the component framework requests for this component to start, this
  // method will be invoked by the realm_builder library.
  void Start(std::unique_ptr<LocalComponentHandles> mock_handles) override {
    // When this component starts, add a binding to the test.mouse.ResponseListener
    // protocol to this component's outgoing directory.
    FX_CHECK(mock_handles->outgoing()->AddPublicService(
                 fidl::InterfaceRequestHandler<test::mouse::ResponseListener>([this](auto request) {
                   bindings_.AddBinding(this, std::move(request), dispatcher_);
                 })) == ZX_OK);
    mock_handles_.emplace_back(std::move(mock_handles));
  }

  size_t SizeOfEvents() const { return events_.size(); }

  test::mouse::PointerData PopEvent() {
    test::mouse::PointerData e = std::move(events_.front());
    events_.pop();
    return e;
  }

  const test::mouse::PointerData& LastEvent() const { return events_.back(); }

  void ClearEvents() { events_ = {}; }

 private:
  // Not owned.
  async_dispatcher_t* dispatcher_ = nullptr;
  fidl::BindingSet<test::mouse::ResponseListener> bindings_;
  std::vector<std::unique_ptr<LocalComponentHandles>> mock_handles_;
  std::queue<test::mouse::PointerData> events_;
  bool web_engine_ready_ = false;
};

constexpr auto kResponseListener = "response_listener";

struct Position {
  double x = 0.0;
  double y = 0.0;
};

class MouseInputBase : public gtest::RealLoopFixture {
 protected:
  MouseInputBase() : response_listener_(std::make_unique<ResponseListenerServer>(dispatcher())) {}

  sys::ServiceDirectory* realm_exposed_services() { return realm_exposed_services_.get(); }

  ResponseListenerServer* response_listener() { return response_listener_.get(); }

  void SetUp() override {
    // Post a "just in case" quit task, if the test hangs.
    async::PostDelayedTask(
        dispatcher(),
        [] { FX_LOGS(FATAL) << "\n\n>> Test did not complete in time, terminating.  <<\n\n"; },
        kTimeout);

    ui_testing::UITestManager::Config config;
    config.use_flatland = true;
    config.scene_owner = ui_testing::UITestManager::SceneOwnerType::SCENE_MANAGER;
    config.use_input = true;
    config.accessibility_owner = ui_testing::UITestManager::AccessibilityOwnerType::FAKE;
    config.ui_to_client_services = {fuchsia::ui::scenic::Scenic::Name_,
                                    fuchsia::ui::composition::Flatland::Name_,
                                    fuchsia::ui::composition::Allocator::Name_,
                                    fuchsia::ui::input::ImeService::Name_,
                                    fuchsia::ui::input3::Keyboard::Name_,
                                    fuchsia::accessibility::semantics::SemanticsManager::Name_};
    ui_test_manager_ = std::make_unique<ui_testing::UITestManager>(std::move(config));
    AssembleRealm(this->GetTestComponents(), this->GetTestV2Components(), this->GetTestRoutes());

    // Get the display dimensions.
    FX_LOGS(INFO) << "Waiting for scenic display info";
    auto scenic = realm_exposed_services()->Connect<fuchsia::ui::scenic::Scenic>();
    scenic->GetDisplayInfo([this](fuchsia::ui::gfx::DisplayInfo display_info) {
      display_width_ = display_info.width_in_px;
      display_height_ = display_info.height_in_px;
      FX_LOGS(INFO) << "Got display_width = " << display_width_
                    << " and display_height = " << display_height_;
    });
    RunLoopUntil([this] { return display_width_ != 0 && display_height_ != 0; });
  }

  void TearDown() override {
    // at the end of test, ensure event queue is empty.
    ASSERT_EQ(response_listener_->SizeOfEvents(), 0u);
  }

  // Subclass should implement this method to add components to the test realm
  // next to the base ones added.
  virtual std::vector<std::pair<ChildName, LegacyUrl>> GetTestComponents() { return {}; }

  // Subclass should implement this method to add v2 components to the test realm
  // next to the base ones added.
  virtual std::vector<std::pair<ChildName, std::string>> GetTestV2Components() { return {}; }

  // Subclass should implement this method to add capability routes to the test
  // realm next to the base ones added.
  virtual std::vector<Route> GetTestRoutes() { return {}; }

  // Send a synthesis mouse event.
  void SendMouseEvent(fidl::InterfacePtr<test::inputsynthesis::Mouse>& input_synthesis,
                      uint32_t device_id, fuchsia::input::report::MouseInputReport report,
                      uint64_t ts) {
    bool injection_initiated = false;
    input_synthesis->SendInputReport(
        device_id, std::move(report), ts, [&injection_initiated](auto result) {
          ASSERT_FALSE(result.is_err()) << "SendInputReport failed " << result.err();
          injection_initiated = true;
        });
    RunLoopUntil([&injection_initiated] { return injection_initiated; });
  }

  // Helper method for checking the test.mouse.ResponseListener response from the client app.
  void VerifyEvent(test::mouse::PointerData& pointer_data, double expected_x, double expected_y,
                   int64_t expected_buttons, const std::string& expected_type,
                   zx::basic_time<ZX_CLOCK_MONOTONIC>& input_injection_time,
                   const std::string& component_name) {
    FX_LOGS(INFO) << "Client received mouse change at (" << pointer_data.local_x() << ", "
                  << pointer_data.local_y() << ") with buttons " << pointer_data.buttons() << ".";
    FX_LOGS(INFO) << "Expected mouse change is at approximately (" << expected_x << ", "
                  << expected_y << ") with buttons " << expected_buttons << ".";

    zx::duration elapsed_time =
        zx::basic_time<ZX_CLOCK_MONOTONIC>(pointer_data.time_received()) - input_injection_time;
    EXPECT_TRUE(elapsed_time.get() > 0 && elapsed_time.get() != ZX_TIME_INFINITE);
    FX_LOGS(INFO) << "Input Injection Time (ns): " << input_injection_time.get();
    FX_LOGS(INFO) << "Client Received Time (ns): " << pointer_data.time_received();
    FX_LOGS(INFO) << "Elapsed Time (ns): " << elapsed_time.to_nsecs();

    // Allow for minor rounding differences in coordinates.
    // Note: These approximations don't account for `PointerMotionDisplayScaleHandler`
    // or `PointerMotionSensorScaleHandler`. We will need to do so in order to validate
    // larger motion or different sized displays.
    EXPECT_NEAR(pointer_data.local_x(), expected_x, 1);
    EXPECT_NEAR(pointer_data.local_y(), expected_y, 1);
    EXPECT_EQ(pointer_data.buttons(), expected_buttons);
    EXPECT_EQ(pointer_data.type(), expected_type);
    EXPECT_EQ(pointer_data.component_name(), component_name);
  }

  void VerifyEventLocationOnTheRightOfExpectation(
      test::mouse::PointerData& pointer_data, double expected_x_min, double expected_y,
      int64_t expected_buttons, const std::string& expected_type,
      zx::basic_time<ZX_CLOCK_MONOTONIC>& input_injection_time, const std::string& component_name) {
    FX_LOGS(INFO) << "Client received mouse change at (" << pointer_data.local_x() << ", "
                  << pointer_data.local_y() << ") with buttons " << pointer_data.buttons() << ".";
    FX_LOGS(INFO) << "Expected mouse change is at approximately (>" << expected_x_min << ", "
                  << expected_y << ") with buttons " << expected_buttons << ".";

    zx::duration elapsed_time =
        zx::basic_time<ZX_CLOCK_MONOTONIC>(pointer_data.time_received()) - input_injection_time;
    EXPECT_TRUE(elapsed_time.get() > 0 && elapsed_time.get() != ZX_TIME_INFINITE);
    FX_LOGS(INFO) << "Input Injection Time (ns): " << input_injection_time.get();
    FX_LOGS(INFO) << "Client Received Time (ns): " << pointer_data.time_received();
    FX_LOGS(INFO) << "Elapsed Time (ns): " << elapsed_time.to_nsecs();

    EXPECT_GT(pointer_data.local_x(), expected_x_min);
    EXPECT_NEAR(pointer_data.local_y(), expected_y, 1);
    EXPECT_EQ(pointer_data.buttons(), expected_buttons);
    EXPECT_EQ(pointer_data.type(), expected_type);
    EXPECT_EQ(pointer_data.component_name(), component_name);
  }

  void AssembleRealm(const std::vector<std::pair<ChildName, LegacyUrl>>& components,
                     const std::vector<std::pair<ChildName, std::string>>& components_v2,
                     const std::vector<Route>& routes) {
    FX_LOGS(INFO) << "Building realm";
    realm_ = std::make_unique<Realm>(ui_test_manager_->AddSubrealm());

    // Key part of service setup: have this test component vend the
    // |ResponseListener| service in the constructed realm.
    realm_->AddLocalChild(kResponseListener, response_listener());

    // Add components specific for this test case to the realm.
    for (const auto& [name, component] : components) {
      realm_->AddLegacyChild(name, component);
    }

    for (const auto& [name, component] : components_v2) {
      realm_->AddChild(name, component);
    }

    // Add the necessary routing for each of the extra components added above.
    for (const auto& route : routes) {
      realm_->AddRoute(route);
    }

    // Finally, build the realm using the provided components and routes.
    ui_test_manager_->BuildRealm();
    realm_exposed_services_ = ui_test_manager_->TakeExposedServicesDirectory();
  }

  void LaunchClient() {
    // Initialize scene, and attach client view.
    ui_test_manager_->InitializeScene();
    FX_LOGS(INFO) << "Wait for client view to render";
    RunLoopUntil([this]() { return ui_test_manager_->ClientViewIsRendering(); });
  }

  uint32_t AddMouseDevice(fidl::InterfacePtr<test::inputsynthesis::Mouse>& input_synthesis) {
    uint32_t device_id;
    bool new_device_completed = false;

    input_synthesis->AddDevice([&device_id, &new_device_completed](uint32_t id) {
      device_id = id;
      new_device_completed = true;
    });

    // wait for new device creation.
    RunLoopUntil([&new_device_completed] { return new_device_completed; });

    return device_id;
  }

  // Guaranteed to be initialized after SetUp().
  uint32_t display_width() const { return display_width_; }
  uint32_t display_height() const { return display_height_; }

  std::unique_ptr<ui_testing::UITestManager> ui_test_manager_;
  std::unique_ptr<sys::ServiceDirectory> realm_exposed_services_;
  std::unique_ptr<Realm> realm_;

  std::unique_ptr<ResponseListenerServer> response_listener_;

 private:
  uint32_t display_width_ = 0;
  uint32_t display_height_ = 0;
};

class FlutterInputTest : public MouseInputBase {
 protected:
  std::vector<std::pair<ChildName, std::string>> GetTestV2Components() override {
    return {
        std::make_pair(kMouseInputFlutter, kMouseInputFlutterUrl),
        std::make_pair(kMemoryPressureProvider, kMemoryPressureProviderUrl),
        std::make_pair(kNetstack, kNetstackUrl),
    };
  }

  std::vector<Route> GetTestRoutes() override {
    return merge({GetFlutterRoutes(ChildRef{kMouseInputFlutter}),
                  {
                      {.capabilities = {Protocol{fuchsia::ui::app::ViewProvider::Name_}},
                       .source = ChildRef{kMouseInputFlutter},
                       .targets = {ParentRef()}},
                  }});
  }

  // Routes needed to setup Flutter client.
  static std::vector<Route> GetFlutterRoutes(ChildRef target) {
    return {{.capabilities =
                 {
                     Protocol{test::mouse::ResponseListener::Name_},
                 },
             .source = ChildRef{kResponseListener},
             .targets = {target}},
            {.capabilities =
                 {
                     Protocol{fuchsia::ui::composition::Allocator::Name_},
                     Protocol{fuchsia::ui::composition::Flatland::Name_},
                     Protocol{fuchsia::ui::scenic::Scenic::Name_},
                     // Redirect logging output for the test realm to
                     // the host console output.
                     Protocol{fuchsia::logger::LogSink::Name_},
                     Protocol{fuchsia::scheduler::ProfileProvider::Name_},
                     Protocol{fuchsia::sysmem::Allocator::Name_},
                     Protocol{fuchsia::tracing::provider::Registry::Name_},
                     Protocol{fuchsia::vulkan::loader::Loader::Name_},
                 },
             .source = ParentRef(),
             .targets = {target}},
            {.capabilities = {Protocol{fuchsia::memorypressure::Provider::Name_}},
             .source = ChildRef{kMemoryPressureProvider},
             .targets = {target}},
            {.capabilities = {Protocol{fuchsia::posix::socket::Provider::Name_}},
             .source = ChildRef{kNetstack},
             .targets = {target}}};
  }

  static constexpr auto kMouseInputFlutter = "mouse-input-flutter";
  static constexpr auto kMouseInputFlutterUrl = "#meta/mouse-input-flutter-realm.cm";

 private:
  static constexpr auto kMemoryPressureProvider = "memory_pressure_provider";
  static constexpr auto kMemoryPressureProviderUrl = "#meta/memory_monitor.cm";

  static constexpr auto kNetstack = "netstack";
  static constexpr auto kNetstackUrl = "#meta/netstack.cm";
};

TEST_F(FlutterInputTest, FlutterMouseMove) {
  // Use `ZX_CLOCK_MONOTONIC` to avoid complications due to wall-clock time changes.
  zx::basic_time<ZX_CLOCK_MONOTONIC> input_injection_time(0);

  LaunchClient();
  auto input_synthesis = realm_exposed_services()->Connect<test::inputsynthesis::Mouse>();
  uint32_t device_id = AddMouseDevice(input_synthesis);

  bool injection_initiated = false;
  fuchsia::input::report::MouseInputReport report;
  report.set_movement_x(1);
  report.set_movement_y(2);
  auto ts = static_cast<uint64_t>(zx::clock::get_monotonic().get());
  input_synthesis->SendInputReport(
      device_id, std::move(report), ts, [&injection_initiated](auto result) {
        ASSERT_FALSE(result.is_err()) << "SendInputReport failed " << result.err();
        injection_initiated = true;
      });

  RunLoopUntil([&injection_initiated] { return injection_initiated; });

  RunLoopUntil([this] { return this->response_listener_->SizeOfEvents() == 1; });

  ASSERT_EQ(response_listener_->SizeOfEvents(), 1u);

  auto e = response_listener_->PopEvent();

  // If the first mouse event is cursor movement, Flutter first sends an ADD event with updated
  // location.
  VerifyEvent(e,
              /*expected_x=*/static_cast<double>(display_width()) / 2.f + 1,
              /*expected_y=*/static_cast<double>(display_height()) / 2.f + 2,
              /*expected_buttons=*/0,
              /*expected_type=*/"add", input_injection_time,
              /*component_name=*/"mouse-input-flutter");
}

TEST_F(FlutterInputTest, FlutterMouseDown) {
  // Use `ZX_CLOCK_MONOTONIC` to avoid complications due to wall-clock time changes.
  zx::basic_time<ZX_CLOCK_MONOTONIC> input_injection_time(0);

  LaunchClient();
  auto input_synthesis = realm_exposed_services()->Connect<test::inputsynthesis::Mouse>();
  uint32_t device_id = AddMouseDevice(input_synthesis);

  bool injection_initiated = false;
  fuchsia::input::report::MouseInputReport report;
  report.set_movement_x(0);
  report.set_movement_y(0);
  report.set_pressed_buttons({0});
  auto ts = static_cast<uint64_t>(zx::clock::get_monotonic().get());
  input_synthesis->SendInputReport(
      device_id, std::move(report), ts, [&injection_initiated](auto result) {
        ASSERT_FALSE(result.is_err()) << "SendInputReport failed " << result.err();
        injection_initiated = true;
      });

  RunLoopUntil([&injection_initiated] { return injection_initiated; });
  RunLoopUntil([this] { return this->response_listener_->SizeOfEvents() == 3; });

  ASSERT_EQ(response_listener_->SizeOfEvents(), 3u);

  auto event_add = response_listener_->PopEvent();
  auto event_down = response_listener_->PopEvent();
  auto event_noop_move = response_listener_->PopEvent();

  // If the first mouse event is a button press, Flutter first sends an ADD event with no buttons.
  VerifyEvent(event_add,
              /*expected_x=*/static_cast<double>(display_width()) / 2.f,
              /*expected_y=*/static_cast<double>(display_height()) / 2.f,
              /*expected_buttons=*/0,
              /*expected_type=*/"add", input_injection_time,
              /*component_name=*/"mouse-input-flutter");

  // Then Flutter sends a DOWN pointer event with the buttons we care about.
  VerifyEvent(event_down,
              /*expected_x=*/static_cast<double>(display_width()) / 2.f,
              /*expected_y=*/static_cast<double>(display_height()) / 2.f,
              /*expected_buttons=*/fuchsia::ui::input::kMousePrimaryButton,
              /*expected_type=*/"down", input_injection_time,
              /*component_name=*/"mouse-input-flutter");

  // Then Flutter sends a MOVE pointer event with no new information.
  VerifyEvent(event_noop_move,
              /*expected_x=*/static_cast<double>(display_width()) / 2.f,
              /*expected_y=*/static_cast<double>(display_height()) / 2.f,
              /*expected_buttons=*/fuchsia::ui::input::kMousePrimaryButton,
              /*expected_type=*/"move", input_injection_time,
              /*component_name=*/"mouse-input-flutter");
}

TEST_F(FlutterInputTest, FlutterMouseDownUp) {
  // Use `ZX_CLOCK_MONOTONIC` to avoid complications due to wall-clock time changes.
  zx::basic_time<ZX_CLOCK_MONOTONIC> input_injection_time(0);

  LaunchClient();
  auto input_synthesis = realm_exposed_services()->Connect<test::inputsynthesis::Mouse>();
  uint32_t device_id = AddMouseDevice(input_synthesis);

  bool down_injection_initiated = false;
  fuchsia::input::report::MouseInputReport down_report;
  down_report.set_movement_x(0);
  down_report.set_movement_y(0);
  down_report.set_pressed_buttons({0});
  auto ts = static_cast<uint64_t>(zx::clock::get_monotonic().get());
  input_synthesis->SendInputReport(
      device_id, std::move(down_report), ts, [&down_injection_initiated](auto result) {
        ASSERT_FALSE(result.is_err()) << "SendInputReport failed " << result.err();
        down_injection_initiated = true;
      });

  RunLoopUntil([&down_injection_initiated] { return down_injection_initiated; });
  RunLoopUntil([this] { return this->response_listener_->SizeOfEvents() == 3; });

  ASSERT_EQ(response_listener_->SizeOfEvents(), 3u);

  auto event_add = response_listener_->PopEvent();
  auto event_down = response_listener_->PopEvent();
  auto event_noop_move = response_listener_->PopEvent();

  // If the first mouse event is a button press, Flutter first sends an ADD event with no buttons.
  VerifyEvent(event_add,
              /*expected_x=*/static_cast<double>(display_width()) / 2.f,
              /*expected_y=*/static_cast<double>(display_height()) / 2.f,
              /*expected_buttons=*/0,
              /*expected_type=*/"add", input_injection_time,
              /*component_name=*/"mouse-input-flutter");

  // Then Flutter sends a DOWN pointer event with the buttons we care about.
  VerifyEvent(event_down,
              /*expected_x=*/static_cast<double>(display_width()) / 2.f,
              /*expected_y=*/static_cast<double>(display_height()) / 2.f,
              /*expected_buttons=*/fuchsia::ui::input::kMousePrimaryButton,
              /*expected_type=*/"down", input_injection_time,
              /*component_name=*/"mouse-input-flutter");

  // Then Flutter sends a MOVE pointer event with no new information.
  VerifyEvent(event_noop_move,
              /*expected_x=*/static_cast<double>(display_width()) / 2.f,
              /*expected_y=*/static_cast<double>(display_height()) / 2.f,
              /*expected_buttons=*/fuchsia::ui::input::kMousePrimaryButton,
              /*expected_type=*/"move", input_injection_time,
              /*component_name=*/"mouse-input-flutter");

  bool up_injection_initiated = false;
  fuchsia::input::report::MouseInputReport up_report;
  up_report.set_movement_x(0);
  up_report.set_movement_y(0);
  up_report.set_pressed_buttons({});
  input_synthesis->SendInputReport(
      device_id, std::move(up_report), ts, [&up_injection_initiated](auto result) {
        ASSERT_FALSE(result.is_err()) << "SendInputReport failed " << result.err();
        up_injection_initiated = true;
      });
  RunLoopUntil([&up_injection_initiated] { return up_injection_initiated; });
  RunLoopUntil([this] { return this->response_listener_->SizeOfEvents() == 1; });

  ASSERT_EQ(response_listener_->SizeOfEvents(), 1u);

  auto event_up = response_listener_->PopEvent();
  VerifyEvent(event_up,
              /*expected_x=*/static_cast<double>(display_width()) / 2.f,
              /*expected_y=*/static_cast<double>(display_height()) / 2.f,
              /*expected_buttons=*/0,
              /*expected_type=*/"up", input_injection_time,
              /*component_name=*/"mouse-input-flutter");
}

TEST_F(FlutterInputTest, FlutterMouseDownMoveUp) {
  // Use `ZX_CLOCK_MONOTONIC` to avoid complications due to wall-clock time changes.
  zx::basic_time<ZX_CLOCK_MONOTONIC> input_injection_time(0);

  LaunchClient();
  auto input_synthesis = realm_exposed_services()->Connect<test::inputsynthesis::Mouse>();
  uint32_t device_id = AddMouseDevice(input_synthesis);

  bool down_injection_initiated = false;
  fuchsia::input::report::MouseInputReport down_report;
  down_report.set_movement_x(0);
  down_report.set_movement_y(0);
  down_report.set_pressed_buttons({0});
  auto ts = static_cast<uint64_t>(zx::clock::get_monotonic().get());
  input_synthesis->SendInputReport(
      device_id, std::move(down_report), ts, [&down_injection_initiated](auto result) {
        ASSERT_FALSE(result.is_err()) << "SendInputReport failed " << result.err();
        down_injection_initiated = true;
      });

  RunLoopUntil([&down_injection_initiated] { return down_injection_initiated; });
  RunLoopUntil([&down_injection_initiated] { return down_injection_initiated; });
  RunLoopUntil([this] { return this->response_listener_->SizeOfEvents() == 3; });

  ASSERT_EQ(response_listener_->SizeOfEvents(), 3u);

  auto event_add = response_listener_->PopEvent();
  auto event_down = response_listener_->PopEvent();
  auto event_noop_move = response_listener_->PopEvent();

  // If the first mouse event is a button press, Flutter first sends an ADD event with no buttons.
  VerifyEvent(event_add,
              /*expected_x=*/static_cast<double>(display_width()) / 2.f,
              /*expected_y=*/static_cast<double>(display_height()) / 2.f,
              /*expected_buttons=*/0,
              /*expected_type=*/"add", input_injection_time,
              /*component_name=*/"mouse-input-flutter");

  // Then Flutter sends a DOWN pointer event with the buttons we care about.
  VerifyEvent(event_down,
              /*expected_x=*/static_cast<double>(display_width()) / 2.f,
              /*expected_y=*/static_cast<double>(display_height()) / 2.f,
              /*expected_buttons=*/fuchsia::ui::input::kMousePrimaryButton,
              /*expected_type=*/"down", input_injection_time,
              /*component_name=*/"mouse-input-flutter");

  // Then Flutter sends a MOVE pointer event with no new information.
  VerifyEvent(event_noop_move,
              /*expected_x=*/static_cast<double>(display_width()) / 2.f,
              /*expected_y=*/static_cast<double>(display_height()) / 2.f,
              /*expected_buttons=*/fuchsia::ui::input::kMousePrimaryButton,
              /*expected_type=*/"move", input_injection_time,
              /*component_name=*/"mouse-input-flutter");

  bool move_injection_initiated = false;
  fuchsia::input::report::MouseInputReport move_report;
  // We use `kClickToDragThreshold` to make sure the mouse handler registers movement.
  move_report.set_movement_x(kClickToDragThreshold);
  move_report.set_pressed_buttons({0});
  input_synthesis->SendInputReport(
      device_id, std::move(move_report), ts, [&move_injection_initiated](auto result) {
        ASSERT_FALSE(result.is_err()) << "SendInputReport failed " << result.err();
        move_injection_initiated = true;
      });
  RunLoopUntil([&move_injection_initiated] { return move_injection_initiated; });
  RunLoopUntil([this] { return this->response_listener_->SizeOfEvents() == 1; });

  ASSERT_EQ(response_listener_->SizeOfEvents(), 1u);

  auto event_move = response_listener_->PopEvent();

  VerifyEventLocationOnTheRightOfExpectation(
      event_move,
      /*expected_x_min=*/static_cast<double>(display_width()) / 2.f + 1,
      /*expected_y=*/static_cast<double>(display_height()) / 2.f,
      /*expected_buttons=*/fuchsia::ui::input::kMousePrimaryButton,
      /*expected_type=*/"move", input_injection_time,
      /*component_name=*/"mouse-input-flutter");

  bool up_injection_initiated = false;
  fuchsia::input::report::MouseInputReport up_report;
  up_report.set_movement_x(0);
  up_report.set_movement_y(0);
  up_report.set_pressed_buttons({});
  input_synthesis->SendInputReport(
      device_id, std::move(up_report), ts, [&up_injection_initiated](auto result) {
        ASSERT_FALSE(result.is_err()) << "SendInputReport failed " << result.err();
        up_injection_initiated = true;
      });
  RunLoopUntil([&up_injection_initiated] { return up_injection_initiated; });
  RunLoopUntil([this] { return this->response_listener_->SizeOfEvents() == 1; });

  ASSERT_EQ(response_listener_->SizeOfEvents(), 1u);

  auto event_up = response_listener_->PopEvent();

  VerifyEventLocationOnTheRightOfExpectation(
      event_up,
      /*expected_x_min=*/static_cast<double>(display_width()) / 2.f + 1,
      /*expected_y=*/static_cast<double>(display_height()) / 2.f,
      /*expected_buttons=*/0,
      /*expected_type=*/"up", input_injection_time,
      /*component_name=*/"mouse-input-flutter");
}

class ChromiumInputTest : public MouseInputBase {
 protected:
  std::vector<std::pair<ChildName, LegacyUrl>> GetTestComponents() override {
    return {
        std::make_pair(kWebContextProvider, kWebContextProviderUrl),
    };
  }

  std::vector<std::pair<ChildName, std::string>> GetTestV2Components() override {
    return {
        std::make_pair(kMouseInputChromium, kMouseInputChromiumUrl),
        std::make_pair(kBuildInfoProvider, kBuildInfoProviderUrl),
        std::make_pair(kMemoryPressureProvider, kMemoryPressureProviderUrl),
        std::make_pair(kNetstack, kNetstackUrl),
        std::make_pair(kMockCobalt, kMockCobaltUrl),
    };
  }

  std::vector<Route> GetTestRoutes() override {
    return merge({GetChromiumRoutes(ChildRef{kMouseInputChromium}),
                  {
                      {.capabilities = {Protocol{fuchsia::ui::app::ViewProvider::Name_}},
                       .source = ChildRef{kMouseInputChromium},
                       .targets = {ParentRef()}},
                  }});
  }

  // Routes needed to setup Chromium client.
  static std::vector<Route> GetChromiumRoutes(ChildRef target) {
    return {
        {.capabilities =
             {
                 Protocol{fuchsia::ui::composition::Allocator::Name_},
                 Protocol{fuchsia::ui::composition::Flatland::Name_},
                 Protocol{fuchsia::vulkan::loader::Loader::Name_},
             },
         .source = ParentRef(),
         .targets = {target}},
        {.capabilities = {Protocol{test::mouse::ResponseListener::Name_}},
         .source = ChildRef{kResponseListener},
         .targets = {target}},
        {.capabilities = {Protocol{fuchsia::memorypressure::Provider::Name_}},
         .source = ChildRef{kMemoryPressureProvider},
         .targets = {target}},
        {.capabilities = {Protocol{fuchsia::netstack::Netstack::Name_}},
         .source = ChildRef{kNetstack},
         .targets = {target}},
        {.capabilities = {Protocol{fuchsia::net::interfaces::State::Name_}},
         .source = ChildRef{kNetstack},
         .targets = {target}},
        {.capabilities = {Protocol{fuchsia::accessibility::semantics::SemanticsManager::Name_}},
         .source = ParentRef(),
         .targets = {target}},
        {.capabilities = {Protocol{fuchsia::web::ContextProvider::Name_}},
         .source = ChildRef{kWebContextProvider},
         .targets = {target}},
        {.capabilities = {Protocol{fuchsia::sys::Environment::Name_},
                          Protocol{fuchsia::logger::LogSink::Name_}},
         .source = ParentRef(),
         .targets = {target}},
        {.capabilities = {Protocol{fuchsia::cobalt::LoggerFactory::Name_}},
         .source = ChildRef{kMockCobalt},
         .targets = {ChildRef{kMemoryPressureProvider}}},
        {.capabilities = {Protocol{fuchsia::sysmem::Allocator::Name_}},
         .source = ParentRef(),
         .targets = {ChildRef{kMemoryPressureProvider}, ChildRef{kMouseInputChromium}}},
        {.capabilities = {Protocol{fuchsia::scheduler::ProfileProvider::Name_}},
         .source = ParentRef(),
         .targets = {ChildRef{kMemoryPressureProvider}}},
        {.capabilities = {Protocol{fuchsia::kernel::RootJobForInspect::Name_}},
         .source = ParentRef(),
         .targets = {ChildRef{kMemoryPressureProvider}}},
        {.capabilities = {Protocol{fuchsia::kernel::Stats::Name_}},
         .source = ParentRef(),
         .targets = {ChildRef{kMemoryPressureProvider}}},
        {.capabilities = {Protocol{fuchsia::tracing::provider::Registry::Name_}},
         .source = ParentRef(),
         .targets = {ChildRef{kMemoryPressureProvider}}},
        {.capabilities = {Protocol{fuchsia::ui::scenic::Scenic::Name_}},
         .source = ParentRef(),
         .targets = {target}},
        {.capabilities = {Protocol{fuchsia::posix::socket::Provider::Name_}},
         .source = ChildRef{kNetstack},
         .targets = {target}},
        {.capabilities = {Protocol{fuchsia::buildinfo::Provider::Name_}},
         .source = ChildRef{kBuildInfoProvider},
         .targets = {target, ChildRef{kWebContextProvider}}},
    };
  }

  // TODO(fxbug.dev/58322): EnsureMouseIsReadyAndGetPosition will send a mouse click
  // (down and up) and wait for response to ensure the mouse is ready to use. We will retry a mouse
  // click if we can not get the mouseup response in small timeout. This function returns
  // the cursor position in WebEngine coordinate system.
  Position EnsureMouseIsReadyAndGetPosition(
      fidl::InterfacePtr<test::inputsynthesis::Mouse>& input_synthesis, uint32_t device_id) {
    for (int retry = 0; retry < kMaxRetry; retry++) {
      // Mouse down and up.
      {
        auto ts = static_cast<uint64_t>(zx::clock::get_monotonic().get());
        fuchsia::input::report::MouseInputReport report;
        report.set_pressed_buttons({0});
        SendMouseEvent(input_synthesis, device_id, std::move(report), ts);
      }
      {
        auto ts = static_cast<uint64_t>(zx::clock::get_monotonic().get());
        fuchsia::input::report::MouseInputReport report;
        report.set_pressed_buttons({});
        SendMouseEvent(input_synthesis, device_id, std::move(report), ts);
      }

      RunLoopWithTimeoutOrUntil(
          [this] {
            return this->response_listener_->SizeOfEvents() > 0 &&
                   this->response_listener_->LastEvent().type() == "mouseup";
          },
          kFirstEventRetryInterval);
      if (response_listener_->SizeOfEvents() > 0 &&
          response_listener_->LastEvent().type() == "mouseup") {
        Position p;
        p.x = response_listener_->LastEvent().local_x();
        p.y = response_listener_->LastEvent().local_y();
        response_listener_->ClearEvents();
        return p;
      }
    }

    FX_LOGS(FATAL) << "Can not get mouse click in max retries " << kMaxRetry;
    return Position{};
  }

  void LaunchWebEngineClient() {
    LaunchClient();
    // In WebEngine |is_rendering| only indicated WebEngine is rendering but input tests require JS
    // loaded (JS event callback registered).
    RunLoopUntil([this]() { return this->response_listener()->IsWebEngineReady(); });

    RunLoopUntil([this] { return ui_test_manager_->ClientViewIsFocused(); });
  }

  static constexpr auto kMouseInputChromium = "mouse-input-chromium";
  static constexpr auto kMouseInputChromiumUrl = "#meta/mouse-input-chromium.cm";

  static constexpr auto kWebContextProvider = "web_context_provider";
  static constexpr auto kWebContextProviderUrl =
      "fuchsia-pkg://fuchsia.com/web_engine#meta/context_provider.cmx";

  static constexpr auto kMemoryPressureProvider = "memory_pressure_provider";
  static constexpr auto kMemoryPressureProviderUrl = "#meta/memory_monitor.cm";

  static constexpr auto kNetstack = "netstack";
  static constexpr auto kNetstackUrl = "#meta/netstack.cm";

  static constexpr auto kBuildInfoProvider = "build_info_provider";
  static constexpr auto kBuildInfoProviderUrl = "#meta/fake_build_info.cm";

  static constexpr auto kMockCobalt = "cobalt";
  static constexpr auto kMockCobaltUrl = "#meta/mock_cobalt.cm";

  // The first event to WebEngine may lost, see EnsureMouseIsReadyAndGetPosition. Retry to ensure
  // WebEngine is ready to process events.
  static constexpr auto kFirstEventRetryInterval = zx::sec(1);

  // To avoid retry to timeout, limit 10 retries, if still not ready, fail it with meaningful error.
  static const int kMaxRetry = 10;
};

TEST_F(ChromiumInputTest, ChromiumMouseMove) {
  LaunchWebEngineClient();

  auto input_synthesis = realm_exposed_services()->Connect<test::inputsynthesis::Mouse>();
  uint32_t device_id = AddMouseDevice(input_synthesis);
  auto initial_position = EnsureMouseIsReadyAndGetPosition(input_synthesis, device_id);

  double initial_x = initial_position.x;
  double initial_y = initial_position.y;

  auto input_injection_time = zx::clock::get_monotonic();
  auto ts = static_cast<uint64_t>(input_injection_time.get());
  fuchsia::input::report::MouseInputReport report;
  report.set_movement_x(5);
  report.set_movement_y(0);

  SendMouseEvent(input_synthesis, device_id, std::move(report), ts);

  RunLoopUntil([this] { return this->response_listener_->SizeOfEvents() == 1; });

  auto event_move = response_listener_->PopEvent();

  VerifyEventLocationOnTheRightOfExpectation(event_move,
                                             /*expected_x_min=*/initial_x,
                                             /*expected_y=*/initial_y,
                                             /*expected_buttons=*/0,
                                             /*expected_type=*/"mousemove", input_injection_time,
                                             /*component_name=*/"mouse-input-chromium");
}

TEST_F(ChromiumInputTest, ChromiumMouseDownMoveUp) {
  LaunchWebEngineClient();

  auto input_synthesis = realm_exposed_services()->Connect<test::inputsynthesis::Mouse>();
  uint32_t device_id = AddMouseDevice(input_synthesis);
  auto initial_position = EnsureMouseIsReadyAndGetPosition(input_synthesis, device_id);

  double initial_x = initial_position.x;
  double initial_y = initial_position.y;

  auto down_injection_time = zx::clock::get_monotonic();
  {
    auto ts = static_cast<uint64_t>(down_injection_time.get());
    fuchsia::input::report::MouseInputReport report;
    report.set_pressed_buttons({0});
    SendMouseEvent(input_synthesis, device_id, std::move(report), ts);
  }
  auto move_injection_time = zx::clock::get_monotonic();
  {
    auto ts = static_cast<uint64_t>(move_injection_time.get());
    fuchsia::input::report::MouseInputReport report;
    report.set_pressed_buttons({0});
    report.set_movement_x(kClickToDragThreshold);
    report.set_movement_y(0);
    SendMouseEvent(input_synthesis, device_id, std::move(report), ts);
  }
  auto up_injection_time = zx::clock::get_monotonic();
  {
    auto ts = static_cast<uint64_t>(up_injection_time.get());
    fuchsia::input::report::MouseInputReport report;
    report.set_pressed_buttons({});
    SendMouseEvent(input_synthesis, device_id, std::move(report), ts);
  }

  RunLoopUntil([this] { return this->response_listener_->SizeOfEvents() == 3; });

  auto event_down = response_listener_->PopEvent();
  auto event_move = response_listener_->PopEvent();
  auto event_up = response_listener_->PopEvent();

  VerifyEvent(event_down,
              /*expected_x=*/initial_x,
              /*expected_y=*/initial_y,
              /*expected_buttons=*/1,
              /*expected_type=*/"mousedown", down_injection_time,
              /*component_name=*/"mouse-input-chromium");
  VerifyEventLocationOnTheRightOfExpectation(event_move,
                                             /*expected_x_min=*/initial_x,
                                             /*expected_y=*/initial_y,
                                             /*expected_buttons=*/1,
                                             /*expected_type=*/"mousemove", move_injection_time,
                                             /*component_name=*/"mouse-input-chromium");
  VerifyEvent(event_up,
              /*expected_x=*/event_move.local_x(),
              /*expected_y=*/initial_y,
              /*expected_buttons=*/0,
              /*expected_type=*/"mouseup", up_injection_time,
              /*component_name=*/"mouse-input-chromium");
}

}  // namespace