// Copyright 2022 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/views/interaction/interaction_test_util_mouse.h"

#include <memory>
#include <utility>
#include <variant>

#include "base/auto_reset.h"
#include "base/check.h"
#include "base/containers/contains.h"
#include "base/functional/callback_helpers.h"
#include "base/location.h"
#include "base/logging.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/run_loop.h"
#include "base/scoped_observation.h"
#include "base/task/single_thread_task_runner.h"
#include "base/threading/thread.h"
#include "build/build_config.h"
#include "ui/base/test/ui_controls.h"
#include "ui/gfx/native_ui_types.h"
#include "ui/views/widget/widget.h"

#if defined(USE_AURA)
#include "ui/aura/client/drag_drop_client.h"
#include "ui/aura/client/drag_drop_client_observer.h"
#include "ui/aura/window.h"
#include "ui/aura/window_observer.h"
#endif  // defined(USE_AURA)

// Currently, touch is only supported on ChromeOS Ash.
#if BUILDFLAG(IS_CHROMEOS)
#define TOUCH_INPUT_SUPPORTED 1
#else
#define TOUCH_INPUT_SUPPORTED 0
#endif

namespace views::test {

namespace {
raw_ptr<InteractionTestUtilMouse> g_current_mouse_util = nullptr;

void PostTask(base::OnceClosure task) {
  base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(FROM_HERE,
                                                              std::move(task));
}

#if TOUCH_INPUT_SUPPORTED

ui_controls::TouchType GetTouchAction(ui_controls::MouseButtonState state) {
  switch (state) {
    case ui_controls::DOWN:
      return ui_controls::kTouchPress;
    case ui_controls::UP:
      return ui_controls::kTouchRelease;
  }
}

int GetTouchCount(ui_controls::MouseButton button) {
  switch (button) {
    case ui_controls::LEFT:
      return 1;
    case ui_controls::MIDDLE:
      return 3;
    case ui_controls::RIGHT:
      return 2;
  }
}

#endif  // TOUCH_INPUT_SUPPORTED

}  // namespace

InteractionTestUtilMouse::GestureParams::GestureParams() = default;
InteractionTestUtilMouse::GestureParams::GestureParams(
    gfx::NativeWindow window_hint_,
    bool force_async_)
    : window_hint(window_hint_), force_async(force_async_) {}
InteractionTestUtilMouse::GestureParams::GestureParams(const GestureParams&) =
    default;
InteractionTestUtilMouse::GestureParams&
InteractionTestUtilMouse::GestureParams::operator=(const GestureParams&) =
    default;
InteractionTestUtilMouse::GestureParams::GestureParams(
    GestureParams&&) noexcept = default;
InteractionTestUtilMouse::GestureParams&
InteractionTestUtilMouse::GestureParams::operator=(GestureParams&&) noexcept =
    default;
InteractionTestUtilMouse::GestureParams::~GestureParams() = default;

#if defined(USE_AURA)

// Ends any drag currently in progress or that starts during this object's
// lifetime. This is needed because the drag controller can get out of sync with
// mouse event handling - especially when running ChromeOS-on-Linux. This can
// result in weird test hangs/timeouts during mouse-up after a drag, or (more
// insidiously) during test shutdown.
//
// Once started, the DragEnder will kill any drags that start until:
//  - Stop() is called.
//  - The Aura window it is watching goes away.
//  - The DragEnder is destroyed (which should happen no earlier than the end of
//    ShutDownOnMainThread()).
class InteractionTestUtilMouse::DragEnder
    : public aura::client::DragDropClientObserver,
      public aura::WindowObserver {
 public:
  explicit DragEnder(aura::Window* window) : window_(window) {
    window_observation_.Observe(window);
  }

  ~DragEnder() override = default;

  // Either cancels a current drag, or starts observing for a future drag start
  // event (at which point the drag will be canceled).
  void Start() {
    if (CancelDragNow() || drag_client_observation_.IsObserving()) {
      return;
    }
    // Only Ash actually supports observing the drag-drop client. Therefore, on
    // other platforms, only direct cancel is possible.
#if BUILDFLAG(IS_CHROMEOS)
    if (auto* const client = GetClient()) {
      drag_client_observation_.Observe(client);
    }
#endif
  }

  // Stops any ongoing observation of drag start events.
  void Stop() { drag_client_observation_.Reset(); }

  // Cancels any drag that is currently happening, but does not watch for future
  // drag start events.
  bool CancelDragNow() {
    if (auto* const client = GetClient()) {
      if (client->IsDragDropInProgress()) {
        LOG(WARNING)
            << "InteractionTestUtilMouse: Force-canceling spurious drag "
               "operation.\n"
            << "This can happen when the drag controller gets out of sync with "
               "mouse events being sent by the test, and is especially likely "
               "on  ChromeOS-on-Linux.\n"
            << "This is not necessarily a serious error if the test functions "
               "normally; however, if you see this too often or your test "
               "flakes as a result of the cancel you may need to restructure "
               "the test so that you can be sure the drag has started before "
               "attempting to invoke ReleaseMouse().";
        client->DragCancel();
        return true;
      }
    }
    return false;
  }

  base::WeakPtr<DragEnder> GetWeakPtr() {
    return weak_ptr_factory_.GetWeakPtr();
  }

 private:
  // aura::client::DragDropClientObserver:
  void OnDragStarted() override {
    drag_client_observation_.Reset();
    PostTask(base::BindOnce(base::IgnoreResult(&DragEnder::CancelDragNow),
                            weak_ptr_factory_.GetWeakPtr()));
  }

  // aura::WindowObserver:
  void OnWindowDestroying(aura::Window* window) override {
    DCHECK_EQ(window_, window);
    drag_client_observation_.Reset();
    window_observation_.Reset();
    window_ = nullptr;
  }

  aura::client::DragDropClient* GetClient() {
    return window_ ? aura::client::GetDragDropClient(window_->GetRootWindow())
                   : nullptr;
  }

  // Since there is no "DragDropClientDestroying" event, use the aura::Window as
  // a proxy for the existence of the DragDropClient, and unregister listeners
  // when the window goes away. If this is not done, UAFs may happen when the
  // scoped observation of the drag client goes away.
  raw_ptr<aura::Window> window_;
  base::ScopedObservation<aura::Window, aura::WindowObserver>
      window_observation_{this};
  base::ScopedObservation<aura::client::DragDropClient,
                          aura::client::DragDropClientObserver>
      drag_client_observation_{this};
  base::WeakPtrFactory<DragEnder> weak_ptr_factory_{this};
};

#endif  // defined(USE_AURA)

InteractionTestUtilMouse::InteractionTestUtilMouse(views::Widget* widget)
    : InteractionTestUtilMouse(widget->GetNativeWindow()) {}

InteractionTestUtilMouse::~InteractionTestUtilMouse() {
  CHECK(!performing_gestures_)
      << "InteractionTestUtilMouse destroyed with pending actions.";
  LOG_IF(ERROR, g_current_mouse_util != this)
      << "Expected |this| to be current InteractionTestUtilMouse.";
  g_current_mouse_util = nullptr;
}

// static
InteractionTestUtilMouse::MouseGesture InteractionTestUtilMouse::MoveTo(
    gfx::Point point) {
  return MouseGesture(point);
}

// static
InteractionTestUtilMouse::MouseGesture InteractionTestUtilMouse::MouseDown(
    ui_controls::MouseButton button,
    int modifier_keys) {
  return MouseButtonGesture(button, ui_controls::DOWN, modifier_keys);
}

// static
InteractionTestUtilMouse::MouseGesture InteractionTestUtilMouse::MouseUp(
    ui_controls::MouseButton button,
    int modifier_keys) {
  return MouseButtonGesture(button, ui_controls::UP, modifier_keys);
}

// static
InteractionTestUtilMouse::MouseGestures InteractionTestUtilMouse::Click(
    ui_controls::MouseButton button,
    int modifier_keys) {
  return MouseGestures{MouseDown(button, modifier_keys),
                       MouseUp(button, modifier_keys)};
}

// static
InteractionTestUtilMouse::MouseGestures InteractionTestUtilMouse::DragAndHold(
    gfx::Point destination) {
  return MouseGestures{MouseDown(ui_controls::LEFT), MoveTo(destination)};
}

// static
InteractionTestUtilMouse::MouseGestures
InteractionTestUtilMouse::DragAndRelease(gfx::Point destination) {
  return MouseGestures{MouseDown(ui_controls::LEFT), MoveTo(destination),
                       MouseUp(ui_controls::LEFT)};
}

bool InteractionTestUtilMouse::ShouldCancelDrag() const {
#if defined(USE_AURA)
  return dragging_;
#else
  return false;
#endif
}

void InteractionTestUtilMouse::CancelFutureDrag() {
#if defined(USE_AURA)
  // Allow the system to finish processing any mouse input before force-
  // canceling any ongoing drag. It's possible that a drag that was queued to
  // complete simply hasn't yet.
  PostTask(base::BindOnce(&DragEnder::Start, drag_ender_->GetWeakPtr()));
#endif
}

void InteractionTestUtilMouse::CancelDragNow() {
#if defined(USE_AURA)
  CHECK(!dragging_);
  drag_ender_->Stop();
  drag_ender_->CancelDragNow();
#endif
}

bool InteractionTestUtilMouse::SendButtonPress(
    const MouseButtonGesture& gesture,
    const GestureParams& params,
    base::OnceClosure on_complete) {
  if (!params.force_async) {
#if TOUCH_INPUT_SUPPORTED
    if (touch_mode_) {
      return ui_controls::SendTouchEventsNotifyWhenDone(
          GetTouchAction(gesture.button_state), GetTouchCount(gesture.button),
          touch_hover_point_.x(), touch_hover_point_.y(),
          std::move(on_complete));
    }
#endif  // TOUCH_INPUT_SUPPORTED
    return ui_controls::SendMouseEventsNotifyWhenDone(
        gesture.button, gesture.button_state, std::move(on_complete),
        gesture.modifier_keys, params.window_hint);
  }

#if TOUCH_INPUT_SUPPORTED
  if (touch_mode_) {
    PostTask(base::BindOnce(
        [](base::WeakPtr<InteractionTestUtilMouse> util,
           base::OnceClosure on_complete, MouseButtonGesture gesture,
           gfx::Point target) {
          if (!util) {
            return;
          }
          CHECK(ui_controls::SendTouchEventsNotifyWhenDone(
              GetTouchAction(gesture.button_state),
              GetTouchCount(gesture.button), target.x(), target.y(),
              std::move(on_complete)));
        },
        weak_ptr_factory_.GetWeakPtr(), std::move(on_complete), gesture,
        touch_hover_point_));
    return true;
  }
#endif  // TOUCH_INPUT_SUPPORTED

  PostTask(base::BindOnce(
      [](base::WeakPtr<InteractionTestUtilMouse> util,
         base::OnceClosure on_complete, MouseButtonGesture gesture,
         gfx::NativeWindow window_hint) {
        if (!util) {
          return;
        }
        CHECK(ui_controls::SendMouseEventsNotifyWhenDone(
            gesture.button, gesture.button_state, std::move(on_complete),
            gesture.modifier_keys, window_hint));
      },
      weak_ptr_factory_.GetWeakPtr(), std::move(on_complete), gesture,
      params.window_hint));

  return true;
}

bool InteractionTestUtilMouse::SendMove(const MouseMoveGesture& gesture,
                                        const GestureParams& params,
                                        base::OnceClosure on_complete) {
#if TOUCH_INPUT_SUPPORTED
  if (touch_mode_) {
    // Need to remember where our finger is.
    touch_hover_point_ = gesture;
    // If no fingers are down, there's nothing to do.
    if (buttons_down_.empty()) {
      std::move(on_complete).Run();
      return true;
    }
    // Should never have two different sets of fingers down at once.
    CHECK_EQ(1U, buttons_down_.size());
  }
#endif  // TOUCH_INPUT_SUPPORTED
  if (!params.force_async) {
#if TOUCH_INPUT_SUPPORTED
    if (touch_mode_) {
      return ui_controls::SendTouchEventsNotifyWhenDone(
          ui_controls::kTouchMove, GetTouchCount(*buttons_down_.begin()),
          gesture.x(), gesture.y(), std::move(on_complete));
    }
#endif  // TOUCH_INPUT_SUPPORTED
    return ui_controls::SendMouseMoveNotifyWhenDone(
        gesture.x(), gesture.y(), std::move(on_complete), params.window_hint);
  }

#if TOUCH_INPUT_SUPPORTED
  if (touch_mode_) {
    PostTask(base::BindOnce(
        [](base::WeakPtr<InteractionTestUtilMouse> util,
           base::OnceClosure on_complete, MouseMoveGesture gesture) {
          if (!util) {
            return;
          }
          const int touch_count = GetTouchCount(*util->buttons_down_.begin());
          CHECK(ui_controls::SendTouchEventsNotifyWhenDone(
              ui_controls::kTouchMove, touch_count, gesture.x(), gesture.y(),
              std::move(on_complete)));
        },
        weak_ptr_factory_.GetWeakPtr(), std::move(on_complete), gesture));
    return true;
  }
#endif  // TOUCH_INPUT_SUPPORTED

  PostTask(base::BindOnce(
      [](base::WeakPtr<InteractionTestUtilMouse> util,
         base::OnceClosure on_complete, MouseMoveGesture gesture,
         gfx::NativeWindow window_hint) {
        if (!util) {
          return;
        }
        CHECK(ui_controls::SendMouseMoveNotifyWhenDone(
            gesture.x(), gesture.y(), std::move(on_complete), window_hint));
      },
      weak_ptr_factory_.GetWeakPtr(), std::move(on_complete), gesture,
      params.window_hint));

  return true;
}

bool InteractionTestUtilMouse::SetTouchMode(bool touch_mode) {
  if (touch_mode == touch_mode_) {
    return true;
  }
  CHECK(buttons_down_.empty())
      << "Cannot toggle touch mode when buttons or fingers are down.";
#if TOUCH_INPUT_SUPPORTED
  touch_mode_ = touch_mode;
  return true;
#else
  LOG(WARNING) << "Touch mode not supported on this platform.";
  return false;
#endif
}

bool InteractionTestUtilMouse::GetTouchMode() const {
  return touch_mode_;
}

bool InteractionTestUtilMouse::PerformGesturesImpl(const GestureParams& params,
                                                   MouseGestures gestures) {
  CHECK(!gestures.empty());
  CHECK(!performing_gestures_);
  base::AutoReset<bool> performing_gestures(&performing_gestures_, true);
  canceled_ = false;
  for (auto& gesture : gestures) {
    if (canceled_) {
      break;
    }

    base::RunLoop run_loop{base::RunLoop::Type::kNestableTasksAllowed};
    if (MouseButtonGesture* const button =
            std::get_if<MouseButtonGesture>(&gesture)) {
      switch (button->button_state) {
        case ui_controls::UP: {
          CHECK(buttons_down_.erase(button->button));
          base::OnceClosure on_complete =
              params.force_async ? base::DoNothing() : run_loop.QuitClosure();
          if (ShouldCancelDrag()) {
            // This will bail out of any nested drag-drop run loop, allowing
            // the code to proceed even if the drag somehow starts while the
            // mouse-up is being processed.
            on_complete = std::move(on_complete)
                              .Then(base::BindOnce(
                                  &InteractionTestUtilMouse::CancelFutureDrag,
                                  weak_ptr_factory_.GetWeakPtr()));
          }
#if defined(USE_AURA)
          dragging_ = false;
#endif
          if (!SendButtonPress(*button, params, std::move(on_complete))) {
            LOG(ERROR) << "Mouse button " << button->button << " up failed.";
            return false;
          }
          if (!params.force_async) {
            run_loop.Run();
          }
          break;
        }
        case ui_controls::DOWN:
#if TOUCH_INPUT_SUPPORTED
          CHECK(!touch_mode_ || buttons_down_.empty())
              << "In touch mode, only one set of fingers may be down at any "
                 "given time.";
#endif
          CHECK(buttons_down_.insert(button->button).second);
#if BUILDFLAG(IS_MAC)
          if (!params.force_async && button->button == ui_controls::RIGHT) {
            LOG(WARNING)
                << "InteractionTestUtilMouse::PerformGestures() - "
                   "Important note:\n"
                << "Because right-clicking on Mac typically results in a "
                   "context menu, and because some (but not all) context menus "
                   "on Mac are native and take over the main message loop, "
                   "right-clicking could cause the test to hang.\n"
                << "If you notice your test hangs on Mac, use "
                   "MayInvolveNativeContextMenu() and minimize the number of "
                   "test "
                   "steps performed while the context menu is open.";
          }
#endif
          CancelDragNow();
          if (!SendButtonPress(*button, params,
                               params.force_async ? base::DoNothing()
                                                  : run_loop.QuitClosure())) {
            LOG(ERROR) << "Mouse button " << button->button << " down failed.";
            return false;
          }

          if (!params.force_async) {
            run_loop.Run();
          }
          break;
      }
    } else {
      const auto& move = std::get<MouseMoveGesture>(gesture);
#if defined(USE_AURA)
      if (!buttons_down_.empty()) {
        CHECK(base::Contains(buttons_down_, ui_controls::LEFT));
        dragging_ = true;
      }
#endif
      if (!SendMove(move, params,
                    params.force_async ? base::DoNothing()
                                       : run_loop.QuitClosure())) {
        LOG(ERROR) << "Mouse move to " << move.ToString() << " failed.";
        return false;
      }

      if (!params.force_async) {
        run_loop.Run();
      }
    }
  }

  return !canceled_;
}

void InteractionTestUtilMouse::CancelAllGestures() {
  weak_ptr_factory_.InvalidateWeakPtrs();
  canceled_ = true;

#if TOUCH_INPUT_SUPPORTED
  if (touch_mode_ && !buttons_down_.empty()) {
    // Should never get in a state where multiple finger combinations are down
    // at the same time.
    CHECK_EQ(1U, buttons_down_.size());
    const auto& button = *buttons_down_.begin();
    if (!ui_controls::SendTouchEvents(
            ui_controls::kTouchRelease, GetTouchCount(button),
            touch_hover_point_.x(), touch_hover_point_.y())) {
      LOG(WARNING) << "Unable to send touch up.";
    }
    buttons_down_.clear();
  }
#endif  // TOUCH_INPUT_SUPPORTED

  // Now that no additional actions will happen, release all mouse buttons.
  for (ui_controls::MouseButton button : buttons_down_) {
    if (!ui_controls::SendMouseEvents(button, ui_controls::UP)) {
      LOG(WARNING) << "Unable to release mouse button " << button;
    }
  }
  buttons_down_.clear();

  // Maybe handle dragging stopped.
  if (ShouldCancelDrag()) {
    CancelFutureDrag();
  }
}

InteractionTestUtilMouse::InteractionTestUtilMouse(gfx::NativeWindow window)
#if defined(USE_AURA)
    : drag_ender_(std::make_unique<DragEnder>(window))
#endif
{
  CHECK(window);
  CHECK(!g_current_mouse_util)
      << "Cannot have multiple overlapping InteractionTestUtilMouse instances";
  g_current_mouse_util = this;
}

// static
void InteractionTestUtilMouse::AddGestures(MouseGestures& gestures,
                                           MouseGesture to_add) {
  gestures.emplace_back(std::move(to_add));
}

// static
void InteractionTestUtilMouse::AddGestures(MouseGestures& gestures,
                                           MouseGestures to_add) {
  for (auto& gesture : to_add) {
    gestures.emplace_back(std::move(gesture));
  }
}

}  // namespace views::test