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

#include "ash/wm/overview/overview_window_drag_controller.h"

#include <algorithm>
#include <array>

#include "ash/display/mouse_cursor_event_filter.h"
#include "ash/public/cpp/shell_window_ids.h"
#include "ash/root_window_controller.h"
#include "ash/screen_util.h"
#include "ash/shell.h"
#include "ash/wm/desks/desk_icon_button.h"
#include "ash/wm/desks/desks_util.h"
#include "ash/wm/desks/overview_desk_bar_view.h"
#include "ash/wm/float/float_controller.h"
#include "ash/wm/overview/overview_constants.h"
#include "ash/wm/overview/overview_controller.h"
#include "ash/wm/overview/overview_grid.h"
#include "ash/wm/overview/overview_item.h"
#include "ash/wm/overview/overview_item_base.h"
#include "ash/wm/overview/overview_item_view.h"
#include "ash/wm/overview/overview_session.h"
#include "ash/wm/overview/overview_utils.h"
#include "ash/wm/overview/scoped_float_container_stacker.h"
#include "ash/wm/scoped_windows_mover.h"
#include "ash/wm/snap_group/snap_group.h"
#include "ash/wm/snap_group/snap_group_controller.h"
#include "ash/wm/snap_group/snap_group_metrics.h"
#include "ash/wm/splitview/split_view_constants.h"
#include "ash/wm/splitview/split_view_drag_indicators.h"
#include "ash/wm/splitview/split_view_types.h"
#include "ash/wm/splitview/split_view_utils.h"
#include "ash/wm/window_positioning_utils.h"
#include "ash/wm/window_util.h"
#include "ash/wm/wm_constants.h"
#include "base/auto_reset.h"
#include "base/memory/raw_ptr.h"
#include "base/metrics/histogram_functions.h"
#include "base/numerics/safe_conversions.h"
#include "chromeos/ui/frame/caption_buttons/snap_controller.h"
#include "third_party/abseil-cpp/absl/cleanup/cleanup.h"
#include "ui/aura/window.h"
#include "ui/aura/window_observer.h"
#include "ui/compositor/layer.h"
#include "ui/compositor/presentation_time_recorder.h"
#include "ui/display/display.h"
#include "ui/display/screen.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/rect_conversions.h"
#include "ui/wm/core/coordinate_conversion.h"

namespace ash {

namespace {

// The amount of distance from the start of drag the item needs to be dragged
// vertically for it to be closed on release.
constexpr float kDragToCloseDistanceThresholdDp = 160.f;

// The minimum distance that will be considered as a drag event.
constexpr float kMinimumDragDistanceDp = 5.f;
// Items dragged to within |kDistanceFromEdgeDp| of the screen will get snapped
// even if they have not moved by |kMinimumDragToSnapDistanceDp|.
constexpr float kDistanceFromEdgeDp = 16.f;
// The minimum distance that an item must be moved before it is snapped. This
// prevents accidental snaps.
constexpr float kMinimumDragToSnapDistanceDp = 96.f;

// Flings with less velocity than this will not close the dragged item.
constexpr float kFlingToCloseVelocityThreshold = 2000.f;
constexpr float kItemMinOpacity = 0.4f;

// The scale factor used to calculate the minimum side length for the overview
// item bounds on the desks bar.
constexpr float kScaleFactorForMinimumSideLength = 0.5f;

// The minimum vertical overlapped length between the overview item and new desk
// button in order to activate the new desk button.
constexpr int kVerticalOverlappedLengthToActivateNewDeskButton = 15;

// Amount of time we wait to unpause the occlusion tracker after a overview item
// is finished dragging. Waits a bit longer than the overview item animation.
constexpr base::TimeDelta kOcclusionPauseDurationForDrag =
    base::Milliseconds(300);

constexpr base::TimeDelta kScaleUpNewDeskButtonGracePeriod =
    base::Milliseconds(500);

// The UMA histogram that records presentation time for window dragging
// operation in overview mode.
constexpr char kOverviewWindowDragHistogram[] =
    "Ash.Overview.WindowDrag.PresentationTime.TabletMode";
constexpr char kOverviewWindowDragMaxLatencyHistogram[] =
    "Ash.Overview.WindowDrag.PresentationTime.MaxLatency.TabletMode";

bool g_skip_new_desk_button_scale_up_for_test = false;

bool GetVirtualDesksBarEnabled(OverviewItemBase* item) {
  return desks_util::ShouldDesksBarBeCreated() &&
         item->overview_grid()->desks_bar_view();
}

// Returns whether |item|'s window is visible on all desks.
bool DraggedItemIsVisibleOnAllDesks(OverviewItemBase* item) {
  aura::Window* const dragged_window = item->GetWindow();
  return dragged_window &&
         desks_util::IsWindowVisibleOnAllWorkspaces(dragged_window);
}

// Returns the scaled-down size of the dragged item that should be used when
// it's dragged over the OverviewDeskBarView that belongs to |overview_grid|.
// |window_original_size| is the size of the item's window before it was scaled
// up for dragging.
gfx::SizeF GetItemSizeWhenOnDesksBar(OverviewGrid* overview_grid,
                                     const gfx::SizeF& window_original_size) {
  DCHECK(overview_grid);
  const OverviewDeskBarView* desks_bar_view = overview_grid->desks_bar_view();
  DCHECK(desks_bar_view);

  const int expanded_desks_bar_height = DeskBarViewBase::GetPreferredBarHeight(
      overview_grid->root_window(), DeskBarViewBase::Type::kOverview,
      DeskBarViewBase::State::kExpanded);

  // We should always use the expanded desks bar height here even if the desks
  // bar is actually in zero state to calculate `scale_factor`. Because if zero
  // state bar height is used here, the dragged window could become too small
  // during the drag.
  const float scale_factor = static_cast<float>(expanded_desks_bar_height) /
                             overview_grid->root_window()->bounds().height();
  gfx::SizeF scaled_size = gfx::ScaleSize(window_original_size, scale_factor);

  // Adjust the scaled size to ensure that its smaller side length is equal or
  // larger than the `minimum_size_length`, and then adjust the larger size
  // length to preserve the ratio of the original size.
  const float minimum_size_length =
      expanded_desks_bar_height * kScaleFactorForMinimumSideLength;
  const float scaled_size_height = scaled_size.height();
  const float scaled_size_width = scaled_size.width();
  if (scaled_size_height < minimum_size_length ||
      scaled_size_width < minimum_size_length) {
    if (scaled_size_height < scaled_size_width) {
      scaled_size.set_height(minimum_size_length);
      scaled_size.set_width(scaled_size_width / scaled_size_height *
                            minimum_size_length);
    } else {
      scaled_size.set_width(minimum_size_length);
      scaled_size.set_height(scaled_size_height / scaled_size_width *
                             minimum_size_length);
    }
  }

  // Add the margins overview mode adds around the window's contents.
  scaled_size.Enlarge(kDraggingEnlargeDp,
                      kDraggingEnlargeDp + kWindowMiniViewHeaderHeight);
  return scaled_size;
}

float GetManhattanDistanceX(float point_x, const gfx::RectF& rect) {
  return std::max(rect.x() - point_x, point_x - rect.right());
}

float GetManhattanDistanceY(float point_y, const gfx::RectF& rect) {
  return std::max(rect.y() - point_y, point_y - rect.bottom());
}

void RecordDrag(OverviewDragAction action) {
  base::UmaHistogramEnumeration("Ash.Overview.WindowDrag.Workflow", action);
}

// Restores the new desk button state back to the
// `DeskIconButton::State::kExpanded` on drag ended on all `OverviewGrid`s.
void MaybeRestoreNewDeskButtonState() {
  OverviewSession* overview_session =
      OverviewController::Get()->overview_session();
  if (!overview_session || overview_session->is_shutting_down()) {
    return;
  }

  for (aura::Window* root : Shell::GetAllRootWindows()) {
    OverviewGrid* overview_grid = overview_session->GetGridWithRootWindow(root);
    if (auto* desks_bar_view = overview_grid->desks_bar_view()) {
      desks_bar_view->UpdateDeskIconButtonState(
          desks_bar_view->new_desk_button(), DeskIconButton::State::kExpanded);
    }
  }
}

// Helps with handling the workflow where you drag an overview item from one
// grid and drop into another grid. The challenge is that if the item represents
// an ARC window, that window will be moved to the target root asynchronously.
// |OverviewItemMoveHelper| observes the window until it moves to the target
// root. Then |OverviewItemMoveHelper| self destructs and adds a new item to
// represent the window on the target root.
class OverviewItemMoveHelper : public aura::WindowObserver {
 public:
  // |windows| contains the list of windows to be moved, and |item_window| is the
  // one currently being dragged in this list. |target_item_bounds| is the bounds
  // of the item window when the drag ends. |target_item_bounds| is used to put
  // the new item where the old item ended, so it looks like it is the same
  // item. Then the item is animated from there to its proper position in the
  // grid.
  OverviewItemMoveHelper(aura::Window::Windows windows,
                         aura::Window* item_window,
                         const gfx::RectF& target_item_bounds)
      : windows_(std::move(windows)),
        item_window_(item_window),
        target_item_bounds_(target_item_bounds) {
    CHECK(base::Contains(windows_, item_window_));
    for (auto window : windows_) {
      window->AddObserver(this);
    }
  }
  OverviewItemMoveHelper(const OverviewItemMoveHelper&) = delete;
  OverviewItemMoveHelper& operator=(const OverviewItemMoveHelper&) = delete;
  ~OverviewItemMoveHelper() override {
    OverviewController* overview_controller = OverviewController::Get();
    if (overview_controller->InOverviewSession()) {
      overview_controller->overview_session()->PositionWindows(
          /*animate=*/true);
    }
    DCHECK(windows_.empty());
  }

  // aura::WindowObserver:
  void OnWindowDestroyed(aura::Window* window) override {
    DCHECK(base::Contains(windows_, window));
    ResetWindowAndDeleteIfEmpty(window);
  }
  void OnWindowAddedToRootWindow(aura::Window* window) override {
    DCHECK(base::Contains(windows_, window));
    bool is_item_window = item_window_ == window;

    OverviewController* overview_controller = OverviewController::Get();
    if (overview_controller->InOverviewSession()) {
      // OverviewSession::AddItemInMruOrder() will add |window| to the grid
      // associated with |window|'s root. Do not reposition or restack as we
      // will soon handle them both anyway.
      OverviewSession* session = overview_controller->overview_session();
      session->AddItemInMruOrder(window, /*reposition=*/false,
                                 /*animate=*/false, /*restack=*/false,
                                 /*use_spawn_animation=*/false);
      if (is_item_window) {
        OverviewItemBase* item = session->GetOverviewItemForWindow(window);
        DCHECK(item);
        item->SetBounds(target_item_bounds_, OVERVIEW_ANIMATION_NONE);
        item->set_should_restack_on_animation_end(true);
      } else if (overview_controller->InOverviewSession()) {
        // Don't animate non item window as its origin bounds isn't specified.
        overview_controller->overview_session()->PositionWindows(
            /*animate=*/false);
      }
      // The destructor will call OverviewSession::PositionWindows().
    }
    ResetWindowAndDeleteIfEmpty(window);
  }

 private:
  void ResetWindowAndDeleteIfEmpty(aura::Window* window) {
    window->RemoveObserver(this);
    if (item_window_ == window) {
      item_window_ = nullptr;
    }
    std::erase(windows_, window);
    if (windows_.empty()) {
      delete this;
    }
  }

  aura::Window::Windows windows_;
  raw_ptr<aura::Window> item_window_;
  const gfx::RectF target_item_bounds_;
};

}  // namespace

OverviewWindowDragController::OverviewWindowDragController(
    OverviewSession* overview_session,
    OverviewItemBase* item,
    bool is_touch_dragging,
    OverviewItemBase* event_source_item)
    : overview_session_(overview_session),
      item_(item),
      event_source_item_(event_source_item),
      display_count_(Shell::GetAllRootWindows().size()),
      is_touch_dragging_(is_touch_dragging),
      is_eligible_for_drag_to_snap_(
          IsEligibleForDraggingToSnapInOverview(item)),
      virtual_desks_bar_enabled_(GetVirtualDesksBarEnabled(item)) {
  CHECK(!OverviewController::Get()->IsInStartAnimation());
  CHECK(!SplitViewController::Get(item_->root_window())->IsDividerAnimating());
}

OverviewWindowDragController::~OverviewWindowDragController() {
  // This object is deleted using `DeleteSoon()`, so the shell may be destroyed
  // already during shutdown.
  if (Shell::HasInstance()) {
    Shell::Get()->mouse_cursor_filter()->HideSharedEdgeIndicator();
  }
}

// static
base::AutoReset<bool>
OverviewWindowDragController::SkipNewDeskButtonScaleUpDurationForTesting() {
  return {&g_skip_new_desk_button_scale_up_for_test, true};
}

void OverviewWindowDragController::InitiateDrag(
    const gfx::PointF& location_in_screen) {
  initial_event_location_ = location_in_screen;
  initial_centerpoint_ = item_->target_bounds().CenterPoint();
  original_opacity_ = item_->GetOpacity();
  current_drag_behavior_ = DragBehavior::kUndefined;
  occlusion_pauser_ = OverviewController::Get()->PauseOcclusionTracker(
      kOcclusionPauseDurationForDrag);
  DCHECK(!presentation_time_recorder_);

  presentation_time_recorder_ = CreatePresentationTimeHistogramRecorder(
      item_->root_window()->layer()->GetCompositor(),
      kOverviewWindowDragHistogram, kOverviewWindowDragMaxLatencyHistogram);
}

void OverviewWindowDragController::Drag(const gfx::PointF& location_in_screen) {
  if (!did_move_) {
    gfx::Vector2dF distance = location_in_screen - initial_event_location_;
    // Do not start dragging if the distance from |location_in_screen| to
    // |initial_event_location_| is not greater than |kMinimumDragDistanceDp|.
    if (std::abs(distance.x()) < kMinimumDragDistanceDp &&
        std::abs(distance.y()) < kMinimumDragDistanceDp) {
      return;
    }

    if (is_touch_dragging_ && std::abs(distance.x()) < std::abs(distance.y())) {
      StartDragToCloseMode();
    } else if (is_eligible_for_drag_to_snap_ || virtual_desks_bar_enabled_) {
      StartNormalDragMode(location_in_screen);
    } else {
      return;
    }
  }

  if (current_drag_behavior_ == DragBehavior::kDragToClose)
    ContinueDragToClose(location_in_screen);
  else if (current_drag_behavior_ == DragBehavior::kNormalDrag)
    ContinueNormalDrag(location_in_screen);

  if (presentation_time_recorder_)
    presentation_time_recorder_->RequestNext();
}

OverviewWindowDragController::DragResult
OverviewWindowDragController::CompleteDrag(
    const gfx::PointF& location_in_screen) {
  per_grid_desks_bar_data_.clear();
  DragResult result = DragResult::kNeverDisambiguated;

  switch (current_drag_behavior_) {
    case DragBehavior::kNoDrag:
      NOTREACHED();

    case DragBehavior::kUndefined:
      ActivateDraggedWindow();
      break;

    case DragBehavior::kNormalDrag:
      result = CompleteNormalDrag(location_in_screen);
      break;

    case DragBehavior::kDragToClose:
      result = CompleteDragToClose(location_in_screen);
      break;
  }

  did_move_ = false;

  // `item_` may be null if `CompleteNormalDrag()` resulted in moving the
  // window into another desk. At this point, we can just pass in a nullptr and
  // the `FloatContainerStacker` will reset the stacking. Also,
  // `ActivateDraggedWindow()` above may have started the session shutdown, so
  // the `FloatContainerStacker` may be null.
  if (auto* float_container_stacker =
          overview_session_->float_container_stacker()) {
    float_container_stacker->OnDragFinished(item_ ? item_->GetWindow()
                                                  : nullptr);
  }

  item_ = nullptr;
  event_source_item_ = nullptr;
  current_drag_behavior_ = DragBehavior::kNoDrag;
  occlusion_pauser_.reset();
  presentation_time_recorder_.reset();
  return result;
}

void OverviewWindowDragController::StartNormalDragMode(
    const gfx::PointF& location_in_screen) {
  CHECK(is_eligible_for_drag_to_snap_ || virtual_desks_bar_enabled_);

  did_move_ = true;
  current_drag_behavior_ = DragBehavior::kNormalDrag;
  Shell::Get()->mouse_cursor_filter()->ShowSharedEdgeIndicator(
      item_->root_window());
  const gfx::SizeF window_original_size(item_->GetWindow()->bounds().size());
  item_->ScaleUpSelectedItem(
      OVERVIEW_ANIMATION_LAYOUT_OVERVIEW_ITEMS_IN_OVERVIEW);
  original_scaled_size_ = item_->target_bounds().size();
  auto* overview_grid = item_->overview_grid();
  overview_grid->AddDropTargetForDraggingFromThisGrid(item_);

  // Expand all desks bars on all displays when normal drag starts if it is in
  // zero state.
  for (const std::unique_ptr<OverviewGrid>& grid :
       overview_session_->grid_list()) {
    // The bar may be null if we have no desks in tablet mode.
    if (auto* desks_bar_view = grid->desks_bar_view();
        desks_bar_view && desks_bar_view->IsZeroState()) {
      desks_bar_view->UpdateNewMiniViews(/*initializing_bar_view=*/false,
                                         /*expanding_bar_view=*/true);
    }
  }

  item_->UpdateShadowTypeForDrag(/*is_dragging=*/true);
  aura::Window* dragged_window = item_->GetWindow();

  if (is_eligible_for_drag_to_snap_) {
    overview_session_->SetSplitViewDragIndicatorsDraggedWindow(dragged_window);
    overview_session_->UpdateSplitViewDragIndicatorsWindowDraggingStates(
        GetRootWindowBeingDraggedIn(),
        SplitViewDragIndicators::ComputeWindowDraggingState(
            /*is_dragging=*/true,
            SplitViewDragIndicators::WindowDraggingState::kFromOverview,
            SnapPosition::kNone));
    item_->HideCannotSnapWarning(/*animate=*/true);

    // Update the split view divider bar status if necessary. If splitview is
    // active when dragging the `dragged_window`, the split divider bar should
    // be placed below the dragged window during dragging.
    SplitViewController::Get(item_->root_window())
        ->OnWindowDragStarted(dragged_window);
  }

  if (virtual_desks_bar_enabled_) {
    // Calculate the item bounds minus the header and margins (which are
    // invisible). Use this for the shrink bounds so that the item starts
    // shrinking when the visible top-edge of the item aligns with the
    // bottom-edge of the desks bar (may be different edges if we are dragging
    // from different directions).
    gfx::SizeF item_no_header_size = original_scaled_size_;
    item_no_header_size.Enlarge(
        float{-kDraggingEnlargeDp},
        float{-kDraggingEnlargeDp - kWindowMiniViewHeaderHeight});

    // We must update the desks bar widget bounds before we cache its bounds
    // below, in case it needs to be pushed down due to splitview indicators.
    // Note that when drag is just getting started, the window hasn't moved to
    // another display, so it's ok to use the item's |overview_grid|.
    overview_grid->MaybeUpdateDesksWidgetBounds();

    // Calculate cached values for usage during drag for each grid.
    for (const auto& grid : overview_session_->grid_list()) {
      GridDesksBarData& grid_desks_bar_data =
          per_grid_desks_bar_data_[grid.get()];

      grid_desks_bar_data.on_desks_bar_item_size =
          GetItemSizeWhenOnDesksBar(grid.get(), window_original_size);
      grid_desks_bar_data.desks_bar_bounds = grid_desks_bar_data.shrink_bounds =
          gfx::RectF(grid->desks_bar_view()->GetBoundsInScreen());
      const int expanded_height = DeskBarViewBase::GetPreferredBarHeight(
          grid->root_window(), DeskBarViewBase::Type::kOverview,
          DeskBarViewBase::State::kExpanded);
      grid_desks_bar_data.desks_bar_bounds.set_height(expanded_height);
      grid_desks_bar_data.shrink_bounds.set_height(expanded_height);
      grid_desks_bar_data.shrink_bounds.Inset(gfx::InsetsF::VH(
          -item_no_header_size.height() / 2, -item_no_header_size.width() / 2));
      grid_desks_bar_data.shrink_region_distance =
          grid_desks_bar_data.desks_bar_bounds.origin() -
          grid_desks_bar_data.shrink_bounds.origin();
    }
  }

  overview_session_->float_container_stacker()->OnDragStarted(dragged_window);
}

OverviewWindowDragController::DragResult OverviewWindowDragController::Fling(
    const gfx::PointF& location_in_screen,
    float velocity_x,
    float velocity_y) {
  if (current_drag_behavior_ == DragBehavior::kDragToClose ||
      current_drag_behavior_ == DragBehavior::kUndefined) {
    if (std::abs(velocity_y) > kFlingToCloseVelocityThreshold) {
      item_->AnimateAndCloseItem(
          (location_in_screen - initial_event_location_).y() < 0);
      did_move_ = false;
      item_ = nullptr;
      event_source_item_ = nullptr;
      current_drag_behavior_ = DragBehavior::kNoDrag;
      occlusion_pauser_.reset();
      RecordDragToClose(kFlingToClose);
      return DragResult::kSuccessfulDragToClose;
    }
  }

  // If the fling velocity was not high enough, or flings should be ignored,
  // treat it as a scroll end event.
  return CompleteDrag(location_in_screen);
}

void OverviewWindowDragController::ActivateDraggedWindow() {
  // If no drag was initiated (e.g., a click/tap on the overview window),
  // activate the window. If the split view is active and has a left window,
  // snap the current window to right. If the split view is active and has a
  // right window, snap the current window to left. If split view is active
  // and the selected window cannot be snapped, exit splitview and activate
  // the selected window, and also exit the overview.
  SplitViewController* split_view_controller =
      SplitViewController::Get(item_->root_window());
  SplitViewController::State split_state = split_view_controller->state();
  if (!is_eligible_for_drag_to_snap_ ||
      split_state == SplitViewController::State::kNoSnap) {
    overview_session_->SelectWindow(event_source_item_);
    // Explicitly set `item_` to null to avoid being accessed after been
    // released in `OverviewGrid::RemoveItem()`. See UaF reported in
    // b/301368132.
    item_ = nullptr;
    event_source_item_ = nullptr;
  } else if (auto* split_view_overview_session =
                 RootWindowController::ForWindow(item_->GetWindow())
                     ->split_view_overview_session();
             split_view_overview_session) {
    // If `SplitViewOverviewSession` is active, activate the window;
    // `AutoSnapController` will handle the autosnap.
    RecordPartialOverviewMetrics(item_);
    overview_session_->SelectWindow(event_source_item_);
    item_ = nullptr;
    event_source_item_ = nullptr;
  } else if (split_view_controller->CanSnapWindow(
                 item_->GetWindow(), chromeos::kDefaultSnapRatio)) {
    // Used for overview items that are being dragged to snap. Since the
    // window is already activated, `AutoSnapController::OnWindowActivating()`
    // will not work above.
    RecordPartialOverviewMetrics(item_);
    SnapWindow(split_view_controller,
               split_state == SplitViewController::State::kPrimarySnapped
                   ? SnapPosition::kSecondary
                   : SnapPosition::kPrimary);
  } else {
    split_view_controller->EndSplitView();
    overview_session_->SelectWindow(event_source_item_);
    // Same as above, explicitly set `item_` to nullptr to avoid UaF.
    item_ = nullptr;
    event_source_item_ = nullptr;
    ShowAppCannotSnapToast();
  }

  current_drag_behavior_ = DragBehavior::kNoDrag;
  occlusion_pauser_.reset();
}

void OverviewWindowDragController::ResetGesture() {
  if (current_drag_behavior_ == DragBehavior::kNormalDrag) {
    CHECK(item_->overview_grid()->drop_target());

    Shell::Get()->mouse_cursor_filter()->HideSharedEdgeIndicator();
    item_->DestroyMirrorsForDragging();
    overview_session_->RemoveDropTargets();
    if (is_eligible_for_drag_to_snap_) {
      SplitViewController::Get(item_->root_window())->OnWindowDragCanceled();
      overview_session_->ResetSplitViewDragIndicatorsWindowDraggingStates();
      item_->UpdateCannotSnapWarningVisibility(/*animate=*/true);
    }
  }

  // No need to position windows that are being destroyed.
  base::flat_set<OverviewItemBase*> ignored_items;
  if (item_->GetWindow()->is_destroying()) {
    ignored_items.insert(item_);
  }
  overview_session_->PositionWindows(/*animate=*/true, ignored_items);
  overview_session_->float_container_stacker()->OnDragFinished(
      item_->GetWindow());
  // This function gets called after a long press release, which bypasses
  // CompleteDrag but stops dragging as well, so reset |item_|.
  item_ = nullptr;
  event_source_item_ = nullptr;
  current_drag_behavior_ = DragBehavior::kNoDrag;
  occlusion_pauser_.reset();
}

void OverviewWindowDragController::ResetOverviewSession() {
  overview_session_ = nullptr;
  new_desk_button_scale_up_timer_.Stop();
}

void OverviewWindowDragController::StartDragToCloseMode() {
  DCHECK(is_touch_dragging_);

  did_move_ = true;
  current_drag_behavior_ = DragBehavior::kDragToClose;
  overview_session_->GetGridWithRootWindow(item_->root_window())
      ->StartNudge(item_);

  item_->UpdateShadowTypeForDrag(/*is_dragging=*/true);
  overview_session_->float_container_stacker()->OnDragStarted(
      item_->GetWindow());
}

void OverviewWindowDragController::ContinueDragToClose(
    const gfx::PointF& location_in_screen) {
  DCHECK_EQ(current_drag_behavior_, DragBehavior::kDragToClose);

  // Update the dragged |item_|'s bounds accordingly. The distance from the new
  // location to the new centerpoint should be the same it was initially.
  gfx::RectF bounds(item_->target_bounds());
  const gfx::PointF centerpoint =
      location_in_screen - (initial_event_location_ - initial_centerpoint_);

  // If the drag location intersects with the desk bar, then we should cancel
  // the drag-to-close mode and start the normal drag mode.
  if (virtual_desks_bar_enabled_ &&
      item_->overview_grid()->IntersectsWithDesksBar(
          gfx::ToRoundedPoint(location_in_screen),
          /*update_desks_bar_drag_details=*/false, /*for_drop=*/false)) {
    item_->SetOpacity(original_opacity_);
    StartNormalDragMode(location_in_screen);
    ContinueNormalDrag(location_in_screen);
    return;
  }

  // Update |item_|'s opacity based on its distance. |item_|'s x coordinate
  // should not change while in drag to close state.
  float val = std::abs(location_in_screen.y() - initial_event_location_.y()) /
              kDragToCloseDistanceThresholdDp;
  overview_session_->GetGridWithRootWindow(item_->root_window())
      ->UpdateNudge(item_, val);
  val = std::clamp(val, 0.f, 1.f);
  float opacity = original_opacity_;
  if (opacity > kItemMinOpacity)
    opacity = original_opacity_ - val * (original_opacity_ - kItemMinOpacity);

  item_->SetOpacity(opacity);

  // When dragging to close, only update the y component.
  bounds.set_y(centerpoint.y() - bounds.height() / 2.f);
  item_->SetBounds(bounds, OVERVIEW_ANIMATION_NONE);
}

OverviewWindowDragController::DragResult
OverviewWindowDragController::CompleteDragToClose(
    const gfx::PointF& location_in_screen) {
  DCHECK_EQ(current_drag_behavior_, DragBehavior::kDragToClose);

  // Close the window if it has been dragged enough, otherwise reposition it and
  // set its opacity back to its original value.
  overview_session_->GetGridWithRootWindow(item_->root_window())->EndNudge();
  const float y_distance = (location_in_screen - initial_event_location_).y();
  if (std::abs(y_distance) > kDragToCloseDistanceThresholdDp) {
    item_->AnimateAndCloseItem(/*up=*/y_distance < 0);
    RecordDragToClose(kSwipeToCloseSuccessful);
    return DragResult::kSuccessfulDragToClose;
  }

  item_->UpdateShadowTypeForDrag(/*is_dragging=*/false);

  item_->SetOpacity(original_opacity_);
  overview_session_->PositionWindows(/*animate=*/true);
  RecordDragToClose(kSwipeToCloseCanceled);
  return DragResult::kCanceledDragToClose;
}

void OverviewWindowDragController::ContinueNormalDrag(
    const gfx::PointF& location_in_screen) {
  DCHECK_EQ(current_drag_behavior_, DragBehavior::kNormalDrag);

  // Update the dragged |item_|'s bounds accordingly. The distance from the new
  // location to the new centerpoint should be the same it was initially unless
  // the item is over the DeskBarView, in which case we scale it down and center
  // it around the drag location.
  gfx::RectF bounds(item_->target_bounds());
  gfx::PointF centerpoint =
      location_in_screen - (initial_event_location_ - initial_centerpoint_);

  auto* overview_grid = GetCurrentGrid();

  // If virtual desks is enabled, we want to gradually shrink the dragged item
  // as it gets closer to get dropped into a desk mini view.
  if (virtual_desks_bar_enabled_) {
    centerpoint = location_in_screen;

    const auto iter = per_grid_desks_bar_data_.find(overview_grid);
    DCHECK(iter != per_grid_desks_bar_data_.end());
    const GridDesksBarData& desks_bar_data = iter->second;

    if (desks_bar_data.shrink_bounds.Contains(location_in_screen)) {
      // Update the mini views borders by checking if |location_in_screen|
      // intersects. Only update the borders if the dragged item is not visible
      // on all desks.
      overview_grid->IntersectsWithDesksBar(
          gfx::ToRoundedPoint(location_in_screen),
          /*update_desks_bar_drag_details=*/
          !DraggedItemIsVisibleOnAllDesks(item_), /*for_drop=*/false);

      float value = 0.f;
      if (centerpoint.y() < desks_bar_data.desks_bar_bounds.y() ||
          centerpoint.y() > desks_bar_data.desks_bar_bounds.bottom()) {
        // Coming vertically, this is the main use case. This is a ratio of the
        // distance from |centerpoint| to the closest edge of |desk_bar_bounds|
        // to the distance from |shrink_bounds| to |desk_bar_bounds|.
        value = GetManhattanDistanceY(centerpoint.y(),
                                      desks_bar_data.desks_bar_bounds) /
                desks_bar_data.shrink_region_distance.y();
      } else if (centerpoint.x() < desks_bar_data.desks_bar_bounds.x() ||
                 centerpoint.x() > desks_bar_data.desks_bar_bounds.right()) {
        // Coming horizontally, this only happens if we are in landscape split
        // view and someone drags an item to the other half, then up, then into
        // the desks bar. Works same as vertically except using x-coordinates.
        value = GetManhattanDistanceX(centerpoint.x(),
                                      desks_bar_data.desks_bar_bounds) /
                desks_bar_data.shrink_region_distance.x();
      }
      value = std::clamp(value, 0.f, 1.f);
      const gfx::SizeF size_value =
          gfx::Tween::SizeFValueBetween(1.f - value, original_scaled_size_,
                                        desks_bar_data.on_desks_bar_item_size);
      bounds.set_size(size_value);
    } else {
      bounds.set_size(original_scaled_size_);
    }
  }

  if (is_eligible_for_drag_to_snap_) {
    UpdateDragIndicatorsAndOverviewGrid(location_in_screen);
    // The newly updated indicator state may cause the desks widget to be pushed
    // down to make room for the top splitview guidance indicator when in
    // portrait orientation in tablet mode.
    overview_grid->MaybeUpdateDesksWidgetBounds();
  }

  if (!overview_grid->drop_target() &&
      (!is_eligible_for_drag_to_snap_ ||
       SplitViewDragIndicators::GetSnapPosition(
           overview_grid->split_view_drag_indicators()
               ->current_window_dragging_state()) == SnapPosition::kNone)) {
    overview_grid->AddDropTargetNotForDraggingFromThisGrid(item_->GetWindow(),
                                                           /*animate=*/true);
  }
  overview_session_->UpdateDropTargetsBackgroundVisibilities(
      item_, location_in_screen);

  bounds.set_x(centerpoint.x() - bounds.width() / 2.f);
  bounds.set_y(centerpoint.y() - bounds.height() / 2.f);
  item_->SetBounds(bounds, OVERVIEW_ANIMATION_NONE);

  // The bar may be null if we have no desks in tablet mode.
  if (auto* desks_bar_view = overview_grid->desks_bar_view()) {
    auto* new_desk_button = desks_bar_view->new_desk_button();

    // The header of window is shown during dragging. Overview item should be
    // hovered on the new desk button with
    // `kVerticalOverlappedLengthToActivateNewDeskButton` overlapped vertical
    // area in order to activate the new desk button. There could be a lot of
    // mistriggers with header shown if the new desk button is activated when
    // the overview item intersects with it.
    gfx::Rect effective_hovered_bounds(gfx::ToEnclosedRect(bounds));
    effective_hovered_bounds.Inset(gfx::Insets::TLBR(
        kVerticalOverlappedLengthToActivateNewDeskButton, 0, 0, 0));
    const bool is_hovered_on_new_desk_button =
        new_desk_button->GetBoundsInScreen().Intersects(
            effective_hovered_bounds);

    if (!is_hovered_on_new_desk_button) {
      new_desk_button_scale_up_timer_.Stop();
    } else if (!new_desk_button_scale_up_timer_.IsRunning() &&
               new_desk_button->state() == DeskIconButton::State::kExpanded) {
      if (g_skip_new_desk_button_scale_up_for_test) {
        MaybeScaleUpNewDeskButton();
      } else {
        new_desk_button_scale_up_timer_.Start(
            FROM_HERE, kScaleUpNewDeskButtonGracePeriod, this,
            &OverviewWindowDragController::MaybeScaleUpNewDeskButton);
      }
    }
  }

  if (display_count_ > 1u)
    item_->UpdateMirrorsForDragging(is_touch_dragging_);
}

OverviewWindowDragController::DragResult
OverviewWindowDragController::CompleteNormalDrag(
    const gfx::PointF& location_in_screen) {
  DCHECK_EQ(current_drag_behavior_, DragBehavior::kNormalDrag);
  auto* item_overview_grid = item_->overview_grid();
  CHECK(item_overview_grid->drop_target());
  Shell::Get()->mouse_cursor_filter()->HideSharedEdgeIndicator();
  item_->DestroyMirrorsForDragging();
  overview_session_->RemoveDropTargets();

  item_->UpdateShadowTypeForDrag(/*is_dragging=*/false);

  const gfx::Point rounded_screen_point =
      gfx::ToRoundedPoint(location_in_screen);
  if (is_eligible_for_drag_to_snap_) {
    // Update the split view divider bar status if necessary. The divider bar
    // should be placed above the dragged window after drag ends. Note here the
    // passed parameters |snap_position_| and |location_in_screen| won't be used
    // in this function for this case, but they are passed in as placeholders.
    aura::Window* window = item_->GetWindow();
    SplitViewController::Get(item_->root_window())
        ->OnWindowDragEnded(
            window, snap_position_, rounded_screen_point,
            WindowSnapActionSource::kDragOrSelectOverviewWindowToSnap);

    // Update window grid bounds and |snap_position_| in case the screen
    // orientation was changed.
    UpdateDragIndicatorsAndOverviewGrid(location_in_screen);
    overview_session_->ResetSplitViewDragIndicatorsWindowDraggingStates();
    item_->UpdateCannotSnapWarningVisibility(/*animate=*/true);
  }

  // This function has multiple exit positions, at each we must update the desks
  // bar widget bounds. We can't do this before we attempt dropping the window
  // on a desk mini_view, since this will change where it is relative to the
  // current |location_in_screen|.
  absl::Cleanup at_exit_runner = [] {
    // Overview might have exited if we snapped windows on both sides.
    auto* overview_controller = OverviewController::Get();
    if (!overview_controller->InOverviewSession())
      return;

    for (auto& grid : overview_controller->overview_session()->grid_list())
      grid->MaybeUpdateDesksWidgetBounds();
  };

  aura::Window* target_root = GetRootWindowBeingDraggedIn();
  const bool is_dragged_to_other_display = target_root != item_->root_window();
  auto* current_grid = GetCurrentGrid();
  if (virtual_desks_bar_enabled_) {
    item_->SetOpacity(original_opacity_);

    // Attempt to move a window to a different desk.
    if (current_grid->MaybeDropItemOnDeskMiniViewOrNewDeskButton(
            rounded_screen_point, item_)) {
      // Window was successfully moved to another desk, and |item_| was
      // removed from the grid. It may never be accessed after this.
      item_ = nullptr;
      event_source_item_ = nullptr;
      overview_session_->PositionWindows(/*animate=*/true);
      RecordNormalDrag(kToDesk, is_dragged_to_other_display);
      return DragResult::kDragToDesk;
    }
  }

  // Snap a window if appropriate.
  if (is_eligible_for_drag_to_snap_ && snap_position_ != SnapPosition::kNone) {
    // Overview grid will be updated after window is snapped in splitview.
    SnapWindow(SplitViewController::Get(target_root), snap_position_);
    RecordNormalDrag(kToSnap, is_dragged_to_other_display);
    MaybeRestoreNewDeskButtonState();
    return DragResult::kSnap;
  }

  DCHECK(item_);
  const bool dragged_item_is_visible_on_all_desks =
      DraggedItemIsVisibleOnAllDesks(item_);
  const bool item_intersects_other_display_desk_bar =
      virtual_desks_bar_enabled_ &&
      current_grid->IntersectsWithDesksBar(
          gfx::ToRoundedPoint(location_in_screen),
          /*update_desks_bar_drag_details=*/false, /*for_drop=*/false);

  // Drop a window into overview because we have not done anything else with it.
  // If the window is visible on all desks, only move it to another display if
  // it doesn't intersect the other grid's desk bar.
  if (is_dragged_to_other_display &&
      !(dragged_item_is_visible_on_all_desks &&
        item_intersects_other_display_desk_bar)) {
    int64_t target_display_id =
        display::Screen::Get()->GetDisplayNearestWindow(target_root).id();
    ScopedWindowsMover mover(target_display_id);

    // Get the window and bounds from |item_| before removing it from its grid.
    aura::Window* window = item_->GetWindow();
    const gfx::RectF target_item_bounds = item_->target_bounds();
    // Remove |item_| from overview. Leave the repositioning to the
    // |OverviewItemMoveHelper|.

    // If snapped , breake it now.
    if (auto* snap_group =
            SnapGroupController::Get()->GetSnapGroupForGivenWindow(window)) {
      mover.add_window(snap_group->window1() == window ? snap_group->window2()
                                                       : snap_group->window1());
      SnapGroupController::Get()->RemoveSnapGroup(
          snap_group, SnapGroupExitPoint::kMoveToAnotherDisplay);

      // Temporarily update the item.
      item_ = overview_session_->GetOverviewItemForWindow(window);
    }

    // For the window that controls its bounds directly, wait until client moves
    // the window.
    if (!WindowState::Get(window)->allow_set_bounds_direct()) {
      overview_session_->RemoveItem(item_, /*item_destroying=*/false,
                                    /*reposition=*/false);
    }
    item_ = nullptr;
    event_source_item_ = nullptr;
    // Move windows to the destination. The |OverviewItemMoveHelper| will take
    // care of the rest when the window is moved to another display's window
    // tree.
    mover.add_window(window);

    // The |OverviewItemMoveHelper| will self destruct when we move |window| to
    // |target_root|.
    new OverviewItemMoveHelper(mover.windows(), window, target_item_bounds);
  } else {
    item_->set_should_restack_on_animation_end(true);
    overview_session_->PositionWindows(/*animate=*/true);
    MaybeRestoreNewDeskButtonState();
  }
  RecordNormalDrag(kToGrid, is_dragged_to_other_display);
  return DragResult::kDropIntoOverview;
}

void OverviewWindowDragController::UpdateDragIndicatorsAndOverviewGrid(
    const gfx::PointF& location_in_screen) {
  CHECK(is_eligible_for_drag_to_snap_);
  snap_position_ = GetSnapPosition(location_in_screen);
  overview_session_->UpdateSplitViewDragIndicatorsWindowDraggingStates(
      GetRootWindowBeingDraggedIn(),
      SplitViewDragIndicators::ComputeWindowDraggingState(
          /*is_dragging=*/true,
          SplitViewDragIndicators::WindowDraggingState::kFromOverview,
          snap_position_));
  overview_session_->RearrangeDuringDrag(item_);
}

aura::Window* OverviewWindowDragController::GetRootWindowBeingDraggedIn()
    const {
  if (is_touch_dragging_) {
    return item_->root_window();
  }

  auto* screen = display::Screen::Get();
  CHECK(screen);
  auto display = screen->GetDisplayNearestPoint(screen->GetCursorScreenPoint());
  return Shell::GetRootWindowForDisplayId(display.id());
}

SnapPosition OverviewWindowDragController::GetSnapPosition(
    const gfx::PointF& location_in_screen) const {
  CHECK(item_);
  CHECK(is_eligible_for_drag_to_snap_);
  gfx::Rect area =
      screen_util::GetDisplayWorkAreaBoundsInScreenForActiveDeskContainer(
          GetRootWindowBeingDraggedIn());

  // If split view mode is active at the moment, and dragging an overview window
  // to snap it to a position that already has a snapped window in place, we
  // should show the preview window as soon as the window past the split divider
  // bar.
  aura::Window* root_window = GetRootWindowBeingDraggedIn();
  SplitViewController* split_view_controller =
      SplitViewController::Get(root_window);
  if (!split_view_controller->CanSnapWindow(item_->GetWindow(),
                                            chromeos::kDefaultSnapRatio)) {
    return SnapPosition::kNone;
  }
  if (split_view_controller->InSplitViewMode()) {
    // If we're trying to snap to a position that already has a snapped window:
    aura::Window* default_snapped_window =
        split_view_controller->GetDefaultSnappedWindow();
    if (gfx::RectF(default_snapped_window->GetBoundsInScreen())
            .Contains(location_in_screen)) {
      return split_view_controller->GetPositionOfSnappedWindow(
          default_snapped_window);
    }
  }

  return ::ash::GetSnapPosition(
      root_window, item_->GetWindow(), gfx::ToRoundedPoint(location_in_screen),
      gfx::ToRoundedPoint(initial_event_location_),
      /*snap_distance_from_edge=*/kDistanceFromEdgeDp,
      /*minimum_drag_distance=*/kMinimumDragToSnapDistanceDp,
      /*horizontal_edge_inset=*/area.width() *
              kHighlightScreenPrimaryAxisRatio +
          kHighlightScreenEdgePaddingDp,
      /*vertical_edge_inset=*/area.height() * kHighlightScreenPrimaryAxisRatio +
          kHighlightScreenEdgePaddingDp);
}

void OverviewWindowDragController::SnapWindow(
    SplitViewController* split_view_controller,
    SnapPosition snap_position) {
  DCHECK_NE(snap_position, SnapPosition::kNone);

  CHECK(!SplitViewController::Get(item_->root_window())->IsDividerAnimating());
  aura::Window* window = item_->GetWindow();

  // If `window` is currently fullscreen, snapping it will trigger a work area
  // change, which triggers `OverviewSession::OnDisplayMetricsChanged`. Display
  // changes normally end dragging for simplicity, but we need `item` to be
  // nullptr before that happens so we can skip resetting the window gesture.
  // See crbug.com/1330042 for more details. `item_` will be deleted after
  // SplitViewController::SnapWindow().
  item_ = nullptr;
  event_source_item_ = nullptr;
  split_view_controller->SnapWindow(
      window, snap_position,
      WindowSnapActionSource::kDragOrSelectOverviewWindowToSnap,
      /*activate_window=*/true);
}

OverviewGrid* OverviewWindowDragController::GetCurrentGrid() const {
  return overview_session_->GetGridWithRootWindow(
      GetRootWindowBeingDraggedIn());
}

void OverviewWindowDragController::RecordNormalDrag(
    NormalDragAction action,
    bool is_dragged_to_other_display) const {
  const bool is_tablet = display::Screen::Get()->InTabletMode();
  if (is_dragged_to_other_display) {
    DCHECK(!is_touch_dragging_);
    if (!is_tablet) {
      constexpr std::array<OverviewDragAction, kNormalDragActionEnumSize>
          kDrag = {OverviewDragAction::kToGridOtherDisplayClamshellMouse,
                   OverviewDragAction::kToDeskOtherDisplayClamshellMouse,
                   OverviewDragAction::kToSnapOtherDisplayClamshellMouse};
      RecordDrag(kDrag[action]);
    }
  } else if (is_tablet) {
    if (is_touch_dragging_) {
      constexpr std::array<OverviewDragAction, kNormalDragActionEnumSize>
          kDrag = {OverviewDragAction::kToGridSameDisplayTabletTouch,
                   OverviewDragAction::kToDeskSameDisplayTabletTouch,
                   OverviewDragAction::kToSnapSameDisplayTabletTouch};
      RecordDrag(kDrag[action]);
    }
  } else {
    constexpr std::array<OverviewDragAction, kNormalDragActionEnumSize>
        kMouseDrag = {OverviewDragAction::kToGridSameDisplayClamshellMouse,
                      OverviewDragAction::kToDeskSameDisplayClamshellMouse,
                      OverviewDragAction::kToSnapSameDisplayClamshellMouse};
    constexpr std::array<OverviewDragAction, kNormalDragActionEnumSize>
        kTouchDrag = {OverviewDragAction::kToGridSameDisplayClamshellTouch,
                      OverviewDragAction::kToDeskSameDisplayClamshellTouch,
                      OverviewDragAction::kToSnapSameDisplayClamshellTouch};
    RecordDrag(is_touch_dragging_ ? kTouchDrag[action] : kMouseDrag[action]);
  }
}

void OverviewWindowDragController::RecordDragToClose(
    DragToCloseAction action) const {
  DCHECK(is_touch_dragging_);
  constexpr std::array<OverviewDragAction, kDragToCloseActionEnumSize>
      kClamshellDrag = {
          OverviewDragAction::kSwipeToCloseSuccessfulClamshellTouch,
          OverviewDragAction::kSwipeToCloseCanceledClamshellTouch,
          OverviewDragAction::kFlingToCloseClamshellTouch};
  constexpr std::array<OverviewDragAction, kDragToCloseActionEnumSize>
      kTabletDrag = {OverviewDragAction::kSwipeToCloseSuccessfulTabletTouch,
                     OverviewDragAction::kSwipeToCloseCanceledTabletTouch,
                     OverviewDragAction::kFlingToCloseTabletTouch};
  RecordDrag(display::Screen::Get()->InTabletMode() ? kTabletDrag[action]
                                                    : kClamshellDrag[action]);
}

void OverviewWindowDragController::MaybeScaleUpNewDeskButton() {
  if (!item_ || !item_->overview_grid()) {
    return;
  }

  // When there's only one window and it's snapped, overview mode will be
  // ended. Thus we need to check whether `overview_session_` is being
  // shutting down or not here before triggering `UpdateDeskIconButtonState`.
  if (!overview_session_) {
    return;
  }

  auto* overview_grid =
      overview_session_->GetGridWithRootWindow(GetRootWindowBeingDraggedIn());
  auto* desks_bar_view = overview_grid->desks_bar_view();
  auto* new_desk_button = desks_bar_view->new_desk_button();

  if (!new_desk_button->GetEnabled()) {
    return;
  }

  // Do not reposition the windows while changing the desk icon button. This
  // could cause items to shift around mid drag.
  overview_session_->SuspendReposition();
  desks_bar_view->UpdateDeskIconButtonState(
      new_desk_button, /*target_state=*/DeskIconButton::State::kActive);
  overview_session_->ResumeReposition();
}

}  // namespace ash