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

#include "ash/system/camera/camera_effects_controller.h"

#include "ash/constants/ash_features.h"
#include "ash/constants/ash_pref_names.h"
#include "ash/constants/ash_switches.h"
#include "ash/session/session_controller_impl.h"
#include "ash/shell.h"
#include "ash/style/tab_slider.h"
#include "ash/style/tab_slider_button.h"
#include "ash/system/camera/autozoom_controller_impl.h"
#include "ash/system/status_area_widget.h"
#include "ash/system/status_area_widget_test_helper.h"
#include "ash/system/video_conference/bubble/bubble_view_ids.h"
#include "ash/system/video_conference/bubble/set_value_effects_view.h"
#include "ash/system/video_conference/effects/video_conference_tray_effects_manager_types.h"
#include "ash/system/video_conference/fake_video_conference_tray_controller.h"
#include "ash/system/video_conference/video_conference_tray.h"
#include "ash/system/video_conference/video_conference_tray_controller.h"
#include "ash/test/ash_test_base.h"
#include "base/command_line.h"
#include "base/containers/span.h"
#include "base/files/file_enumerator.h"
#include "base/files/file_util.h"
#include "base/files/scoped_temp_dir.h"
#include "base/memory/raw_ptr.h"
#include "base/strings/string_view_util.h"
#include "base/test/bind.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/scoped_feature_list.h"
#include "media/capture/video/chromeos/mojom/cros_camera_service.mojom-shared.h"
#include "media/capture/video/chromeos/mojom/effects_pipeline.mojom.h"
#include "third_party/skia/include/core/SkBitmap.h"
#include "ui/gfx/codec/jpeg_codec.h"

namespace ash {

using ::testing::ElementsAre;
using BackgroundImageInfo = CameraEffectsController::BackgroundImageInfo;

constexpr char kMetadataSuffix[] = ".metadata";

// Helper for converting `bitmap` into string.
std::string SkBitmapToString(const SkBitmap& bitmap) {
  std::optional<std::vector<uint8_t>> data =
      gfx::JPEGCodec::Encode(bitmap, /*quality=*/100);
  CHECK(data);
  return std::string(base::as_string_view(data.value()));
}

// Create fake Jpg image bytes.
std::string CreateJpgBytes(SkColor color) {
  SkBitmap bitmap;
  bitmap.allocN32Pixels(CameraEffectsController::kImageAsIconWidth,
                        CameraEffectsController::kImageAsIconWidth);
  bitmap.eraseColor(color);
  return SkBitmapToString(bitmap);
}

// Matcher defined to compare BackgroundImageInfo.
// We ignore the creation_time and last_accessed for now, because that were
// obtained from the filesystem, which is hard to mock for now.
auto BackgroundImageInfoMatcher(const base::FilePath& basename,
                                const std::string& jpeg_bytes,
                                const std::string& metadata) {
  return testing::AllOf(
      testing::Field("basename", &BackgroundImageInfo::basename,
                     testing::Eq(basename)),
      testing::ResultOf(
          [](BackgroundImageInfo info) {
            info.image.SetReadOnly();
            return SkBitmapToString(*info.image.bitmap());
          },
          testing::Eq(jpeg_bytes)),
      testing::Field("metadata", &BackgroundImageInfo::metadata,
                     testing::Eq(metadata)));
}

constexpr char kTestAccount[] = "testuser@gmail.com";
class CameraEffectsControllerTest : public NoSessionAshTestBase {
 public:
  // NoSessionAshTestBase:
  void SetUp() override {
    scoped_feature_list_.InitAndEnableFeature(
        features::kFeatureManagementVideoConference);

    // Instantiates a fake controller (the real one is created in
    // ChromeBrowserMainExtraPartsAsh::PreProfileInit() which is not called in
    // ash unit tests).
    controller_ = std::make_unique<FakeVideoConferenceTrayController>();

    AshTestBase::SetUp();

    camera_effects_controller_ = Shell::Get()->camera_effects_controller();

    // Enable test mode to mock the SetCameraEffects calls.
    camera_effects_controller_->bypass_set_camera_effects_for_testing(true);

    // Create fake camera_background_img_dir_ and camera_background_run_dir_.
    ASSERT_TRUE(file_tmp_dir_.CreateUniqueTempDir());
    camera_background_img_dir_ =
        file_tmp_dir_.GetPath().AppendASCII("camera_background_img_dir_");
    camera_background_run_dir_ =
        file_tmp_dir_.GetPath().AppendASCII("camera_background_run_dir_");
    ASSERT_TRUE(base::CreateDirectory(camera_background_img_dir_));
    ASSERT_TRUE(base::CreateDirectory(camera_background_run_dir_));
  }

  void TearDown() override {
    NoSessionAshTestBase::TearDown();
    controller_.reset();
  }

  // Sets background blur state.
  void SetBackgroundBlurEffectState(std::optional<int> state) {
    camera_effects_controller_->OnEffectControlActivated(
        VcEffectId::kBackgroundBlur, state);
  }

  // Gets the state of the background blur effect from the effect's host,
  // `camera_effects_controller_`.
  int GetBackgroundBlurEffectState() {
    std::optional<int> effect_state =
        camera_effects_controller_->GetEffectState(VcEffectId::kBackgroundBlur);
    DCHECK(effect_state.has_value());
    return effect_state.value();
  }

  // Retrieves the value of `prefs::kBackgroundBlur`.
  int GetBackgroundBlurPref() {
    return Shell::Get()
        ->session_controller()
        ->GetActivePrefService()
        ->GetInteger(prefs::kBackgroundBlur);
  }

  // Returns a pair of <replace-enabled, background-image-filepath>.
  std::pair<bool, std::string> GetBackgroundReplacePref() {
    const auto* prefs =
        Shell::Get()->session_controller()->GetActivePrefService();

    return {prefs->GetBoolean(prefs::kBackgroundReplace),
            prefs->GetFilePath(prefs::kBackgroundImagePath).value()};
  }

  // Simulates toggling portrait relighting effect state. Note that the `state`
  // argument doesn't matter for toggle effects.
  void TogglePortraitRelightingEffectState() {
    camera_effects_controller_->OnEffectControlActivated(
        VcEffectId::kPortraitRelighting, /*state=*/std::nullopt);
  }

  // Simulates toggling camera framing effect state. Note that the `state`
  // argument doesn't matter for toggle effects.
  void ToggleCameraFramingEffectState() {
    camera_effects_controller_->OnEffectControlActivated(
        VcEffectId::kCameraFraming, /*state=*/std::nullopt);
  }

  // Gets the state of the portrait relighting effect from the effect's host,
  // `camera_effects_controller_`.
  bool GetPortraitRelightingEffectState() {
    std::optional<int> effect_state =
        camera_effects_controller_->GetEffectState(
            VcEffectId::kPortraitRelighting);
    DCHECK(effect_state.has_value());
    return static_cast<bool>(effect_state.value());
  }

  // Retrieves the value of `prefs::kPortraitRelighting`.
  bool GetPortraitRelightingPref() {
    return Shell::Get()
        ->session_controller()
        ->GetActivePrefService()
        ->GetBoolean(prefs::kPortraitRelighting);
  }

  void SetAutozoomSupportState(bool autozoom_supported) {
    auto* autozoom_controller = Shell::Get()->autozoom_controller();

    autozoom_controller->SetAutozoomSupported(autozoom_supported);

    if (!autozoom_supported) {
      return;
    }

    // Autozoom is only supported if there's an active camera client, so we
    // simulate that here.
    autozoom_controller->OnActiveClientChange(
        cros::mojom::CameraClientType::ASH_CHROME,
        /*is_new_active_client=*/true,
        /*active_device_ids=*/{"fake_id"});
  }

  CameraEffectsController* camera_effects_controller() {
    return camera_effects_controller_;
  }

  FakeVideoConferenceTrayController* tray_controller() {
    return controller_.get();
  }

  base::FilePath GetFileInBackgroundRunDir() {
    base::FileEnumerator enumerator(camera_background_run_dir_,
                                    /*recursive=*/false,
                                    base::FileEnumerator::FILES);
    std::vector<base::FilePath> files;
    for (auto path = enumerator.Next(); !path.empty();
         path = enumerator.Next()) {
      files.push_back(enumerator.GetInfo().GetName());
    }

    // We should always see 1 file in the camera_background_run_dir_.
    CHECK_EQ(files.size(), 1u);

    return files[0];
  }

 protected:
  const SeaPenImage content1_ =
      SeaPenImage(CreateJpgBytes(SK_ColorBLACK), 12345);
  const SeaPenImage content2_ = SeaPenImage(CreateJpgBytes(SK_ColorWHITE), 888);
  const std::string metadata1_ = "metadata1_";
  const std::string metadata2_ = "metadata2_";

  const base::FilePath filename1_ = base::FilePath("12345.jpg");
  const base::FilePath filename2_ = base::FilePath("888.jpg");
  const base::FilePath metadata_filename1_ =
      filename1_.AddExtensionASCII(kMetadataSuffix);
  base::FilePath metadata_filename2_ =
      filename2_.AddExtensionASCII(kMetadataSuffix);

  base::ScopedTempDir file_tmp_dir_;
  base::FilePath camera_background_img_dir_;
  base::FilePath camera_background_run_dir_;

  raw_ptr<CameraEffectsController, DanglingUntriaged>
      camera_effects_controller_ = nullptr;

  std::unique_ptr<FakeVideoConferenceTrayController> controller_;
  base::test::ScopedFeatureList scoped_feature_list_;

  base::WeakPtrFactory<CameraEffectsControllerTest> weak_factory_{this};
};

TEST_F(CameraEffectsControllerTest, IsEffectControlAvailable) {
  {
    base::test::ScopedFeatureList scoped_feature_list;
    scoped_feature_list.InitWithFeatures(
        {}, {features::kFeatureManagementVideoConference});
    EXPECT_FALSE(camera_effects_controller()->IsEffectControlAvailable(
        cros::mojom::CameraEffect::kBackgroundBlur));
    EXPECT_FALSE(camera_effects_controller()->IsEffectControlAvailable(
        cros::mojom::CameraEffect::kPortraitRelight));
    EXPECT_FALSE(camera_effects_controller()->IsEffectControlAvailable(
        cros::mojom::CameraEffect::kBackgroundReplace));
  }

  {
    base::test::ScopedFeatureList scoped_feature_list;
    scoped_feature_list.InitWithFeatures(
        {features::kFeatureManagementVideoConference}, {});
    EXPECT_TRUE(camera_effects_controller()->IsEffectControlAvailable(
        cros::mojom::CameraEffect::kBackgroundBlur));
    EXPECT_TRUE(camera_effects_controller()->IsEffectControlAvailable(
        cros::mojom::CameraEffect::kPortraitRelight));
    EXPECT_TRUE(camera_effects_controller()->IsEffectControlAvailable(
        cros::mojom::CameraEffect::kBackgroundReplace));
  }

  {
    base::test::ScopedFeatureList scoped_feature_list;
    scoped_feature_list.InitWithFeatures(
        {features::kFeatureManagementVideoConference},
        {features::kVcPortraitRelight});
    EXPECT_TRUE(camera_effects_controller()->IsEffectControlAvailable(
        cros::mojom::CameraEffect::kBackgroundBlur));
    EXPECT_FALSE(camera_effects_controller()->IsEffectControlAvailable(
        cros::mojom::CameraEffect::kPortraitRelight));
    EXPECT_TRUE(camera_effects_controller()->IsEffectControlAvailable(
        cros::mojom::CameraEffect::kBackgroundReplace));
  }

  {
    base::test::ScopedFeatureList scoped_feature_list;
    scoped_feature_list.InitWithFeatures(
        {features::kFeatureManagementVideoConference},
        {features::kVcBackgroundReplace});
    EXPECT_TRUE(camera_effects_controller()->IsEffectControlAvailable(
        cros::mojom::CameraEffect::kBackgroundBlur));
    EXPECT_TRUE(camera_effects_controller()->IsEffectControlAvailable(
        cros::mojom::CameraEffect::kPortraitRelight));
    EXPECT_FALSE(camera_effects_controller()->IsEffectControlAvailable(
        cros::mojom::CameraEffect::kBackgroundReplace));
  }
}

TEST_F(CameraEffectsControllerTest, BackgroundBlurOnEffectControlActivated) {
  SimulateUserLogin({kTestAccount});

  // Activate the possible values of
  // `CameraEffectsController::BackgroundBlurPrefValue`, verify that the pref
  //  and internal state are all set properly.
  for (const auto state :
       {CameraEffectsController::BackgroundBlurPrefValue::kOff,
        CameraEffectsController::BackgroundBlurPrefValue::kLowest,
        CameraEffectsController::BackgroundBlurPrefValue::kLight,
        CameraEffectsController::BackgroundBlurPrefValue::kMedium,
        CameraEffectsController::BackgroundBlurPrefValue::kHeavy,
        CameraEffectsController::BackgroundBlurPrefValue::kMaximum}) {
    SetBackgroundBlurEffectState(state);
    EXPECT_EQ(GetBackgroundBlurPref(), state);
    EXPECT_EQ(GetBackgroundBlurEffectState(), state);
  }

  // Invalid background blur effect state should set the state to kOff.
  SetBackgroundBlurEffectState(100);
  EXPECT_EQ(GetBackgroundBlurPref(),
            CameraEffectsController::BackgroundBlurPrefValue::kOff);
  EXPECT_EQ(GetBackgroundBlurEffectState(),
            CameraEffectsController::BackgroundBlurPrefValue::kOff);

  // Set the background blur state to be kMaximum.
  SetBackgroundBlurEffectState(
      CameraEffectsController::BackgroundBlurPrefValue::kMaximum);
  // Setting the background blur state to null will reset the effects as
  // kOff.
  SetBackgroundBlurEffectState(std::nullopt);
  EXPECT_EQ(GetBackgroundBlurPref(),
            CameraEffectsController::BackgroundBlurPrefValue::kOff);
  EXPECT_EQ(GetBackgroundBlurEffectState(),
            CameraEffectsController::BackgroundBlurPrefValue::kOff);
}

TEST_F(CameraEffectsControllerTest,
       PortraitRelightingOnEffectControlActivated) {
  SimulateUserLogin({kTestAccount});

  // Initial state should be "off".
  EXPECT_FALSE(GetPortraitRelightingEffectState());
  EXPECT_FALSE(GetPortraitRelightingPref());

  // Activating the effect should toggle it to "true."
  TogglePortraitRelightingEffectState();
  EXPECT_TRUE(GetPortraitRelightingEffectState());
  EXPECT_TRUE(GetPortraitRelightingPref());

  // Another toggle should set it to "false."
  TogglePortraitRelightingEffectState();
  EXPECT_FALSE(GetPortraitRelightingEffectState());
  EXPECT_FALSE(GetPortraitRelightingPref());

  // And one more toggle should set it back to "true."
  TogglePortraitRelightingEffectState();
  EXPECT_TRUE(GetPortraitRelightingEffectState());
  EXPECT_TRUE(GetPortraitRelightingPref());
}

TEST_F(CameraEffectsControllerTest, PrefOnCameraEffectChanged) {
  SimulateUserLogin({kTestAccount});

  // Initial state should be "off".
  EXPECT_EQ(GetBackgroundBlurPref(),
            CameraEffectsController::BackgroundBlurPrefValue::kOff);
  EXPECT_EQ(GetBackgroundBlurEffectState(),
            CameraEffectsController::BackgroundBlurPrefValue::kOff);
  EXPECT_FALSE(GetPortraitRelightingEffectState());
  EXPECT_FALSE(GetPortraitRelightingPref());

  // Case 1: when observe effects change from `CameraHalDispatcherImp`, the pref
  // is updated.
  cros::mojom::EffectsConfigPtr new_effects = cros::mojom::EffectsConfig::New();
  new_effects->blur_enabled = true;
  new_effects->blur_level = cros::mojom::BlurLevel::kMaximum;
  new_effects->relight_enabled = true;
  camera_effects_controller_->OnCameraEffectChanged(std::move(new_effects));

  // State should be "on".
  EXPECT_EQ(GetBackgroundBlurPref(),
            CameraEffectsController::BackgroundBlurPrefValue::kMaximum);
  EXPECT_EQ(GetBackgroundBlurEffectState(),
            CameraEffectsController::BackgroundBlurPrefValue::kMaximum);
  EXPECT_TRUE(GetPortraitRelightingEffectState());
  EXPECT_TRUE(GetPortraitRelightingPref());

  // Case 2: when new effects is null, the pref is unchanged.
  new_effects = cros::mojom::EffectsConfigPtr();
  camera_effects_controller_->OnCameraEffectChanged(std::move(new_effects));

  // State should be "on".
  EXPECT_EQ(GetBackgroundBlurPref(),
            CameraEffectsController::BackgroundBlurPrefValue::kMaximum);
  EXPECT_EQ(GetBackgroundBlurEffectState(),
            CameraEffectsController::BackgroundBlurPrefValue::kMaximum);
  EXPECT_TRUE(GetPortraitRelightingEffectState());
  EXPECT_TRUE(GetPortraitRelightingPref());

  // Case 3: when observe default effects from `CameraHalDispatcherImp`, the
  // pref should be back to default.
  new_effects = cros::mojom::EffectsConfig::New();
  camera_effects_controller_->OnCameraEffectChanged(std::move(new_effects));

  // State should be "off".
  EXPECT_EQ(GetBackgroundBlurPref(),
            CameraEffectsController::BackgroundBlurPrefValue::kOff);
  EXPECT_EQ(GetBackgroundBlurEffectState(),
            CameraEffectsController::BackgroundBlurPrefValue::kOff);
  EXPECT_FALSE(GetPortraitRelightingEffectState());
  EXPECT_FALSE(GetPortraitRelightingPref());
}

TEST_F(CameraEffectsControllerTest, ResourceDependencyFlags) {
  SimulateUserLogin({kTestAccount});

  // Makes sure that all registered effects have the correct dependency flag.
  auto* background_blur =
      camera_effects_controller()->GetEffectById(VcEffectId::kBackgroundBlur);
  EXPECT_EQ(VcHostedEffect::ResourceDependency::kCamera,
            background_blur->dependency_flags());

  if (features::IsVcStudioLookEnabled()) {
    auto* studio_look =
        camera_effects_controller()->GetEffectById(VcEffectId::kStudioLook);
    EXPECT_EQ(VcHostedEffect::ResourceDependency::kCamera,
              studio_look->dependency_flags());
  } else {
    auto* portrait_relight = camera_effects_controller()->GetEffectById(
        VcEffectId::kPortraitRelighting);
    EXPECT_EQ(VcHostedEffect::ResourceDependency::kCamera,
              portrait_relight->dependency_flags());
  }
}

TEST_F(CameraEffectsControllerTest, BackgroundBlurEnums) {
  // This test makes sure that `BackgroundBlurState` and
  // `BackgroundBlurPrefValue` is in sync with each other.
  EXPECT_EQ(
      static_cast<int>(CameraEffectsController::BackgroundBlurState::kMaximum),
      CameraEffectsController::BackgroundBlurPrefValue::kMaximum + 1);
}

TEST_F(CameraEffectsControllerTest, BackgroundBlurMetricsRecord) {
  base::HistogramTester histogram_tester;

  SimulateUserLogin({kTestAccount});

  // Update media status to make the video conference tray visible.
  VideoConferenceMediaState state;
  state.has_media_app = true;
  state.has_camera_permission = true;
  state.has_microphone_permission = true;
  state.is_capturing_screen = true;
  tray_controller()->UpdateWithMediaState(state);

  auto* vc_tray = StatusAreaWidgetTestHelper::GetStatusAreaWidget()
                      ->video_conference_tray();

  // Open the vc bubble.
  LeftClickOn(vc_tray->toggle_bubble_button());

  // The set-value effects panel should have only 1 child view, and that view
  // should be the slider associated to the background blur effect.
  auto* set_value_effects_view = vc_tray->GetBubbleView()->GetViewByID(
      video_conference::BubbleViewID::kSetValueEffectsView);

  ASSERT_EQ(1u, set_value_effects_view->children().size());

  auto* background_blur_slider =
      static_cast<video_conference::SetValueEffectSlider*>(
          set_value_effects_view->children()[0]);
  EXPECT_EQ(VcEffectId::kBackgroundBlur, background_blur_slider->effect_id());

  auto* tab_slider = background_blur_slider->tab_slider();
  auto* first_button = tab_slider->GetButtonAtIndex(0);

  // At first, the first button is selected, but there should not be any metrics
  // recorded for that state since it is the default state when opening the
  // bubble.
  EXPECT_TRUE(first_button->selected());
  histogram_tester.ExpectBucketCount(
      "Ash.VideoConferenceTray.BackgroundBlur.Click",
      CameraEffectsController::BackgroundBlurState::kOff, 0);

  // Switching states by clicking slider buttons should record metrics in the
  // associated bucket.
  LeftClickOn(tab_slider->GetButtonAtIndex(1));

  histogram_tester.ExpectBucketCount(
      "Ash.VideoConferenceTray.BackgroundBlur.Click",
      CameraEffectsController::BackgroundBlurState::kLight, 1);

  LeftClickOn(tab_slider->GetButtonAtIndex(2));

  histogram_tester.ExpectBucketCount(
      "Ash.VideoConferenceTray.BackgroundBlur.Click",
      CameraEffectsController::BackgroundBlurState::kMaximum, 1);

  LeftClickOn(first_button);

  histogram_tester.ExpectBucketCount(
      "Ash.VideoConferenceTray.BackgroundBlur.Click",
      CameraEffectsController::BackgroundBlurState::kOff, 1);
}

TEST_F(CameraEffectsControllerTest, CameraFramingSupportState) {
  SimulateUserLogin({kTestAccount});

  // By default autozoom is not supported, so the effect is not added.
  EXPECT_FALSE(
      camera_effects_controller()->GetEffectById(VcEffectId::kCameraFraming));

  SetAutozoomSupportState(true);

  EXPECT_TRUE(
      camera_effects_controller()->GetEffectById(VcEffectId::kCameraFraming));

  SetAutozoomSupportState(false);

  EXPECT_FALSE(
      camera_effects_controller()->GetEffectById(VcEffectId::kCameraFraming));
}

TEST_F(CameraEffectsControllerTest, CameraFramingToggle) {
  SetAutozoomSupportState(true);

  SimulateUserLogin({kTestAccount});

  ASSERT_EQ(Shell::Get()->autozoom_controller()->GetState(),
            cros::mojom::CameraAutoFramingState::OFF);

  ToggleCameraFramingEffectState();
  EXPECT_EQ(Shell::Get()->autozoom_controller()->GetState(),
            cros::mojom::CameraAutoFramingState::ON_SINGLE);

  ToggleCameraFramingEffectState();
  EXPECT_EQ(Shell::Get()->autozoom_controller()->GetState(),
            cros::mojom::CameraAutoFramingState::OFF);
}

TEST_F(CameraEffectsControllerTest, SetBackgroundImageWithFileExists) {
  base::test::ScopedFeatureList scoped_feature_list{
      features::kVcBackgroundReplace};

  SimulateUserLogin({kTestAccount});
  camera_effects_controller()->set_camera_background_img_dir_for_testing(
      camera_background_img_dir_);
  camera_effects_controller()->set_camera_background_run_dir_for_testing(
      camera_background_run_dir_);

  // Apply background blur first.
  const auto state = CameraEffectsController::BackgroundBlurPrefValue::kLowest;
  SetBackgroundBlurEffectState(state);
  EXPECT_EQ(GetBackgroundBlurPref(), state);

  // Create fake image file.
  const std::string relative_path = "background/test.png";
  base::FilePath file_fullpath =
      camera_background_img_dir_.Append(relative_path);
  ASSERT_TRUE(base::CreateDirectory(file_fullpath.DirName()));
  ASSERT_TRUE(base::WriteFile(file_fullpath, ""));

  // Set background image.
  camera_effects_controller()->SetBackgroundImage(
      base::FilePath(relative_path),
      base::BindOnce([](bool call_succeeded) { EXPECT_TRUE(call_succeeded); }));
  task_environment()->RunUntilIdle();

  // Check background replace result from pref.
  EXPECT_THAT(GetBackgroundReplacePref(), testing::Pair(true, relative_path));

  // Check the background blur is turned off.
  EXPECT_EQ(GetBackgroundBlurPref(),
            CameraEffectsController::BackgroundBlurPrefValue::kOff);

  // Apply background blur again.
  SetBackgroundBlurEffectState(state);
  EXPECT_EQ(GetBackgroundBlurPref(), state);

  // Background replace should be turned off.
  EXPECT_THAT(GetBackgroundReplacePref(), testing::Pair(false, ""));

  // When background replace is turned off, we want the background_filepath to
  // be empty.
  EXPECT_FALSE(camera_effects_controller()
                   ->GetCameraEffects()
                   ->background_filepath.has_value());

  // Set background image again.
  camera_effects_controller()->SetBackgroundImage(
      base::FilePath(relative_path),
      base::BindOnce([](bool call_succeeded) { EXPECT_TRUE(call_succeeded); }));
  task_environment()->RunUntilIdle();

  // Check background replace result from pref.
  EXPECT_THAT(GetBackgroundReplacePref(), testing::Pair(true, relative_path));

  // Turn off backgroundblur or replace.
  const auto off_state = CameraEffectsController::BackgroundBlurPrefValue::kOff;
  SetBackgroundBlurEffectState(off_state);
  EXPECT_EQ(GetBackgroundBlurPref(), off_state);

  // Background replace should be turned off.
  EXPECT_THAT(GetBackgroundReplacePref(), testing::Pair(false, ""));
}

TEST_F(CameraEffectsControllerTest, SetBackgroundImageWithFileDoesNotExist) {
  base::test::ScopedFeatureList scoped_feature_list{
      features::kVcBackgroundReplace};

  SimulateUserLogin({kTestAccount});
  camera_effects_controller()->set_camera_background_img_dir_for_testing(
      camera_background_img_dir_);
  camera_effects_controller()->set_camera_background_run_dir_for_testing(
      camera_background_run_dir_);

  // Apply background blur first.
  const auto state = CameraEffectsController::BackgroundBlurPrefValue::kLowest;
  SetBackgroundBlurEffectState(state);
  EXPECT_EQ(GetBackgroundBlurPref(), state);

  // Set background image.
  camera_effects_controller()->SetBackgroundImage(
      filename1_, base::BindOnce([](bool call_succeeded) {
        EXPECT_FALSE(call_succeeded);
      }));
  task_environment()->RunUntilIdle();

  // Because the image is not created, the above SetBackgroundImage should fail,
  // so that the background replace pref should not be set.
  EXPECT_THAT(GetBackgroundReplacePref(), testing::Pair(false, ""));

  // Check the background blur is not changed.
  EXPECT_EQ(GetBackgroundBlurPref(), state);
}

TEST_F(CameraEffectsControllerTest, SetBackgroundImageFromContent) {
  base::test::ScopedFeatureList scoped_feature_list{
      features::kVcBackgroundReplace};

  SimulateUserLogin({kTestAccount});
  camera_effects_controller()->set_camera_background_img_dir_for_testing(
      camera_background_img_dir_);
  camera_effects_controller()->set_camera_background_run_dir_for_testing(
      camera_background_run_dir_);

  // Set background image from content1_.
  camera_effects_controller()->SetBackgroundImageFromContent(
      content1_, metadata1_,
      base::BindOnce([](bool call_succeeded) { EXPECT_TRUE(call_succeeded); }));
  task_environment()->RunUntilIdle();

  // We should see replace-enabled and the filename1_ in prefs.
  EXPECT_THAT(GetBackgroundReplacePref(),
              testing::Pair(true, filename1_.value()));

  // Check saved image info.
  camera_effects_controller()->GetRecentlyUsedBackgroundImages(
      3, base::BindLambdaForTesting(
             [&](const std::vector<BackgroundImageInfo>& info) {
               EXPECT_THAT(info,
                           ElementsAre(BackgroundImageInfoMatcher(
                               filename1_, content1_.jpg_bytes, metadata1_)));
               EXPECT_EQ(GetFileInBackgroundRunDir(), filename1_);
             }));
  task_environment()->RunUntilIdle();

  // Set background image from content2_.
  camera_effects_controller()->SetBackgroundImageFromContent(
      content2_, metadata2_,
      base::BindOnce([](bool call_succeeded) { EXPECT_TRUE(call_succeeded); }));
  task_environment()->RunUntilIdle();

  // We should see replace-enabled and the filename2_ in prefs.
  EXPECT_THAT(GetBackgroundReplacePref(),
              testing::Pair(true, filename2_.value()));

  camera_effects_controller()->GetRecentlyUsedBackgroundImages(
      3, base::BindLambdaForTesting(
             [&](const std::vector<BackgroundImageInfo>& info) {
               EXPECT_THAT(
                   info, ElementsAre(
                             BackgroundImageInfoMatcher(
                                 filename2_, content2_.jpg_bytes, metadata2_),
                             BackgroundImageInfoMatcher(
                                 filename1_, content1_.jpg_bytes, metadata1_)));
               EXPECT_EQ(GetFileInBackgroundRunDir(), filename2_);
             }));
  task_environment()->RunUntilIdle();

  // SetBackgroundImage with filename1_ should update the last activity
  // time of filename1_.
  camera_effects_controller()->SetBackgroundImage(
      filename1_,
      base::BindOnce([](bool call_succeeded) { EXPECT_TRUE(call_succeeded); }));
  task_environment()->RunUntilIdle();

  // We should see replace-enabled and the filename1_ in prefs.
  EXPECT_THAT(GetBackgroundReplacePref(),
              testing::Pair(true, filename1_.value()));

  camera_effects_controller()->GetRecentlyUsedBackgroundImages(
      3, base::BindLambdaForTesting(
             [&](const std::vector<BackgroundImageInfo>& info) {
               EXPECT_THAT(
                   info, ElementsAre(
                             BackgroundImageInfoMatcher(
                                 filename1_, content1_.jpg_bytes, metadata1_),
                             BackgroundImageInfoMatcher(
                                 filename2_, content2_.jpg_bytes, metadata2_)));
               EXPECT_EQ(GetFileInBackgroundRunDir(), filename1_);
             }));
  task_environment()->RunUntilIdle();

  // Remove filename2_.
  camera_effects_controller()->RemoveBackgroundImage(
      filename2_,
      base::BindOnce([](bool call_succeeded) { EXPECT_TRUE(call_succeeded); }));
  task_environment()->RunUntilIdle();

  // Pref should not be effect if a irrelevant image is removed.
  EXPECT_THAT(GetBackgroundReplacePref(),
              testing::Pair(true, filename1_.value()));

  camera_effects_controller()->GetRecentlyUsedBackgroundImages(
      3, base::BindLambdaForTesting(
             [&](const std::vector<BackgroundImageInfo>& info) {
               EXPECT_THAT(info,
                           ElementsAre(BackgroundImageInfoMatcher(
                               filename1_, content1_.jpg_bytes, metadata1_)));
             }));
  task_environment()->RunUntilIdle();

  // Remove filename1_.
  camera_effects_controller()->RemoveBackgroundImage(
      filename1_,
      base::BindOnce([](bool call_succeeded) { EXPECT_TRUE(call_succeeded); }));
  task_environment()->RunUntilIdle();

  // Since filename2_ is removed, we should see the background image is removed
  // from prefs.
  EXPECT_THAT(GetBackgroundReplacePref(), testing::Pair(false, ""));

  camera_effects_controller()->GetRecentlyUsedBackgroundImages(
      3, base::BindLambdaForTesting(
             [&](const std::vector<BackgroundImageInfo>& info) {
               // We should only see all files removed.
               EXPECT_TRUE(info.empty());
             }));
  task_environment()->RunUntilIdle();
}

TEST_F(CameraEffectsControllerTest, GetBackgroundImageFileNames) {
  base::test::ScopedFeatureList scoped_feature_list{
      features::kVcBackgroundReplace};

  SimulateUserLogin({kTestAccount});
  camera_effects_controller()->set_camera_background_img_dir_for_testing(
      camera_background_img_dir_);
  camera_effects_controller()->set_camera_background_run_dir_for_testing(
      camera_background_run_dir_);

  // Set background image from content1_.
  camera_effects_controller()->SetBackgroundImageFromContent(
      content1_, metadata1_,
      base::BindOnce([](bool call_succeeded) { EXPECT_TRUE(call_succeeded); }));
  task_environment()->RunUntilIdle();

  // filename1_ should be created.
  camera_effects_controller()->GetBackgroundImageFileNames(
      base::BindLambdaForTesting([&](const std::vector<base::FilePath>& files) {
        EXPECT_THAT(files, ElementsAre(filename1_));
      }));
  task_environment()->RunUntilIdle();

  // Set background image from content2_.
  camera_effects_controller()->SetBackgroundImageFromContent(
      content2_, metadata2_,
      base::BindOnce([](bool call_succeeded) { EXPECT_TRUE(call_succeeded); }));
  task_environment()->RunUntilIdle();

  // filename2_ should be created.
  camera_effects_controller()->GetBackgroundImageFileNames(
      base::BindLambdaForTesting([&](const std::vector<base::FilePath>& files) {
        EXPECT_THAT(files, ElementsAre(filename2_, filename1_));
      }));
  task_environment()->RunUntilIdle();

  // SetBackgroundImage with filename1_ should update the last activity
  // time of filename1_.
  camera_effects_controller()->SetBackgroundImage(
      filename1_,
      base::BindOnce([](bool call_succeeded) { EXPECT_TRUE(call_succeeded); }));
  task_environment()->RunUntilIdle();

  // Returned files order should be changed.
  camera_effects_controller()->GetBackgroundImageFileNames(
      base::BindLambdaForTesting([&](const std::vector<base::FilePath>& files) {
        EXPECT_THAT(files, ElementsAre(filename1_, filename2_));
      }));
  task_environment()->RunUntilIdle();

  // Remove filename1_.
  camera_effects_controller()->RemoveBackgroundImage(
      filename1_,
      base::BindOnce([](bool call_succeeded) { EXPECT_TRUE(call_succeeded); }));
  task_environment()->RunUntilIdle();

  // We should only see filename2_.
  camera_effects_controller()->GetBackgroundImageFileNames(
      base::BindLambdaForTesting([&](const std::vector<base::FilePath>& files) {
        EXPECT_THAT(files, ElementsAre(filename2_));
      }));
  task_environment()->RunUntilIdle();
}

TEST_F(CameraEffectsControllerTest, GetBackgroundImageInfo) {
  base::test::ScopedFeatureList scoped_feature_list{
      features::kVcBackgroundReplace};

  SimulateUserLogin({kTestAccount});
  camera_effects_controller()->set_camera_background_img_dir_for_testing(
      camera_background_img_dir_);
  camera_effects_controller()->set_camera_background_run_dir_for_testing(
      camera_background_run_dir_);

  // Set background image from content1_.
  camera_effects_controller()->SetBackgroundImageFromContent(
      content1_, metadata1_,
      base::BindOnce([](bool call_succeeded) { EXPECT_TRUE(call_succeeded); }));
  task_environment()->RunUntilIdle();

  // GetBackgroundImageInfo should return info about filename1_.
  camera_effects_controller()->GetBackgroundImageInfo(
      filename1_, base::BindLambdaForTesting(
                      [&](const std::optional<BackgroundImageInfo>& info) {
                        EXPECT_THAT(
                            info.value(),
                            BackgroundImageInfoMatcher(
                                filename1_, content1_.jpg_bytes, metadata1_));
                      }));
  task_environment()->RunUntilIdle();

  // Delete metadata_filename1_ will return empty metadata.
  camera_effects_controller()->RemoveBackgroundImage(
      metadata_filename1_,
      base::BindOnce([](bool call_succeeded) { EXPECT_TRUE(call_succeeded); }));
  task_environment()->RunUntilIdle();

  camera_effects_controller()->GetBackgroundImageInfo(
      filename1_, base::BindLambdaForTesting(
                      [&](const std::optional<BackgroundImageInfo>& info) {
                        EXPECT_THAT(info.value(),
                                    BackgroundImageInfoMatcher(
                                        filename1_, content1_.jpg_bytes, ""));
                      }));
  task_environment()->RunUntilIdle();

  // GetBackgroundImageInfo should return nullopt for filename2_ because the
  // file is not created.
  camera_effects_controller()->GetBackgroundImageInfo(
      filename2_,
      base::BindOnce([](const std::optional<BackgroundImageInfo>& info) {
        EXPECT_FALSE(info.has_value());
      }));
  task_environment()->RunUntilIdle();
}

TEST_F(CameraEffectsControllerTest, NotEligibleForSeaPen) {
  // Set is_eligible_for_background_replace to false so that the image button
  // will not be constructed.
  GetSessionControllerClient()->set_is_eligible_for_background_replace(
      {false, false});
  SimulateUserLogin({kTestAccount});

  // Update media status to make the video conference tray visible.
  VideoConferenceMediaState state;
  state.has_media_app = true;
  state.has_camera_permission = true;
  state.has_microphone_permission = true;
  state.is_capturing_screen = true;
  tray_controller()->UpdateWithMediaState(state);

  auto effects = VideoConferenceTrayController::Get()
                     ->GetEffectsManager()
                     .GetSetValueEffects();

  EXPECT_EQ(effects.size(), 1u);
  EXPECT_EQ(effects[0]->label_text(), u"Background");
  // Verify that only three states are constructed; the forth one is the image
  // button.
  EXPECT_EQ(effects[0]->GetNumStates(), 3);
}

TEST_F(CameraEffectsControllerTest, UpdateBackgroundBlurImageState) {
  // Set is_eligible_for_background_replace to false so that the image button
  // will not be constructed.
  GetSessionControllerClient()->set_is_eligible_for_background_replace(
      {false, false});
  SimulateUserLogin({kTestAccount});

  // Update media status to make the video conference tray visible.
  VideoConferenceMediaState state;
  state.has_media_app = true;
  state.has_camera_permission = true;
  state.has_microphone_permission = true;
  state.is_capturing_screen = true;
  tray_controller()->UpdateWithMediaState(state);

  auto effects = VideoConferenceTrayController::Get()
                     ->GetEffectsManager()
                     .GetSetValueEffects();

  EXPECT_EQ(effects.size(), 1u);
  EXPECT_EQ(effects[0]->label_text(), u"Background");
  // Verify that only three states are constructed; the forth one is the image
  // button.
  EXPECT_EQ(effects[0]->GetNumStates(), 3);

  // Set background replace eligible state to true and enterprise enabled state
  // to false so that the image button is added but disabled.
  GetSessionControllerClient()->set_is_eligible_for_background_replace(
      {true, false});
  auto* vc_tray = StatusAreaWidgetTestHelper::GetStatusAreaWidget()
                      ->video_conference_tray();

  // Open the vc bubble to notify bubble opened and update Background Blur
  // effect.
  LeftClickOn(vc_tray->toggle_bubble_button());

  effects = VideoConferenceTrayController::Get()
                ->GetEffectsManager()
                .GetSetValueEffects();

  // Now four states are constructed and the forth one is the image button.
  EXPECT_EQ(effects[0]->GetNumStates(), 4) << " four states are constructed";
  const VcEffectState* imageState = effects[0]->GetState(/*index=*/3);
  EXPECT_EQ(imageState->view_id(),
            video_conference::BubbleViewID::kBackgroundBlurImageButton);
  EXPECT_TRUE(imageState->is_disabled_by_enterprise());

  // Update VC Background enterprise enabled state to true so that the Image
  // button is enabled.
  GetSessionControllerClient()->set_is_eligible_for_background_replace(
      {true, true});
  // Close the video conference bubble.
  LeftClickOn(vc_tray->toggle_bubble_button());
  // Reopen the bubble to trigger updating Background Blur effect again.
  LeftClickOn(vc_tray->toggle_bubble_button());

  effects = VideoConferenceTrayController::Get()
                ->GetEffectsManager()
                .GetSetValueEffects();

  // The image button is now enabled.
  EXPECT_EQ(effects[0]->GetNumStates(), 4)
      << "still four states for Background Blur effect";
  const VcEffectState* newImageState = effects[0]->GetState(/*index=*/3);
  EXPECT_EQ(newImageState->view_id(),
            video_conference::BubbleViewID::kBackgroundBlurImageButton);
  EXPECT_FALSE(newImageState->is_disabled_by_enterprise());
}

}  // namespace ash