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

#include "ash/wm/splitview/split_view_metrics_controller.h"

#include <algorithm>
#include <vector>

#include "ash/root_window_controller.h"
#include "ash/root_window_settings.h"
#include "ash/session/session_controller_impl.h"
#include "ash/shell.h"
#include "ash/wm/desks/desk.h"
#include "ash/wm/desks/desks_util.h"
#include "ash/wm/mru_window_tracker.h"
#include "ash/wm/overview/overview_controller.h"
#include "ash/wm/splitview/split_view_controller.h"
#include "ash/wm/splitview/split_view_utils.h"
#include "ash/wm/switchable_windows.h"
#include "ash/wm/window_positioning_utils.h"
#include "ash/wm/window_restore/window_restore_controller.h"
#include "ash/wm/window_state.h"
#include "ash/wm/window_util.h"
#include "ash/wm/wm_metrics.h"
#include "base/check_op.h"
#include "base/containers/adapters.h"
#include "base/containers/contains.h"
#include "base/memory/raw_ptr.h"
#include "base/metrics/histogram_functions.h"
#include "base/time/time.h"
#include "chromeos/ui/base/display_util.h"
#include "chromeos/ui/base/window_state_type.h"
#include "components/app_restore/window_info.h"
#include "components/app_restore/window_properties.h"
#include "components/prefs/pref_service.h"
#include "ui/aura/env.h"
#include "ui/display/screen.h"
#include "ui/display/tablet_state.h"
#include "ui/wm/public/activation_client.h"

namespace ash {

namespace {

// Histogram of the device UI mode when entering split view.
constexpr char kSplitViewEntryPointDeviceUIModeHistogram[] =
    "Ash.SplitView.EntryPoint.DeviceUIMode";
// Histogram of the device orientation when entering split view.
constexpr char kSplitViewEntryPointDeviceOrientationHistogram[] =
    "Ash.SplitView.EntryPoint.DeviceOrientation";
// Histogram of the device orientation when using split view.
constexpr char kSplitViewDeviceOrientationPrefix[] =
    "Ash.SplitView.DeviceOrientation";
// Histogram of the device orientation changes when using split view.
constexpr char kOrientationInSplitViewHistogram[] =
    "Ash.SplitView.OrientationInSplitView";
// Histogram of the engagement time in clamshell split view.
constexpr char kTimeInSplitScreenClamshellHistogram[] =
    "Ash.SplitView.TimeInSplitScreen.ClamshellMode";
// Histogram of the engagement time in tablet split view.
constexpr char kTimeInSplitScreenTabletHistogram[] =
    "Ash.SplitView.TimeInSplitScreen.TabletMode";
// Histogram of the engagement time in multi-display clamshell split view.
constexpr char kTimeInMultiDisplaySplitScreenClamshellHistogram[] =
    "Ash.SplitView.TimeInMultiDisplaySplitScreen.ClamshellMode";
// Histogram of the engagement time in multi-display tablet split view.
constexpr char kTimeInMultiDisplaySplitScreenTabletHistogram[] =
    "Ash.SplitView.TimeInMultiDisplaySplitScreen.TabletMode";
// Histogram of the number of resizing window operations in clamshell split
// view.
constexpr char kSplitViewResizeWindowCountClamshellHistogram[] =
    "Ash.SplitView.ResizeWindowCount.ClamshellMode";
// Histogram of the number of resizing window operations in tablet split view.
constexpr char kSplitViewResizeWindowCountTabletHistogram[] =
    "Ash.SplitView.ResizeWindowCount.TabletMode";
// Histogram of the number of swapping window operations in split view.
constexpr char kSplitViewSwapWindowCountHistogram[] =
    "Ash.SplitView.SwapWindowCount";

constexpr base::TimeTicks kInvalidTime = base::TimeTicks::Max();

// Start time of clamshell and tablet multi-display split view.
base::TimeTicks g_clamshell_multi_display_split_view_start_time;
base::TimeTicks g_tablet_multi_display_split_view_start_time;

// An accumulator of clamshell multi-display split view engagement time. When
// the clamshell split view with two windows snapped on both sides is paused
// (the definition of "pause" is defined in the comments at the beginning of the
// the header file), accumulate the current engagement time period.
int64_t g_clamshell_multi_display_split_view_time_ms;

bool IsRecordingClamshellMultiDisplaySplitView() {
  return g_clamshell_multi_display_split_view_start_time != kInvalidTime;
}

bool IsRecordingTabletMultiDisplaySplitView() {
  return g_tablet_multi_display_split_view_start_time != kInvalidTime;
}

// Number of root windows in split view.
int NumRootWindowsInSplitViewRecording() {
  auto root_windows = Shell::GetAllRootWindows();
  return std::ranges::count_if(root_windows, [](aura::Window* root_window) {
    return SplitViewController::Get(root_window)
        ->split_view_metrics_controller()
        ->in_split_view_recording();
  });
}

bool InTabletMode() {
  return display::Screen::Get()->InTabletMode();
}

bool TopTwoVisibleWindowsBothSnapped(
    const std::vector<raw_ptr<aura::Window, VectorExperimental>>& windows) {
  int windows_size = windows.size();
  if (windows_size < 2)
    return false;

  // Check if there are snapped windows on both sides without hidden by other
  // windows. The topmost window is at the end of the list.
  WindowState* top_snap_window_state = WindowState::Get(windows.back());
  if (!top_snap_window_state->IsSnapped())
    return false;

  for (aura::Window* window : base::Reversed(windows)) {
    // Skip the top one.
    if (window == windows.back())
      continue;

    auto* window_state = WindowState::Get(window);
    // Skip the invisible windows.
    if (!window->IsVisible())
      continue;
    if (!window_state->IsSnapped())
      return false;
    if (window_state->GetStateType() == top_snap_window_state->GetStateType()) {
      continue;
    } else {
      return true;
    }
  }
  return false;
}

// Appends the proper suffix to |prefix| based on whether the device is in
// tablet mode or not.
std::string GetHistogramNameWithDeviceUIMode(std::string prefix) {
  return prefix.append(InTabletMode() ? ".TabletMode" : ".ClamshellMode");
}

SplitViewMetricsController::DeviceOrientation GetDeviceOrientation(
    const display::Display& display) {
  return display.is_landscape()
             ? SplitViewMetricsController::DeviceOrientation::kLandscape
             : SplitViewMetricsController::DeviceOrientation::kPortrait;
}

// Records the pref value of `kSnapWindowSuggestions` at the time a window is
// snapped.
void MaybeRecordSnapWindowSuggestions(
    WindowSnapActionSource snap_action_source) {
  if (!CanSnapActionSourceStartFasterSplitView(snap_action_source)) {
    return;
  }
  PrefService* pref_service =
      Shell::Get()->session_controller()->GetActivePrefService();
  if (!pref_service) {
    return;
  }
  base::UmaHistogramBoolean(
      BuildSnapWindowSuggestionsHistogramName(snap_action_source),
      pref_service->GetBoolean(prefs::kSnapWindowSuggestions));
}

}  // namespace

// static
SplitViewMetricsController* SplitViewMetricsController::Get(
    aura::Window* window) {
  DCHECK(window);
  DCHECK(window->GetRootWindow());

  auto* root_window_controller = RootWindowController::ForWindow(window);
  DCHECK(root_window_controller);

  return root_window_controller->split_view_controller()
      ->split_view_metrics_controller();
}

SplitViewMetricsController::SplitViewMetricsController(
    SplitViewController* split_view_controller)
    : split_view_controller_(split_view_controller) {
  split_view_controller_->AddObserver(this);
  Shell::Get()->activation_client()->AddObserver(this);

  auto* desks_controller = Shell::Get()->desks_controller();
  desks_controller->AddObserver(this);
  current_desk_ = desks_controller->active_desk();

  aura::Env::GetInstance()->AddObserver(this);

  const display::Display display =
      display::Screen::Get()->GetDisplayNearestWindow(
          split_view_controller->root_window());
  orientation_ = GetDeviceOrientation(display);
  ResetTimeAndCounter();
}

SplitViewMetricsController::~SplitViewMetricsController() {
  ClearObservedWindows();
  split_view_controller_->RemoveObserver(this);
  Shell::Get()->activation_client()->RemoveObserver(this);
  Shell::Get()->desks_controller()->RemoveObserver(this);
  aura::Env::GetInstance()->RemoveObserver(this);
}

void SplitViewMetricsController::OnSplitViewStateChanged(
    SplitViewController::State previous_state,
    SplitViewController::State state) {
  if (previous_state == state)
    return;

  if (previous_state == SplitViewController::State::kNoSnap)
    StartRecordSplitViewMetrics();
  else if (state == SplitViewController::State::kNoSnap)
    StopRecordSplitViewMetrics();
}

void SplitViewMetricsController::OnSplitViewWindowResized() {
  DCHECK(split_view_controller_->InSplitViewMode());

  if (split_view_controller_->InClamshellSplitViewMode())
    clamshell_resize_count_ += 1;
  else
    tablet_resize_count_ += 1;
}

void SplitViewMetricsController::OnSplitViewWindowSwapped() {
  DCHECK(split_view_controller_->InSplitViewMode());

  swap_count_ += 1;

  // Decreases the counter by 2, since swapping windows will trigger resizing
  // window twice.
  if (split_view_controller_->InClamshellSplitViewMode())
    clamshell_resize_count_ -= 2;
  else
    tablet_resize_count_ -= 2;
}

void SplitViewMetricsController::OnDisplayMetricsChanged(
    const display::Display& display,
    uint32_t changed_metrics) {
  if (!(changed_metrics &
        display::DisplayObserver::DisplayMetric::DISPLAY_METRIC_ROTATION)) {
    return;
  }

  // Do nothing if the split view does not belongs to the modified display.
  if (GetRootWindowSettings(split_view_controller_->root_window())
          ->display_id != display.id()) {
    return;
  }

  const DeviceOrientation orientation = GetDeviceOrientation(display);
  if (orientation_ == orientation)
    return;
  orientation_ = orientation;

  // Reports change of the display orientation.
  if (in_split_view_recording_) {
    base::UmaHistogramEnumeration(kOrientationInSplitViewHistogram,
                                  orientation_);
    ReportDeviceUIModeAndOrientationHistogram();
  }
}

void SplitViewMetricsController::OnDisplayTabletStateChanged(
    display::TabletState state) {
  switch (state) {
    case display::TabletState::kEnteringTabletMode:
    case display::TabletState::kExitingTabletMode:
      break;
    case display::TabletState::kInTabletMode:
      OnTabletModeStarted();
      break;
    case display::TabletState::kInClamshellMode:
      OnTabletModeEnded();
      break;
  }
}

void SplitViewMetricsController::OnWindowParentChanged(aura::Window* window,
                                                       aura::Window* parent) {
  // Stop observing the window when it is moved to another desk. If the restored
  // window is parented to current desk, observe its window state change.
  if (parent && desks_util::IsDeskContainer(parent)) {
    if (parent->GetId() != current_desk_->container_id()) {
      RemoveObservedWindow(window);
    } else if (base::Contains(no_state_observed_windows_, window)) {
      WindowState::Get(window)->AddObserver(this);
      no_state_observed_windows_.erase(window);
    }

    // If the top two windows snapped on both sides in clamshell mode, moving
    // one of the snapped windows to another desk may end the split view. If
    // there are two windows snapped on both sides with another unsnapped window
    // on top in clamshell mode, moving the unsnapped window to another desk may
    // start split view.
    MaybeStartOrEndRecordBothSnappedClamshellSplitView();
  }
}

void SplitViewMetricsController::OnResizeLoopEnded(aura::Window* window) {
  // Only report window resizing if it is in the split view with two windows
  // snapped on both sides.
  if (!in_split_view_recording_ || split_view_controller_->InSplitViewMode())
    return;

  clamshell_resize_count_ += 1;
}

void SplitViewMetricsController::OnWindowDestroyed(aura::Window* window) {
  RemoveObservedWindow(window);

  // If the top two windows snapped on both sides in clamshell mode,
  // destroying one of the snapped windows may end the split view. If there
  // are two windows snapped on both sides with another unsnapped window
  // on top in clamshell mode, destroying the unsnapped window may start split
  // view.
  MaybeStartOrEndRecordBothSnappedClamshellSplitView();
}

void SplitViewMetricsController::OnWindowRemovingFromRootWindow(
    aura::Window* window,
    aura::Window* new_root) {
  // Stop observing the window if it is removing from current root window.
  RemoveObservedWindow(window);

  // If the top two windows snapped on both sides in clamshell mode,
  // moving one of the snapped windows to another display may end the split
  // view. If there are two windows snapped on both sides with another unsnapped
  // window on top in clamshell mode, moving the unsnapped window to another
  // display may start split view.
  MaybeStartOrEndRecordBothSnappedClamshellSplitView();

  // Add the window to the new root window's split view metrics controller. It
  // may make the new root window start or end split view metrics recording.
  if (new_root) {
    auto* target_split_view_metrics_controller =
        SplitViewController::Get(new_root)->split_view_metrics_controller();
    DCHECK(target_split_view_metrics_controller);
    if (!target_split_view_metrics_controller->IsObservingWindow(window)) {
      target_split_view_metrics_controller->AddObservedWindow(window);
      target_split_view_metrics_controller
          ->MaybeStartOrEndRecordBothSnappedClamshellSplitView();
    }
  }
}

void SplitViewMetricsController::OnPostWindowStateTypeChange(
    WindowState* window_state,
    chromeos::WindowStateType old_type) {
  MaybeStartOrEndRecordSnapTwoWindowsDuration(window_state);
  MaybeStartOrEndRecordMinimizeTwoWindowsDuration(window_state, old_type);

  // We only care if a window is snapped or unsnapped.
  bool is_snapped = window_state->IsSnapped();
  if (is_snapped) {
    MaybeRecordSnapWindowSuggestions(
        window_state->snap_action_source().value_or(
            WindowSnapActionSource::kNotSpecified));
  }
  bool was_snapped = chromeos::IsSnappedWindowStateType(old_type);
  if (is_snapped == was_snapped)
    return;

  if (was_snapped &&
      chromeos::IsSnappedWindowStateType(first_closed_state_type_) &&
      old_type != first_closed_state_type_) {
    // If a window in the opposite side of `first_closed_state_type_` gets
    // unsnapped, record the max duration to indicate a second snapped window
    // was never closed after the first window.
    RecordCloseTwoWindowsDuration(kSequentialSnapActionMaxTime);
  }

  MaybeStartOrEndRecordBothSnappedClamshellSplitView();
}

void SplitViewMetricsController::OnWindowActivated(ActivationReason reason,
                                                   aura::Window* gained_active,
                                                   aura::Window* lost_active) {
  // Reorder the observed windows.
  AddOrStackWindowOnTop(gained_active);
  MaybeStartOrEndRecordBothSnappedClamshellSplitView();
}

void SplitViewMetricsController::OnDeskActivationChanged(
    const Desk* activated,
    const Desk* deactivated) {
  // When switching desks, ends the split view and updates observed windows.
  StopRecordSplitViewMetrics();
  current_desk_ = Shell::Get()->desks_controller()->active_desk();
  InitObservedWindowsOnActiveDesk();

  // Check if the new desk is in clamshell split view with two windows snapped
  // on both sides.
  MaybeStartOrEndRecordBothSnappedClamshellSplitView();
}

void SplitViewMetricsController::OnWindowInitialized(aura::Window* window) {
  int32_t* activation_index =
      window->GetProperty(app_restore::kActivationIndexKey);
  if (!activation_index)
    return;

  app_restore::WindowInfo* window_info =
      window->GetProperty(app_restore::kWindowInfoKey);
  if (!window_info)
    return;

  // Check if the recovered window belongs to the same root window.
  // Note: The display id saved in window_info has no value. Need to use the
  // restore bounds/
  if (!window_info->current_bounds.has_value() ||
      !display::Screen::Get()
           ->GetDisplayNearestWindow(split_view_controller_->root_window())
           .work_area()
           .Contains(window_info->current_bounds.value())) {
    return;
  }

  // Check if the recovered window is in the current desk.
  if (!window_info->desk_guid.is_valid() ||
      window_info->desk_guid != current_desk_->uuid()) {
    return;
  }

  // Insert the window in the `observed_windows_` list according to its
  // activation index key. Since the window is not parented at this stage, the
  // `WindowStateObserver` will be added later in `OnWindowParentChanged`.
  window->AddObserver(this);
  no_state_observed_windows_.insert(window);
  observed_windows_.insert(WindowRestoreController::GetWindowToInsertBefore(
                               window, observed_windows_),
                           window);
}

void SplitViewMetricsController::StartRecordSplitViewMetrics() {
  if (in_split_view_recording_)
    return;

  // If the split view is started with a snapped window next to the overview,
  // and there is only one window (no overview items), the overview will end
  // immediately so does the split view. We won't record this case.
  if (split_view_controller_->InClamshellSplitViewMode() &&
      Shell::Get()
              ->mru_window_tracker()
              ->BuildMruWindowList(DesksMruType::kActiveDesk)
              .size() == 1) {
    return;
  }

  bool in_clamshell = !InTabletMode();
  if (in_clamshell)
    StartRecordClamshellSplitView();
  else
    StartRecordTabletSplitView();

  in_split_view_recording_ = true;
  // The starting of this split view makes the number of root windows in split
  // view become two, which means the multi-display split view just started.
  if (NumRootWindowsInSplitViewRecording() == 2) {
    if (in_clamshell)
      StartRecordClamshellMultiDisplaySplitView();
    else
      StartRecordTabletMultiDisplaySplitView();
  }

  base::UmaHistogramEnumeration(kSplitViewEntryPointDeviceOrientationHistogram,
                                orientation_);
  base::UmaHistogramEnumeration(
      kSplitViewEntryPointDeviceUIModeHistogram,
      in_clamshell ? DeviceUIMode::kClamshell : DeviceUIMode::kTablet);
}

void SplitViewMetricsController::StopRecordSplitViewMetrics() {
  if (!in_split_view_recording_)
    return;

  bool is_recording_clamshell_metrics = IsRecordingClamshellMetrics();
  if (is_recording_clamshell_metrics) {
    // If the split view is started with a snapped window next to the overview,
    // the the user activate a window by clicking the overview item, the window
    // will snap to the other side. Therefore, stacks the window on top.
    if (auto* to_be_activated_window =
            split_view_controller_->to_be_activated_window()) {
      AddOrStackWindowOnTop(to_be_activated_window);
    }

    // Do not end if there are still two windows snapped on both sides on top.
    if (TopTwoVisibleWindowsBothSnapped(observed_windows_))
      return;

    StopRecordClamshellSplitView();
  } else {
    StopRecordTabletSplitView();
  }

  base::UmaHistogramCounts100(kSplitViewSwapWindowCountHistogram, swap_count_);

  in_split_view_recording_ = false;

  // The ending of this split view makes the number of root windows in split
  // view become one, which means the multi-display split view just ended.
  if (NumRootWindowsInSplitViewRecording() == 1) {
    if (is_recording_clamshell_metrics)
      StopRecordClamshellMultiDisplaySplitView();
    else
      StopRecordTabletMultiDisplaySplitView();
  }
  ResetTimeAndCounter();
}

bool SplitViewMetricsController::IsObservingWindow(aura::Window* window) const {
  return base::Contains(observed_windows_, window);
}

void SplitViewMetricsController::AddObservedWindow(aura::Window* window) {
  window->AddObserver(this);
  WindowState::Get(window)->AddObserver(this);
  observed_windows_.emplace_back(window);
}

void SplitViewMetricsController::RemoveObservedWindow(aura::Window* window) {
  if (window->is_destroying()) {
    MaybeStartOrEndRecordCloseTwoWindowsDuration(window);
  }

  if (window == first_snapped_window_) {
    if (window->is_destroying()) {
      // If `first_snapped_window_` was destroyed, record the max duration to
      // indicate a second window was never snapped on the opposite side.
      RecordSnapTwoWindowsDuration(kSequentialSnapActionMaxTime);
    }
    first_snapped_window_ = nullptr;
  }
  if (first_minimized_window_state_ &&
      window == first_minimized_window_state_->window()) {
    if (window->is_destroying()) {
      RecordMinimizeTwoWindowsDuration(kSequentialSnapActionMaxTime);
    }
    first_minimized_window_state_ = nullptr;
  }
  if (std::erase(observed_windows_, window)) {
    WindowState::Get(window)->RemoveObserver(this);
    window->RemoveObserver(this);
  }
}

void SplitViewMetricsController::AddOrStackWindowOnTop(aura::Window* window) {
  // We only observe the activable windows on active desk of the root window
  // attached by |split_view_controller_|.
  if (!window)
    return;

  if (window->GetRootWindow() != split_view_controller_->root_window())
    return;

  aura::Window* parent = window->parent();
  if (!parent || !IsSwitchableContainer(parent))
    return;

  const int parent_id = parent->GetId();
  if (desks_util::IsDeskContainerId(parent_id) &&
      parent_id != current_desk_->container_id()) {
    return;
  }

  if (!CanIncludeWindowInMruList(window))
    return;

  auto iter = std::ranges::find(observed_windows_, window);
  if (iter == observed_windows_.end()) {
    AddObservedWindow(window);
  } else {
    observed_windows_.erase(iter);
    observed_windows_.emplace_back(window);
  }
}

void SplitViewMetricsController::InitObservedWindowsOnActiveDesk() {
  ClearObservedWindows();

  auto windows =
      current_desk_
          ->GetDeskContainerForRoot(split_view_controller_->root_window())
          ->children();
  for (aura::Window* window : windows) {
    if (!CanIncludeWindowInMruList(window))
      continue;
    AddObservedWindow(window);
  }
}

void SplitViewMetricsController::ClearObservedWindows() {
  while (!observed_windows_.empty()) {
    RemoveObservedWindow(observed_windows_.back());
  }
}

void SplitViewMetricsController::
    MaybeStartOrEndRecordBothSnappedClamshellSplitView() {
  if (InTabletMode() || split_view_controller_->InSplitViewMode()) {
    return;
  }

  bool both_snapped = TopTwoVisibleWindowsBothSnapped(observed_windows_);
  if (!in_split_view_recording_ && both_snapped) {
    StartRecordSplitViewMetrics();
  } else if (in_split_view_recording_ && !both_snapped) {
    StopRecordSplitViewMetrics();
  }
}

bool SplitViewMetricsController::
    MaybePauseRecordBothSnappedClamshellSplitView() {
  if (InTabletMode() || split_view_controller_->InSplitViewMode()) {
    return false;
  }

  if (observed_windows_.size() < 3)
    return false;
  // Find the topmost unsnapped visible window.
  auto iter = observed_windows_.end() - 1;
  auto begin_iter = observed_windows_.begin();
  for (; iter != begin_iter; iter--) {
    if (!(*iter)->IsVisible())
      continue;
    if (WindowState::Get(*iter)->IsSnapped())
      return false;
    else
      break;
  }

  if (iter == begin_iter)
    return false;

  return TopTwoVisibleWindowsBothSnapped(
      std::vector<raw_ptr<aura::Window, VectorExperimental>>(begin_iter, iter));
}

void SplitViewMetricsController::RecordSnapTwoWindowsDuration(
    const base::TimeDelta& elapsed_time) {
  base::UmaHistogramCustomTimes(kSnapTwoWindowsDurationHistogramName,
                                /*sample=*/elapsed_time,
                                kSequentialSnapActionMinTime,
                                kSequentialSnapActionMaxTime, /*buckets=*/100);
  first_snapped_window_ = nullptr;
  first_snapped_time_ = base::TimeTicks();
}

void SplitViewMetricsController::RecordMinimizeTwoWindowsDuration(
    const base::TimeDelta& elapsed_time) {
  base::UmaHistogramCustomTimes(kMinimizeTwoWindowsDurationHistogramName,
                                /*sample=*/elapsed_time,
                                kSequentialSnapActionMinTime,
                                kSequentialSnapActionMaxTime, /*buckets=*/100);
  first_minimized_window_state_ = nullptr;
  first_minimized_time_ = base::TimeTicks();
}

void SplitViewMetricsController::RecordCloseTwoWindowsDuration(
    const base::TimeDelta& elapsed_time) {
  base::UmaHistogramCustomTimes(kCloseTwoWindowsDurationHistogramName,
                                /*sample=*/elapsed_time,
                                kSequentialSnapActionMinTime,
                                kSequentialSnapActionMaxTime, /*buckets=*/100);
  // Reset `first_closed_state_type_` to kDefault to stop recording.
  first_closed_state_type_ = chromeos::WindowStateType::kDefault;
  first_closed_time_ = base::TimeTicks();
}

void SplitViewMetricsController::MaybeStartOrEndRecordSnapTwoWindowsDuration(
    WindowState* window_state) {
  // If `first_snapped_window_` is no longer snapped, record the max duration to
  // indicate a second window was never snapped on the opposite side.
  if (first_snapped_window_ &&
      !WindowState::Get(first_snapped_window_)->IsSnapped()) {
    // Any state type change can change `first_snapped_window_`'s state type
    // (i.e. float). This must be reset before we check `first_snapped_window_`
    // below.
    RecordSnapTwoWindowsDuration(kSequentialSnapActionMaxTime);
  }
  if (window_state->IsSnapped()) {
    if (first_snapped_window_ && !first_snapped_time_.is_null() &&
        window_state->window() != first_snapped_window_ &&
        window_state->GetStateType() ==
            ToWindowStateType(GetOppositeSnapType(first_snapped_window_))) {
      // If this is a different window that got snapped on the opposite side,
      // record the duration since `first_snapped_time_`.
      RecordSnapTwoWindowsDuration(base::TimeTicks::Now() -
                                   first_snapped_time_);
      return;
    }
    // Else start recording. If the same window gets snapped again, this will
    // restart recording.
    first_snapped_window_ = window_state->window();
    first_snapped_time_ = base::TimeTicks::Now();
    return;
  }
}

void SplitViewMetricsController::
    MaybeStartOrEndRecordMinimizeTwoWindowsDuration(
        WindowState* window_state,
        chromeos::WindowStateType old_type) {
  const bool is_minimized = window_state->IsMinimized();
  if (is_minimized && chromeos::IsSnappedWindowStateType(old_type)) {
    if (first_minimized_window_state_ && !first_minimized_time_.is_null()) {
      // No need to check if `first_minimized_window_state_` is the same as
      // `window_state`, since if it changes state it would no longer be
      // minimized, and would fall through to record the max duration below.
      RecordMinimizeTwoWindowsDuration(base::TimeTicks::Now() -
                                       first_minimized_time_);
      return;
    }
    first_minimized_window_state_ = window_state;
    first_minimized_time_ = base::TimeTicks::Now();
    return;
  }
  if (window_state == first_minimized_window_state_ && !is_minimized &&
      !window_state->IsSnapped()) {
    // If the first window is no longer minimized or snapped, record the max
    // duration to indicate no other window was snapped then minimized.
    RecordMinimizeTwoWindowsDuration(kSequentialSnapActionMaxTime);
  }
}

void SplitViewMetricsController::MaybeStartOrEndRecordCloseTwoWindowsDuration(
    aura::Window* window) {
  if (auto* window_state = WindowState::Get(window);
      window_state && window_state->IsSnapped()) {
    if (!chromeos::IsSnappedWindowStateType(first_closed_state_type_)) {
      // If `first_closed_state_type_` is reset to kDefault, start recording.
      first_closed_state_type_ = window_state->GetStateType();
      first_closed_time_ = base::TimeTicks::Now();
      return;
    }
    // If `window` has the opposite state type of `first_closed_state_type_`,
    // record the duration.
    if (ToWindowStateType(GetOppositeSnapType(window)) ==
            first_closed_state_type_ &&
        !first_closed_time_.is_null()) {
      RecordCloseTwoWindowsDuration(base::TimeTicks::Now() -
                                    first_closed_time_);
    }
  }
}

void SplitViewMetricsController::ResetTimeAndCounter() {
  clamshell_split_view_start_time_ = kInvalidTime;
  tablet_split_view_start_time_ = kInvalidTime;
  clamshell_resize_count_ = 0;
  tablet_resize_count_ = 0;
  swap_count_ = 0;
}

void SplitViewMetricsController::OnTabletModeStarted() {
  // If it has been in split view and recording clamshell mode metrics, stop
  // recording clamshell mode metrics and start to record tablet mode metrics.
  if (in_split_view_recording_ && IsRecordingClamshellMetrics()) {
    StopRecordClamshellSplitView();
    StartRecordTabletSplitView();
    if (NumRootWindowsInSplitViewRecording() > 1 &&
        IsRecordingClamshellMultiDisplaySplitView()) {
      StopRecordClamshellMultiDisplaySplitView();
      StartRecordTabletMultiDisplaySplitView();
    }
  }
}

void SplitViewMetricsController::OnTabletModeEnded() {
  // If it has been in split view and recording tablet mode metrics, stop
  // recording tablet mode metrics and start to record clamshell mode metrics.
  if (in_split_view_recording_ && IsRecordingTabletMetrics()) {
    StopRecordTabletSplitView();
    StartRecordClamshellSplitView();
    if (NumRootWindowsInSplitViewRecording() > 1 &&
        IsRecordingTabletMultiDisplaySplitView()) {
      StopRecordTabletMultiDisplaySplitView();
      StartRecordClamshellMultiDisplaySplitView();
    }
  }
}

bool SplitViewMetricsController::IsRecordingClamshellMetrics() const {
  return clamshell_split_view_start_time_ != kInvalidTime;
}
bool SplitViewMetricsController::IsRecordingTabletMetrics() const {
  return tablet_split_view_start_time_ != kInvalidTime;
}

void SplitViewMetricsController::StartRecordClamshellSplitView() {
  clamshell_split_view_start_time_ = base::TimeTicks::Now();
  ReportDeviceUIModeAndOrientationHistogram();
}

void SplitViewMetricsController::StopRecordClamshellSplitView() {
  DCHECK_NE(clamshell_split_view_start_time_, kInvalidTime);

  // Accumulate the engagement time.
  clamshell_split_view_time_ +=
      (base::TimeTicks::Now() - clamshell_split_view_start_time_)
          .InMicroseconds();
  clamshell_split_view_start_time_ = kInvalidTime;

  // If pauses, do not emit the records.
  if (MaybePauseRecordBothSnappedClamshellSplitView())
    return;

  base::UmaHistogramLongTimes(kTimeInSplitScreenClamshellHistogram,
                              base::Milliseconds(clamshell_split_view_time_));
  base::UmaHistogramCounts100(kSplitViewResizeWindowCountClamshellHistogram,
                              clamshell_resize_count_);
  clamshell_split_view_time_ = 0;
  clamshell_resize_count_ = 0;
}

void SplitViewMetricsController::StartRecordTabletSplitView() {
  tablet_split_view_start_time_ = base::TimeTicks::Now();
  ReportDeviceUIModeAndOrientationHistogram();
}

void SplitViewMetricsController::StopRecordTabletSplitView() {
  DCHECK_NE(tablet_split_view_start_time_, kInvalidTime);

  base::UmaHistogramLongTimes(
      kTimeInSplitScreenTabletHistogram,
      base::TimeTicks::Now() - tablet_split_view_start_time_);
  tablet_split_view_start_time_ = kInvalidTime;

  base::UmaHistogramCounts100(kSplitViewResizeWindowCountTabletHistogram,
                              tablet_resize_count_);
  tablet_resize_count_ = 0;
}

void SplitViewMetricsController::StartRecordClamshellMultiDisplaySplitView() {
  g_clamshell_multi_display_split_view_start_time = base::TimeTicks::Now();
  ReportDeviceUIModeAndOrientationHistogram();
}

void SplitViewMetricsController::StopRecordClamshellMultiDisplaySplitView() {
  DCHECK_NE(g_clamshell_multi_display_split_view_start_time, kInvalidTime);

  // Accumulate the engagement time.
  g_clamshell_multi_display_split_view_time_ms =
      (base::TimeTicks::Now() - g_clamshell_multi_display_split_view_start_time)
          .InMilliseconds();
  g_clamshell_multi_display_split_view_start_time = kInvalidTime;

  // If pauses, do not emit the records.
  if (MaybePauseRecordBothSnappedClamshellSplitView())
    return;

  base::UmaHistogramLongTimes(
      kTimeInMultiDisplaySplitScreenClamshellHistogram,
      base::Milliseconds(g_clamshell_multi_display_split_view_time_ms));
  g_clamshell_multi_display_split_view_time_ms = 0;
}

void SplitViewMetricsController::StartRecordTabletMultiDisplaySplitView() {
  g_tablet_multi_display_split_view_start_time = base::TimeTicks::Now();
  ReportDeviceUIModeAndOrientationHistogram();
}

void SplitViewMetricsController::StopRecordTabletMultiDisplaySplitView() {
  DCHECK_NE(g_tablet_multi_display_split_view_start_time, kInvalidTime);

  base::UmaHistogramLongTimes(
      kTimeInMultiDisplaySplitScreenTabletHistogram,
      base::TimeTicks::Now() - g_tablet_multi_display_split_view_start_time);
  g_tablet_multi_display_split_view_start_time = kInvalidTime;
}

void SplitViewMetricsController::ReportDeviceUIModeAndOrientationHistogram() {
  base::UmaHistogramEnumeration(
      GetHistogramNameWithDeviceUIMode(kSplitViewDeviceOrientationPrefix),
      orientation_);
}

}  // namespace ash