// Copyright 2020 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/system/accessibility/floating_accessibility_controller.h"

#include "ash/accelerators/accelerator_controller_impl.h"
#include "ash/accessibility/a11y_feature_type.h"
#include "ash/accessibility/accessibility_controller.h"
#include "ash/accessibility/autoclick/autoclick_controller.h"
#include "ash/ime/ime_controller_impl.h"
#include "ash/public/cpp/ime_info.h"
#include "ash/public/cpp/session/session_types.h"
#include "ash/session/session_controller_impl.h"
#include "ash/shell.h"
#include "ash/system/accessibility/accessibility_detailed_view.h"
#include "ash/system/accessibility/autoclick_menu_bubble_controller.h"
#include "ash/system/accessibility/autoclick_menu_view.h"
#include "ash/system/ime_menu/ime_menu_tray.h"
#include "ash/test/ash_test_base.h"
#include "base/barrier_closure.h"
#include "base/functional/callback.h"
#include "base/functional/callback_helpers.h"
#include "base/strings/stringprintf.h"
#include "ui/compositor/layer.h"
#include "ui/views/accessibility/view_accessibility.h"

namespace ash {

namespace {

// A buffer for checking whether the menu view is near this region of the
// screen. This buffer allows for things like padding and the shelf size,
// but is still smaller than half the screen size, so that we can check the
// general corner in which the menu is displayed.
const int kMenuViewBoundsBuffer = 100;
const char ImeEnglishId[] = "ime:english";

}  // namespace
class FloatingAccessibilityControllerTest : public AshTestBase {
 public:
  void SetUp() override {
    AshTestBase::SetUp();
    // Ensure 2 Ime's are available so we show the ime switch button.
    SetTwoAvailableImes();
  }

  AccessibilityController* accessibility_controller() {
    return Shell::Get()->accessibility_controller();
  }

  FloatingAccessibilityController* controller() {
    return accessibility_controller()->GetFloatingMenuController();
  }

  bool IsFloatingMenuVisible() { return controller() != nullptr; }

  FloatingMenuPosition menu_position() { return controller()->position_; }

  FloatingAccessibilityView* menu_view() {
    return controller() ? controller()->menu_view_.get() : nullptr;
  }

  views::Widget* widget() {
    return controller() ? controller()->bubble_widget_.get() : nullptr;
  }

  AutoclickMenuView* autoclick_menu_view() {
    AutoclickMenuBubbleController* controller =
        Shell::Get()
            ->autoclick_controller()
            ->GetMenuBubbleControllerForTesting();
    return controller ? controller->menu_view_.get() : nullptr;
  }

  bool detailed_view_shown() {
    return controller() && controller()->detailed_menu_controller_.get();
  }

  void WaitUntilAccessibilityTrayClosed() {
    // Waiting until accessibility tray is closed
    // after being notified from the observer.
    base::RunLoop run_loop;
    while (detailed_view_shown()) {
      run_loop.RunUntilIdle();
    }
  }

  views::View* GetMenuButton(FloatingAccessibilityView::ButtonId button_id) {
    FloatingAccessibilityView* view = menu_view();
    if (!view) {
      return nullptr;
    }
    return view->GetViewByID(static_cast<int>(button_id));
  }

  bool IsButtonVisible(FloatingAccessibilityView::ButtonId button_id) {
    views::View* button = GetMenuButton(button_id);
    return button != nullptr && button->layer()->opacity() > 0;
  }

  ImeMenuTray* GetImeTray() {
    ImeMenuTray* result = menu_view() ? menu_view()->ime_button() : nullptr;
    EXPECT_NE(result, nullptr) << "Ime tray is not currently visible";
    return result;
  }

  TrayBackgroundView* GetVirtualKeyboardTray() {
    TrayBackgroundView* result =
        menu_view() ? menu_view()->virtual_keyboard_button() : nullptr;
    EXPECT_NE(result, nullptr)
        << "Virtual keyboard tray is not currently visible";
    return result;
  }

  // Returns true if the IME menu bubble has been shown.
  bool IsImeTrayShown() { return GetImeTray()->GetBubbleView() != nullptr; }

  void SetUpKioskSession() {
    SessionInfo info;
    info.is_running_in_app_mode = true;
    Shell::Get()->session_controller()->SetSessionInfo(info);
  }

  gfx::Rect GetMenuViewBounds() {
    FloatingAccessibilityView* view = menu_view();
    return view ? view->GetBoundsInScreen()
                : gfx::Rect(-kMenuViewBoundsBuffer, -kMenuViewBoundsBuffer);
  }

  gfx::Rect GetDetailedMenuBounds() {
    FloatingAccessibilityDetailedController* detailed_controller =
        controller() ? controller()->detailed_menu_controller_.get() : nullptr;
    return detailed_controller
               ? detailed_controller->detailed_view_->GetBoundsInScreen()
               : gfx::Rect(-kMenuViewBoundsBuffer, -kMenuViewBoundsBuffer);
  }

  gfx::Rect GetAutoclickMenuBounds() {
    return autoclick_menu_view()
               ? autoclick_menu_view()->GetBoundsInScreen()
               : gfx::Rect(-kMenuViewBoundsBuffer, -kMenuViewBoundsBuffer);
  }

  float GetMenuOpacity() {
    return controller()->bubble_view()->layer()->opacity();
  }

  void Show() { accessibility_controller()->ShowFloatingMenuIfEnabled(); }

  void SetUpVisibleMenu() {
    SetUpKioskSession();
    accessibility_controller()->floating_menu().SetEnabled(true);
    accessibility_controller()->ShowFloatingMenuIfEnabled();
  }

  void SetOnLayoutCallback(base::RepeatingClosure closure) {
    controller()->on_layout_change_ = std::move(closure);
  }

  void SetCurrentAndAvailableImes(const std::string& current_ime_id,
                                  const std::vector<ImeInfo>& available_imes) {
    Shell::Get()->ime_controller()->RefreshIme(current_ime_id, available_imes,
                                               std::vector<ImeMenuItem>());
  }

  void ClickOnAccessibilityTrayButton() {
    views::View* button =
        GetMenuButton(FloatingAccessibilityView::ButtonId::kSettingsList);
    GestureTapOn(button);
  }

  void ClickOnImeTrayButton() { GestureTapOn(GetImeTray()); }

  void EnableAndClickOnVirtualKeyboardTrayButton() {
    accessibility_controller()->virtual_keyboard().SetEnabled(true);
    GestureTapOn(
        GetMenuButton(FloatingAccessibilityView::ButtonId::kVirtualKeyboard));
  }

  // Setup one language
  void SetSingleAvailableIme() {
    ImeInfo ime_english;
    ime_english.id = ImeEnglishId;
    ime_english.name = u"English";
    ime_english.short_name = u"US";

    SetCurrentAndAvailableImes(ImeEnglishId, /*available_imes=*/{ime_english});
  }

  // Should have at least two languages to show the button
  void SetTwoAvailableImes() {
    ImeInfo ime_english;
    ime_english.id = ImeEnglishId;
    ime_english.name = u"English";
    ime_english.short_name = u"US";

    ImeInfo ime_pinyin;
    ime_pinyin.id = "ime:pinyin";
    ime_pinyin.name = u"Pinyin";
    ime_pinyin.short_name = u"拼";

    SetCurrentAndAvailableImes(ImeEnglishId,
                               /*available_imes=*/{ime_english, ime_pinyin});
  }

  std::u16string GetAccessibleNameForBubble() {
    return controller()->GetAccessibleNameForBubble();
  }
};

TEST_F(FloatingAccessibilityControllerTest, ImeButtonShownWhenEnabled) {
  SetUpVisibleMenu();

  EXPECT_TRUE(IsButtonVisible(FloatingAccessibilityView::ButtonId::kIme));
}

TEST_F(FloatingAccessibilityControllerTest, ImeButtonHiddenWhenSingleLanguage) {
  SetSingleAvailableIme();
  SetUpVisibleMenu();

  EXPECT_FALSE(IsButtonVisible(FloatingAccessibilityView::ButtonId::kIme));
}

TEST_F(FloatingAccessibilityControllerTest, KioskImeTrayVisibility) {
  SetUpVisibleMenu();

  // Tray bubble is visible when  a user taps on the IME icon.
  GestureTapOn(GetImeTray());
  EXPECT_TRUE(IsImeTrayShown());

  // Tray bubble is invisible when the user clicks on the IME icon again.
  GestureTapOn(GetImeTray());
  EXPECT_FALSE(IsImeTrayShown());
}

TEST_F(FloatingAccessibilityControllerTest, KioskImeTrayBottomButtons) {
  SetUpVisibleMenu();
  EXPECT_FALSE(GetImeTray()->AnyBottomButtonShownForTest());
}

TEST_F(FloatingAccessibilityControllerTest,
       ImeTrayNotOverlapWithFloatingBubble) {
  SetUpVisibleMenu();

  // Tray bubble is visible when  a user taps on the IME icon.
  GestureTapOn(GetImeTray());

  auto* ime_tray = GetImeTray()->GetBubbleView();
  ASSERT_TRUE(ime_tray);

  // The IME tray should not overlap with the floating accessibility bubble.
  EXPECT_FALSE(controller()->bubble_view()->GetBoundsInScreen().Intersects(
      ime_tray->GetBoundsInScreen()));
}

TEST_F(FloatingAccessibilityControllerTest, MenuIsNotShownWhenNotEnabled) {
  accessibility_controller()->ShowFloatingMenuIfEnabled();
  EXPECT_FALSE(IsFloatingMenuVisible());
}

TEST_F(FloatingAccessibilityControllerTest,
       ImeTrayClosedWhenAccessibilityTrayIsShown) {
  SetUpVisibleMenu();

  ClickOnImeTrayButton();
  ASSERT_TRUE(IsImeTrayShown());

  ClickOnAccessibilityTrayButton();
  ASSERT_TRUE(detailed_view_shown());

  EXPECT_FALSE(IsImeTrayShown());
}

TEST_F(FloatingAccessibilityControllerTest,
       AccessibilityTrayClosedWhenImeTrayIsShown) {
  SetUpVisibleMenu();

  ClickOnAccessibilityTrayButton();
  ASSERT_TRUE(detailed_view_shown());

  ClickOnImeTrayButton();
  ASSERT_TRUE(IsImeTrayShown());

  EXPECT_FALSE(detailed_view_shown());
}

TEST_F(FloatingAccessibilityControllerTest, ShowingMenu) {
  SetUpKioskSession();
  accessibility_controller()->floating_menu().SetEnabled(true);
  accessibility_controller()->ShowFloatingMenuIfEnabled();

  EXPECT_TRUE(IsFloatingMenuVisible());
  EXPECT_EQ(menu_position(),
            accessibility_controller()->GetFloatingMenuPosition());
}

TEST_F(FloatingAccessibilityControllerTest, ShowingMenuAfterPrefUpdate) {
  SetUpKioskSession();

  // If we try to show the floating menu before it is enabled, nothing happens.
  accessibility_controller()->ShowFloatingMenuIfEnabled();
  EXPECT_FALSE(IsFloatingMenuVisible());

  // As soon as we enable the floating menu, it will show the floating menu
  // because we tried to show it earlier.
  accessibility_controller()->floating_menu().SetEnabled(true);
  EXPECT_TRUE(IsFloatingMenuVisible());

  // Disable the floating menu, which should cause it to be hidden.
  accessibility_controller()->floating_menu().SetEnabled(false);
  EXPECT_FALSE(IsFloatingMenuVisible());

  // Enabling it again will show the menu since we already tried to show
  // it earlier. As soon as it we request it to be shown at least once, it
  // should show/hide on enabled state change.
  accessibility_controller()->floating_menu().SetEnabled(true);
  EXPECT_TRUE(IsFloatingMenuVisible());
}

TEST_F(FloatingAccessibilityControllerTest,
       AccessibilityTrayClosedWhenVirtualKeyboardTrayIsShown) {
  SetUpVisibleMenu();

  ClickOnAccessibilityTrayButton();
  EXPECT_TRUE(detailed_view_shown());

  EnableAndClickOnVirtualKeyboardTrayButton();
  EXPECT_TRUE(GetVirtualKeyboardTray()->is_active());

  WaitUntilAccessibilityTrayClosed();

  EXPECT_FALSE(detailed_view_shown());
}

TEST_F(FloatingAccessibilityControllerTest, CanChangePosition) {
  SetUpVisibleMenu();

  accessibility_controller()->SetFloatingMenuPosition(
      FloatingMenuPosition::kTopRight);

  // Get the full root window bounds to test the position.
  gfx::Rect window_bounds = Shell::GetPrimaryRootWindow()->bounds();

  // Test cases rotate clockwise.
  const struct {
    gfx::Point expected_location;
    FloatingMenuPosition expected_position;
  } kTestCases[] = {
      {gfx::Point(window_bounds.width(), window_bounds.height()),
       FloatingMenuPosition::kBottomRight},
      {gfx::Point(0, window_bounds.height()),
       FloatingMenuPosition::kBottomLeft},
      {gfx::Point(0, 0), FloatingMenuPosition::kTopLeft},
      {gfx::Point(window_bounds.width(), 0), FloatingMenuPosition::kTopRight},
  };

  // Find the autoclick menu position button.
  views::View* button =
      GetMenuButton(FloatingAccessibilityView::ButtonId::kPosition);
  ASSERT_TRUE(button) << "No position button found.";

  // Loop through all positions twice.
  for (int i = 0; i < 2; i++) {
    for (const auto& test : kTestCases) {
      SCOPED_TRACE(base::StringPrintf(
          "Testing position #[%d]", static_cast<int>(test.expected_position)));
      // Tap the position button.
      GestureTapOn(button);

      // Pref change happened.
      EXPECT_EQ(test.expected_position, menu_position());

      // Menu is in generally the correct screen location.
      EXPECT_LT(
          GetMenuViewBounds().ManhattanDistanceToPoint(test.expected_location),
          kMenuViewBoundsBuffer);
    }
  }
}

TEST_F(FloatingAccessibilityControllerTest, DetailedViewToggle) {
  SetUpVisibleMenu();

  // Find the autoclick menu position button.
  views::View* button =
      GetMenuButton(FloatingAccessibilityView::ButtonId::kSettingsList);
  ASSERT_TRUE(button) << "No accessibility features list button found.";
  EXPECT_FALSE(detailed_view_shown());

  GestureTapOn(button);
  EXPECT_TRUE(detailed_view_shown());

  GestureTapOn(button);
  EXPECT_FALSE(detailed_view_shown());
}

TEST_F(FloatingAccessibilityControllerTest, LocaleChangeObserver) {
  SetUpVisibleMenu();
  gfx::Rect window_bounds = Shell::GetPrimaryRootWindow()->bounds();

  // RTL should position the menu on the bottom left.
  base::i18n::SetICUDefaultLocale("he");
  // Trigger the LocaleChangeObserver, which should cause a layout of the menu.
  ash::LocaleUpdateController::Get()->ConfirmLocaleChange("en", "en", "he",
                                                          base::DoNothing());
  EXPECT_TRUE(base::i18n::IsRTL());
  EXPECT_LT(
      GetMenuViewBounds().ManhattanDistanceToPoint(window_bounds.bottom_left()),
      kMenuViewBoundsBuffer);

  // LTR should position the menu on the bottom right.
  base::i18n::SetICUDefaultLocale("en");
  ash::LocaleUpdateController::Get()->ConfirmLocaleChange("he", "he", "en",
                                                          base::DoNothing());
  EXPECT_FALSE(base::i18n::IsRTL());
  EXPECT_LT(GetMenuViewBounds().ManhattanDistanceToPoint(
                window_bounds.bottom_right()),
            kMenuViewBoundsBuffer);
}

TEST_F(FloatingAccessibilityControllerTest,
       LocaleChangeObserverWithNoNotification) {
  SetUpVisibleMenu();
  gfx::Rect window_bounds = Shell::GetPrimaryRootWindow()->bounds();

  // RTL should position the menu on the bottom left.
  base::i18n::SetICUDefaultLocale("he");
  // Trigger the LocaleChangeObserver, which should cause a layout of the menu.
  ash::LocaleUpdateController::Get()->OnLocaleChanged();
  EXPECT_TRUE(base::i18n::IsRTL());
  EXPECT_LT(
      GetMenuViewBounds().ManhattanDistanceToPoint(window_bounds.bottom_left()),
      kMenuViewBoundsBuffer);

  // LTR should position the menu on the bottom right.
  base::i18n::SetICUDefaultLocale("en");
  ash::LocaleUpdateController::Get()->OnLocaleChanged();
  EXPECT_FALSE(base::i18n::IsRTL());
  EXPECT_LT(GetMenuViewBounds().ManhattanDistanceToPoint(
                window_bounds.bottom_right()),
            kMenuViewBoundsBuffer);
}

// The detailed view has to be anchored to the floating menu.
TEST_F(FloatingAccessibilityControllerTest, DetailedViewPosition) {
  SetUpVisibleMenu();

  ClickOnAccessibilityTrayButton();

  const struct {
    bool is_RTL;
  } kTestCases[] = {{true}, {false}};
  for (auto& test : kTestCases) {
    SCOPED_TRACE(base::StringPrintf("Testing rtl=#[%d]", test.is_RTL));
    // These positions should be relative to the corners of the screen
    // whether we are in RTL or LTR.
    base::i18n::SetRTLForTesting(test.is_RTL);

    // When the menu is in the top right, the detailed should be directly
    // under it and along the right side of the screen.
    controller()->SetMenuPosition(FloatingMenuPosition::kTopRight);
    EXPECT_LT(GetDetailedMenuBounds().ManhattanDistanceToPoint(
                  GetMenuViewBounds().bottom_center()),
              kMenuViewBoundsBuffer);
    EXPECT_EQ(GetDetailedMenuBounds().right(), GetMenuViewBounds().right());

    // When the menu is in the bottom right, the detailed view is directly above
    // it and along the right side of the screen.
    controller()->SetMenuPosition(FloatingMenuPosition::kBottomRight);
    EXPECT_LT(GetDetailedMenuBounds().ManhattanDistanceToPoint(
                  GetMenuViewBounds().top_center()),
              kMenuViewBoundsBuffer);
    EXPECT_EQ(GetDetailedMenuBounds().right(), GetMenuViewBounds().right());

    // When the menu is on the bottom left, the detailed view is directly above
    // it and along the left side of the screen.
    controller()->SetMenuPosition(FloatingMenuPosition::kBottomLeft);
    EXPECT_LT(GetDetailedMenuBounds().ManhattanDistanceToPoint(
                  GetMenuViewBounds().top_center()),
              kMenuViewBoundsBuffer);
    EXPECT_EQ(GetDetailedMenuBounds().x(), GetMenuViewBounds().x());

    // When the menu is on the top left, the detailed view is directly below it
    // and along the left side of the screen.
    controller()->SetMenuPosition(FloatingMenuPosition::kTopLeft);
    EXPECT_LT(GetDetailedMenuBounds().ManhattanDistanceToPoint(
                  GetMenuViewBounds().bottom_center()),
              kMenuViewBoundsBuffer);
    EXPECT_EQ(GetDetailedMenuBounds().x(), GetMenuViewBounds().x());
  }
}

TEST_F(FloatingAccessibilityControllerTest, CollisionWithAutoclicksMenu) {
  // We expect floating accessibility menu not to move when there is autoclick
  // menu present, but to push it to avoid collision. This test is exactly the
  // same as CanChangePosition, but the autoclicks are enabled.
  SetUpVisibleMenu();
  accessibility_controller()->SetFloatingMenuPosition(
      FloatingMenuPosition::kTopRight);

  accessibility_controller()->autoclick().SetEnabled(true);

  // Get the full root window bounds to test the position.
  gfx::Rect window_bounds = Shell::GetPrimaryRootWindow()->bounds();

  // Test cases rotate clockwise.
  const struct {
    gfx::Point expected_location;
    FloatingMenuPosition expected_position;
  } kTestCases[] = {
      {gfx::Point(window_bounds.right(), window_bounds.bottom()),
       FloatingMenuPosition::kBottomRight},
      {gfx::Point(0, window_bounds.bottom()),
       FloatingMenuPosition::kBottomLeft},
      {gfx::Point(0, 0), FloatingMenuPosition::kTopLeft},
      {gfx::Point(window_bounds.right(), 0), FloatingMenuPosition::kTopRight},
  };

  // Find the autoclick menu position button.
  views::View* button =
      GetMenuButton(FloatingAccessibilityView::ButtonId::kPosition);
  ASSERT_TRUE(button) << "No position button found.";

  // Loop through all positions twice.
  for (int i = 0; i < 2; i++) {
    for (const auto& test : kTestCases) {
      SCOPED_TRACE(base::StringPrintf(
          "Testing position #[%d]", static_cast<int>(test.expected_position)));
      // Tap the position button.
      GestureTapOn(button);

      // Pref change happened.
      EXPECT_EQ(test.expected_position, menu_position());

      // Rotate around the autoclicks menu.
      for (int j = 0; j < 4; j++) {
        // The position button on autoclicks view.

        GestureTapOn(autoclick_menu_view()->GetViewByID(
            static_cast<int>(AutoclickMenuView::ButtonId::kPosition)));

        // Menu is in generally the correct screen location.
        EXPECT_LT(GetMenuViewBounds().ManhattanDistanceToPoint(
                      test.expected_location),
                  kMenuViewBoundsBuffer);
        EXPECT_FALSE(GetMenuViewBounds().Intersects(GetAutoclickMenuBounds()));
      }
    }
  }
}

TEST_F(FloatingAccessibilityControllerTest, ActiveFeaturesButtons) {
  SetUpVisibleMenu();

  struct FeatureWithButton {
    FloatingAccessibilityView::ButtonId button_id;
    A11yFeatureType feature_type;
  } kFeatureButtons[] = {{FloatingAccessibilityView::ButtonId::kDictation,
                          A11yFeatureType::kDictation},
                         {FloatingAccessibilityView::ButtonId::kSelectToSpeak,
                          A11yFeatureType::kSelectToSpeak},
                         {FloatingAccessibilityView::ButtonId::kVirtualKeyboard,
                          A11yFeatureType::kVirtualKeyboard}};

  gfx::Rect original_bounds = GetMenuViewBounds();

  for (FeatureWithButton feature : kFeatureButtons) {
    SCOPED_TRACE(
        base::StringPrintf("Testing single feature with button id=#[%d]",
                           static_cast<int>(feature.button_id)));
    views::View* feature_button = GetMenuButton(feature.button_id);
    EXPECT_TRUE(feature_button);

    // The button should not be visible when dication is not enabled.
    EXPECT_FALSE(feature_button->GetVisible());

    // Wait for relayout.
    base::RunLoop loop_enable;
    SetOnLayoutCallback(loop_enable.QuitClosure());
    accessibility_controller()
        ->GetFeature(feature.feature_type)
        .SetEnabled(true);
    loop_enable.Run();

    EXPECT_TRUE(feature_button->GetVisible());
    // Get the full root window bounds to test the position.
    gfx::Rect window_bounds = Shell::GetPrimaryRootWindow()->bounds();
    // The menu should change its size and fit on the screen.
    EXPECT_TRUE(window_bounds.Contains(GetMenuViewBounds()));

    // After disabling dictation, menu should have the same size as it had
    // before.
    base::RunLoop loop_disable;
    SetOnLayoutCallback(loop_disable.QuitClosure());
    accessibility_controller()
        ->GetFeature(feature.feature_type)
        .SetEnabled(false);
    EXPECT_EQ(GetMenuViewBounds(), original_bounds);

    SetOnLayoutCallback(base::RepeatingClosure());
  }

  {
    base::RunLoop loop_enable;
    SetOnLayoutCallback(base::BarrierClosure(std::size(kFeatureButtons),
                                             loop_enable.QuitClosure()));
    // Enable all features.
    for (FeatureWithButton feature : kFeatureButtons) {
      accessibility_controller()
          ->GetFeature(feature.feature_type)
          .SetEnabled(true);
    }
    loop_enable.Run();
  }
  gfx::Rect window_bounds = Shell::GetPrimaryRootWindow()->bounds();
  // The menu should change its size and fit on the screen.
  EXPECT_TRUE(window_bounds.Contains(GetMenuViewBounds()));
  {
    base::RunLoop loop_disable;
    SetOnLayoutCallback(base::BarrierClosure(std::size(kFeatureButtons),
                                             loop_disable.QuitClosure()));
    // Enable all features.
    // Dicable all features.
    for (FeatureWithButton feature : kFeatureButtons) {
      accessibility_controller()
          ->GetFeature(feature.feature_type)
          .SetEnabled(false);
    }
    loop_disable.Run();
  }
  EXPECT_EQ(GetMenuViewBounds(), original_bounds);
}

TEST_F(FloatingAccessibilityControllerTest, AcceleratorFocusMenuImeDisabled) {
  // The IME menu is not shown for a single language.
  SetSingleAvailableIme();
  SetUpVisibleMenu();

  ASSERT_TRUE(widget());
  views::FocusManager* focus_manager = widget()->GetFocusManager();

  Shell::Get()->accelerator_controller()->PerformActionIfEnabled(
      AcceleratorAction::kFocusShelf, {});
  // If nothing else is enabled, it should focus on the detailed view button.
  EXPECT_EQ(focus_manager->GetFocusedView(),
            GetMenuButton(FloatingAccessibilityView::ButtonId::kSettingsList));

  // Focus should be reset if advanced through the menu.
  focus_manager->AdvanceFocus(false /* reverse */);
  EXPECT_NE(focus_manager->GetFocusedView(),
            GetMenuButton(FloatingAccessibilityView::ButtonId::kSettingsList));

  Shell::Get()->accelerator_controller()->PerformActionIfEnabled(
      AcceleratorAction::kFocusShelf, {});
  // It should get back to the settings list button.
  EXPECT_EQ(focus_manager->GetFocusedView(),
            GetMenuButton(FloatingAccessibilityView::ButtonId::kSettingsList));

  // Now, enable virtual keyboard and spoken feedback.
  accessibility_controller()->virtual_keyboard().SetEnabled(true);
  accessibility_controller()->select_to_speak().SetEnabled(true);

  // We should be focused on the first button in the menu.
  // Order: select to speak, virtual keyboard, settings menu, position.
  Shell::Get()->accelerator_controller()->PerformActionIfEnabled(
      AcceleratorAction::kFocusShelf, {});
  EXPECT_EQ(focus_manager->GetFocusedView(),
            GetMenuButton(FloatingAccessibilityView::ButtonId::kSelectToSpeak));
}

TEST_F(FloatingAccessibilityControllerTest, ShowingAlreadyEnabledFeatures) {
  accessibility_controller()->select_to_speak().SetEnabled(true);
  accessibility_controller()->dictation().SetEnabled(true);
  accessibility_controller()->virtual_keyboard().SetEnabled(true);
  SetUpVisibleMenu();

  EXPECT_TRUE(GetMenuButton(FloatingAccessibilityView::ButtonId::kSelectToSpeak)
                  ->GetVisible());
  EXPECT_TRUE(GetMenuButton(FloatingAccessibilityView::ButtonId::kDictation)
                  ->GetVisible());
  EXPECT_TRUE(
      GetMenuButton(FloatingAccessibilityView::ButtonId::kVirtualKeyboard)
          ->GetVisible());
}

TEST_F(FloatingAccessibilityControllerTest,
       MenuPositionChangedOnDisplayUpdate) {
  SetUpKioskSession();
  accessibility_controller()->floating_menu().SetEnabled(true);
  accessibility_controller()->ShowFloatingMenuIfEnabled();
  EXPECT_TRUE(IsFloatingMenuVisible());

  auto old_location = GetMenuViewBounds();
  UpdateDisplay("1300x800");

  gfx::Rect window_bounds = Shell::GetPrimaryRootWindow()->bounds();
  gfx::Point expected_location =
      gfx::Point(window_bounds.right(), window_bounds.bottom());
  EXPECT_NE(old_location, GetMenuViewBounds());

  EXPECT_LT(GetMenuViewBounds().ManhattanDistanceToPoint(expected_location),
            kMenuViewBoundsBuffer);
}

TEST_F(FloatingAccessibilityControllerTest,
       OnDisplayUpdateDoesNotChangeMenuVisibility) {
  SetUpKioskSession();
  accessibility_controller()->floating_menu().SetEnabled(true);
  EXPECT_FALSE(IsFloatingMenuVisible());

  UpdateDisplay("1300x800");

  EXPECT_FALSE(IsFloatingMenuVisible());
}

TEST_F(FloatingAccessibilityControllerTest, DictationButtonFocus) {
  accessibility_controller()->dictation().SetEnabled(true);
  SetSingleAvailableIme();
  SetUpVisibleMenu();

  EXPECT_TRUE(IsFloatingMenuVisible());

  ASSERT_TRUE(widget());
  views::FocusManager* focus_manager = widget()->GetFocusManager();

  views::View* settings_button =
      GetMenuButton(FloatingAccessibilityView::ButtonId::kSettingsList);
  ASSERT_TRUE(settings_button) << "No settings list button found.";
  EXPECT_TRUE(settings_button->GetVisible());

  views::View* dictation_button =
      GetMenuButton(FloatingAccessibilityView::ButtonId::kDictation);
  ASSERT_TRUE(dictation_button) << "No dictation button found.";
  EXPECT_TRUE(dictation_button->GetVisible());

  // The floating menu stays inactive during touches/clicks.
  // Dictation button click shouldn't take the focus.
  GestureTapOn(dictation_button);
  EXPECT_EQ(focus_manager->GetFocusedView(), nullptr);

  // The floating menu should activate for a 'focus on shelf' keyboard shortcut
  // and take the focus.
  // Dictation button is visible but disabled when we are not in text input.
  dictation_button->SetEnabled(false);
  Shell::Get()->accelerator_controller()->PerformActionIfEnabled(
      AcceleratorAction::kFocusShelf, {});
  EXPECT_EQ(focus_manager->GetFocusedView(), settings_button);
}

TEST_F(FloatingAccessibilityControllerTest,
       FloatingAccessibilityBubbleViewAccessibleProperties) {
  SetUpVisibleMenu();
  auto* bubble_view_ = controller()->bubble_view();
  ui::AXNodeData data;

  bubble_view_->GetViewAccessibility().GetAccessibleNodeData(&data);
  EXPECT_EQ(data.role, ax::mojom::Role::kWindow);
  // FloatingAccessibilityController::Show sets the
  // FloatingAccessibleBubbleView's CanActivate() to false, so we expect the
  // accessible name to be empty.
  EXPECT_EQ(data.GetString16Attribute(ax::mojom::StringAttribute::kName),
            std::u16string());
  EXPECT_EQ(data.GetNameFrom(), ax::mojom::NameFrom::kAttributeExplicitlyEmpty);
}

TEST_F(FloatingAccessibilityControllerTest, CheckOpacity) {
  SetUpVisibleMenu();
  EXPECT_LT(GetMenuOpacity(), 1.0f);

  controller()->FocusOnMenu();
  EXPECT_EQ(GetMenuOpacity(), 1.0f);
}

}  // namespace ash