// Copyright 2020 The Chromium 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 "third_party/blink/renderer/platform/widget/input/elastic_overscroll_controller_bezier.h"

#include "cc/input/input_handler.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/blink/public/common/input/web_input_event.h"
#include "third_party/blink/public/common/input/web_mouse_wheel_event.h"
#include "ui/gfx/geometry/vector2d_conversions.h"

namespace blink {

using gfx::Size;
using gfx::Vector2dF;
using PhaseState = WebGestureEvent::InertialPhaseState;

class MockScrollElasticityHelper : public cc::ScrollElasticityHelper {
 public:
  MockScrollElasticityHelper() = default;
  ~MockScrollElasticityHelper() override = default;

  // cc::ScrollElasticityHelper implementation:
  Size ScrollBounds() const override { return Size(1000, 1000); }
  bool IsUserScrollable() const override { return is_user_scrollable_; }
  void SetUserScrollable(bool is_user_scrollable) {
    is_user_scrollable_ = is_user_scrollable;
  }
  Vector2dF StretchAmount() const override { return stretch_amount_; }
  void SetStretchAmount(const Vector2dF& stretch_amount) override {
    stretch_amount_ = stretch_amount;
  }
  void ScrollBy(const Vector2dF& delta) override {
    scroll_offset_ += gfx::ScrollOffset(delta);
  }
  void RequestOneBeginFrame() override {}
  gfx::ScrollOffset ScrollOffset() const override { return scroll_offset_; }
  gfx::ScrollOffset MaxScrollOffset() const override {
    return max_scroll_offset_;
  }

  void SetScrollOffsetAndMaxScrollOffset(
      const gfx::ScrollOffset& scroll_offset,
      const gfx::ScrollOffset& max_scroll_offset) {
    scroll_offset_ = scroll_offset;
    max_scroll_offset_ = max_scroll_offset;
  }

 private:
  bool is_user_scrollable_ = true;
  Vector2dF stretch_amount_;
  gfx::ScrollOffset scroll_offset_, max_scroll_offset_;
};

class ElasticOverscrollControllerBezierTest : public testing::Test {
 public:
  ElasticOverscrollControllerBezierTest() : controller_(&helper_) {}
  ~ElasticOverscrollControllerBezierTest() override = default;

  void SetUp() override {}

  void SendGestureScrollBegin(PhaseState inertialPhase) {
    WebGestureEvent event(WebInputEvent::Type::kGestureScrollBegin,
                          WebInputEvent::kNoModifiers, base::TimeTicks(),
                          WebGestureDevice::kTouchpad);
    event.data.scroll_begin.inertial_phase = inertialPhase;

    controller_.ObserveGestureEventAndResult(event,
                                             cc::InputHandlerScrollResult());
  }

  void SendGestureScrollUpdate(PhaseState inertialPhase,
                               const Vector2dF& unused_scroll_delta) {
    blink::WebGestureEvent event(WebInputEvent::Type::kGestureScrollUpdate,
                                 WebInputEvent::kNoModifiers, base::TimeTicks(),
                                 blink::WebGestureDevice::kTouchpad);
    event.data.scroll_update.inertial_phase = inertialPhase;
    cc::InputHandlerScrollResult scroll_result;
    scroll_result.did_overscroll_root = !unused_scroll_delta.IsZero();
    scroll_result.unused_scroll_delta = unused_scroll_delta;

    controller_.ObserveGestureEventAndResult(event, scroll_result);
  }
  void SendGestureScrollEnd(base::TimeTicks time = base::TimeTicks::Now()) {
    WebGestureEvent event(WebInputEvent::Type::kGestureScrollEnd,
                          WebInputEvent::kNoModifiers, time,
                          WebGestureDevice::kTouchpad);

    controller_.ObserveGestureEventAndResult(event,
                                             cc::InputHandlerScrollResult());
  }

  MockScrollElasticityHelper helper_;
  ElasticOverscrollControllerBezier controller_;
};

// Tests that the scroller "stretches" as expected when an overscroll occurs.
TEST_F(ElasticOverscrollControllerBezierTest, VerifyOverscrollStretch) {
  // Test vertical overscroll.
  SendGestureScrollBegin(PhaseState::kNonMomentum);
  EXPECT_EQ(Vector2dF(0, 0), helper_.StretchAmount());
  SendGestureScrollUpdate(PhaseState::kNonMomentum, Vector2dF(0, -100));
  EXPECT_EQ(Vector2dF(0, -19), helper_.StretchAmount());
  SendGestureScrollUpdate(PhaseState::kNonMomentum, Vector2dF(0, 100));
  EXPECT_EQ(Vector2dF(0, 0), helper_.StretchAmount());
  SendGestureScrollEnd();

  // Test horizontal overscroll.
  SendGestureScrollBegin(PhaseState::kNonMomentum);
  EXPECT_EQ(Vector2dF(0, 0), helper_.StretchAmount());
  SendGestureScrollUpdate(PhaseState::kNonMomentum, Vector2dF(-100, 0));
  EXPECT_EQ(Vector2dF(-19, 0), helper_.StretchAmount());
  SendGestureScrollUpdate(PhaseState::kNonMomentum, Vector2dF(100, 0));
  EXPECT_EQ(Vector2dF(0, 0), helper_.StretchAmount());
  SendGestureScrollEnd();
}

// Verify that ReconcileStretchAndScroll reduces the overscrolled delta.
TEST_F(ElasticOverscrollControllerBezierTest, ReconcileStretchAndScroll) {
  // Test vertical overscroll.
  SendGestureScrollBegin(PhaseState::kNonMomentum);
  helper_.SetScrollOffsetAndMaxScrollOffset(gfx::ScrollOffset(0, 0),
                                            gfx::ScrollOffset(100, 100));
  SendGestureScrollUpdate(PhaseState::kNonMomentum, Vector2dF(0, -100));
  EXPECT_EQ(Vector2dF(0, -19), helper_.StretchAmount());
  helper_.ScrollBy(Vector2dF(0, 1));
  controller_.ReconcileStretchAndScroll();
  EXPECT_EQ(Vector2dF(0, -18), helper_.StretchAmount());

  // Reset vertical overscroll.
  helper_.SetStretchAmount(Vector2dF(0, 0));
  SendGestureScrollEnd(base::TimeTicks::Now());

  // Test horizontal overscroll.
  SendGestureScrollBegin(PhaseState::kNonMomentum);
  helper_.SetScrollOffsetAndMaxScrollOffset(gfx::ScrollOffset(0, 0),
                                            gfx::ScrollOffset(100, 100));
  SendGestureScrollUpdate(PhaseState::kNonMomentum, Vector2dF(-100, 0));
  EXPECT_EQ(Vector2dF(-19, 0), helper_.StretchAmount());
  helper_.ScrollBy(Vector2dF(1, 0));
  controller_.ReconcileStretchAndScroll();
  EXPECT_EQ(Vector2dF(-18, 0), helper_.StretchAmount());
}

// Tests that momentum_animation_start_time_ doesn't get reset when the
// overscroll animation is ticking and the scroller is diagonally overscrolled.
TEST_F(ElasticOverscrollControllerBezierTest, VerifyInitialStretchDelta) {
  // Set up the state to be in kStateMomentumAnimated with some amount of
  // diagonal stretch.
  controller_.state_ =
      ElasticOverscrollController::State::kStateMomentumAnimated;
  helper_.SetStretchAmount(Vector2dF(5, 10));
  helper_.SetScrollOffsetAndMaxScrollOffset(gfx::ScrollOffset(0, 20),
                                            gfx::ScrollOffset(100, 100));
  controller_.ReconcileStretchAndScroll();
  controller_.bounce_forwards_duration_x_ =
      base::TimeDelta::FromMilliseconds(1000);
  controller_.bounce_forwards_duration_y_ =
      base::TimeDelta::FromMilliseconds(1000);
  controller_.momentum_animation_initial_stretch_ = gfx::Vector2dF(10.f, 10.f);

  // Verify that the momentum_animation_start_time_ doesn't get reset when the
  // animation ticks.
  const base::TimeTicks animation_start_time =
      base::TimeTicks() + base::TimeDelta::FromMilliseconds(32);

  // After 2 frames.
  controller_.Animate(animation_start_time);
  helper_.ScrollBy(Vector2dF(0, 2));
  EXPECT_NE(controller_.momentum_animation_start_time_, animation_start_time);
  EXPECT_EQ(controller_.state_,
            ElasticOverscrollController::State::kStateMomentumAnimated);

  // After 8 frames.
  controller_.Animate(animation_start_time +
                      base::TimeDelta::FromMilliseconds(128));
  helper_.ScrollBy(Vector2dF(0, 8));
  EXPECT_NE(controller_.momentum_animation_start_time_, animation_start_time);
  EXPECT_EQ(controller_.state_,
            ElasticOverscrollController::State::kStateMomentumAnimated);

  // After 64 frames the forward animation should no longer be active.
  controller_.Animate(animation_start_time +
                      base::TimeDelta::FromMilliseconds(1024));
  helper_.ScrollBy(Vector2dF(0, 64));
  EXPECT_NE(controller_.momentum_animation_start_time_, animation_start_time);
  EXPECT_EQ(controller_.state_,
            ElasticOverscrollController::State::kStateInactive);
  EXPECT_EQ(Vector2dF(), helper_.StretchAmount());
}

// Tests if the overscrolled delta maps correctly to the actual amount that the
// scroller gets stretched.
TEST_F(ElasticOverscrollControllerBezierTest, VerifyOverscrollBounceDistance) {
  Vector2dF overscroll_bounce_distance(
      controller_.StretchAmountForAccumulatedOverscroll(Vector2dF(0, -100)));
  EXPECT_EQ(overscroll_bounce_distance.y(), -19);

  overscroll_bounce_distance =
      controller_.StretchAmountForAccumulatedOverscroll(Vector2dF(-100, 0));
  EXPECT_EQ(overscroll_bounce_distance.x(), -19);
}

// Tests that the bounce back animation ticks as expected. If the animation was
// successfully created, the call to OverscrollBounceController::Animate should
// tick the animation as expected. When the stretch amount is near 0, the
// scroller should treat the bounce as "completed".
TEST_F(ElasticOverscrollControllerBezierTest, VerifyBackwardAnimationTick) {
  // Test vertical overscroll.
  EXPECT_EQ(controller_.state_, ElasticOverscrollController::kStateInactive);
  SendGestureScrollBegin(PhaseState::kNonMomentum);
  EXPECT_EQ(Vector2dF(0, 0), helper_.StretchAmount());
  SendGestureScrollUpdate(PhaseState::kNonMomentum, Vector2dF(0, -100));

  // This signals that the finger has lifted off which triggers the bounce back
  // animation.
  const base::TimeTicks now = base::TimeTicks::Now();
  SendGestureScrollEnd(now);

  // Frame 2.
  controller_.Animate(now + base::TimeDelta::FromMilliseconds(32));
  EXPECT_EQ(controller_.state_,
            ElasticOverscrollController::kStateMomentumAnimated);
  ASSERT_FLOAT_EQ(helper_.StretchAmount().y(), -14);

  // Frame 5. The stretch amount moving closer to 0 proves that we're animating.
  controller_.Animate(now + base::TimeDelta::FromMilliseconds(80));
  ASSERT_FLOAT_EQ(helper_.StretchAmount().y(), -8);

  // Frame 15. StretchAmount < abs(1), so snap to 0. state_ is kStateInactive.
  controller_.Animate(now + base::TimeDelta::FromMilliseconds(240));
  EXPECT_EQ(Vector2dF(0, 0), helper_.StretchAmount());

  EXPECT_EQ(controller_.state_, ElasticOverscrollController::kStateInactive);

  // Test horizontal overscroll.
  SendGestureScrollBegin(PhaseState::kNonMomentum);
  EXPECT_EQ(Vector2dF(0, 0), helper_.StretchAmount());
  SendGestureScrollUpdate(PhaseState::kNonMomentum, Vector2dF(-80, 0));
  SendGestureScrollEnd(now);

  // Frame 2.
  controller_.Animate(now + base::TimeDelta::FromMilliseconds(32));
  ASSERT_FLOAT_EQ(helper_.StretchAmount().x(), -10);

  // Frame 5. The stretch amount moving closer to 0 proves that we're animating.
  controller_.Animate(now + base::TimeDelta::FromMilliseconds(80));
  EXPECT_EQ(controller_.state_,
            ElasticOverscrollController::kStateMomentumAnimated);
  ASSERT_FLOAT_EQ(helper_.StretchAmount().x(), -5);

  // Frame 15. StretchAmount < abs(1), so snap to 0. state_ is kStateInactive.
  controller_.Animate(now + base::TimeDelta::FromMilliseconds(240));
  EXPECT_EQ(Vector2dF(0, 0), helper_.StretchAmount());
  EXPECT_EQ(controller_.state_, ElasticOverscrollController::kStateInactive);
}

// Tests that the bounce forward animation ticks as expected.
TEST_F(ElasticOverscrollControllerBezierTest, VerifyForwardAnimationTick) {
  // Test vertical forward bounce animations.
  EXPECT_EQ(controller_.state_, ElasticOverscrollController::kStateInactive);
  SendGestureScrollBegin(PhaseState::kNonMomentum);
  EXPECT_EQ(Vector2dF(0, 0), helper_.StretchAmount());
  SendGestureScrollUpdate(PhaseState::kNonMomentum, Vector2dF(0, -100));
  controller_.scroll_velocity_ = gfx::Vector2dF(0.f, -4000.f);

  // This signals that the finger has lifted off which triggers a fling.
  const base::TimeTicks now = base::TimeTicks::Now();
  SendGestureScrollEnd(now);

  const int TOTAL_FRAMES = 28;
  const int stretch_amount_y[TOTAL_FRAMES] = {
      -19, -41, -55, -65, -72, -78, -82, -85, -88, -89, -78, -64, -53, -44,
      -37, -30, -25, -20, -16, -13, -10, -7,  -5,  -4,  -2,  -1,  -1,  0};

  for (int i = 0; i < TOTAL_FRAMES; i++) {
    controller_.Animate(now + base::TimeDelta::FromMilliseconds(i * 16));
    EXPECT_EQ(controller_.state_,
              (stretch_amount_y[i] == 0
                   ? ElasticOverscrollController::kStateInactive
                   : ElasticOverscrollController::kStateMomentumAnimated));
    ASSERT_FLOAT_EQ(helper_.StretchAmount().y(), stretch_amount_y[i]);
  }

  // Test horizontal forward bounce animations.
  SendGestureScrollBegin(PhaseState::kNonMomentum);
  SendGestureScrollUpdate(PhaseState::kNonMomentum, Vector2dF(-50, 0));
  controller_.scroll_velocity_ = gfx::Vector2dF(-3000.f, 0.f);
  SendGestureScrollEnd(now);

  const int stretch_amount_x[TOTAL_FRAMES] = {
      -9,  -24, -34, -42, -48, -54, -58, -62, -66, -69, -62, -52, -43, -36,
      -30, -25, -20, -17, -13, -10, -8,  -6,  -4,  -3,  -2,  -1,  0,   0};

  for (int i = 0; i < TOTAL_FRAMES; i++) {
    controller_.Animate(now + base::TimeDelta::FromMilliseconds(i * 16));
    EXPECT_EQ(controller_.state_,
              (stretch_amount_x[i] == 0
                   ? ElasticOverscrollController::kStateInactive
                   : ElasticOverscrollController::kStateMomentumAnimated));
    ASSERT_FLOAT_EQ(helper_.StretchAmount().x(), stretch_amount_x[i]);
  }
}

// Tests that the bounce forward animation is *not* played when the velocity is
// less than kIgnoreForwardBounceVelocityThreshold. This can be verified by
// checking bounce_forwards_distance_ (since it is a function of velocity)
TEST_F(ElasticOverscrollControllerBezierTest,
       VerifyForwardAnimationIsNotPlayed) {
  EXPECT_EQ(Vector2dF(), helper_.StretchAmount());
  controller_.scroll_velocity_ = gfx::Vector2dF(0.f, -199.f);
  controller_.DidEnterMomentumAnimatedState();
  EXPECT_TRUE(controller_.bounce_forwards_distance_.IsZero());

  controller_.scroll_velocity_ = gfx::Vector2dF(-199.f, 0.f);
  controller_.DidEnterMomentumAnimatedState();
  EXPECT_TRUE(controller_.bounce_forwards_distance_.IsZero());

  // When velocity > 200, forward animation is expected to be played.
  controller_.scroll_velocity_ = gfx::Vector2dF(0.f, -201.f);
  controller_.DidEnterMomentumAnimatedState();
  EXPECT_EQ(gfx::Vector2dF(0, -16),
            gfx::ToRoundedVector2d(controller_.bounce_forwards_distance_));

  controller_.scroll_velocity_ = gfx::Vector2dF(-201.f, 0.f);
  controller_.DidEnterMomentumAnimatedState();
  EXPECT_EQ(gfx::Vector2dF(-16, 0),
            gfx::ToRoundedVector2d(controller_.bounce_forwards_distance_));
}

// Tests initiating a scroll when a bounce back animation is in progress works
// as expected.
TEST_F(ElasticOverscrollControllerBezierTest, VerifyScrollDuringBounceBack) {
  // Test vertical overscroll.
  SendGestureScrollBegin(PhaseState::kNonMomentum);
  EXPECT_EQ(Vector2dF(0, 0), helper_.StretchAmount());
  SendGestureScrollUpdate(PhaseState::kNonMomentum, Vector2dF(0, -100));

  // This signals that the finger has lifted off which triggers the bounce back
  // animation.
  const base::TimeTicks now = base::TimeTicks::Now();
  SendGestureScrollEnd(now);
  EXPECT_EQ(Vector2dF(0, -19), helper_.StretchAmount());

  // Frame 2.
  controller_.Animate(now + base::TimeDelta::FromMilliseconds(32));
  ASSERT_FLOAT_EQ(helper_.StretchAmount().y(), -14);

  // Frame 5. The stretch amount moving closer to 0 proves that we're animating.
  controller_.Animate(now + base::TimeDelta::FromMilliseconds(80));
  ASSERT_FLOAT_EQ(helper_.StretchAmount().y(), -8);

  // While the animation is still ticking, initiate a scroll.
  SendGestureScrollBegin(PhaseState::kNonMomentum);
  SendGestureScrollUpdate(PhaseState::kNonMomentum, Vector2dF(0, -50));
  ASSERT_FLOAT_EQ(helper_.StretchAmount().y(), -17);
}

// Tests that animation doesn't get created when unused_delta is 0.
TEST_F(ElasticOverscrollControllerBezierTest, VerifyAnimationNotCreated) {
  // Test vertical and horizontal overscroll.
  SendGestureScrollBegin(PhaseState::kNonMomentum);
  EXPECT_EQ(Vector2dF(0, 0), helper_.StretchAmount());

  // state_ is kStateActiveScroll. unused_delta is 0 so overscroll should not
  // take place.
  SendGestureScrollUpdate(PhaseState::kNonMomentum, Vector2dF(0, 0));

  // This signals that the finger has lifted off which triggers the bounce back
  // animation.
  const base::TimeTicks now = base::TimeTicks::Now();
  SendGestureScrollEnd(now);

  // Frame 2.
  controller_.Animate(now + base::TimeDelta::FromMilliseconds(32));
  EXPECT_EQ(Vector2dF(0, 0), helper_.StretchAmount());
}
}  // namespace blink