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

#include "chrome/browser/media/prefs/capture_device_ranking.h"
#include "components/prefs/testing_pref_service.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace {

MATCHER(VideoCaptureDeviceInfoEq, "") {
  return std::get<0>(arg).descriptor.device_id ==
         std::get<1>(arg).descriptor.device_id;
}

MATCHER(MediaStreamDeviceInfoEq, "") {
  return std::get<0>(arg).id == std::get<1>(arg).id &&
         std::get<0>(arg).type == std::get<1>(arg).type;
}

template <typename T>
std::vector<T>::const_iterator GetIterForInfo(const std::vector<T>& infos,
                                              const T& info) {
  for (auto iter = infos.begin(); iter < infos.end(); ++iter) {
    if (media_prefs::internal::DeviceInfoToUniqueId(*iter) ==
        media_prefs::internal::DeviceInfoToUniqueId(info)) {
      return iter;
    }
  }

  return infos.end();
}

}  // namespace

class CaptureDeviceRankingTest : public testing::Test {
  void SetUp() override { media_prefs::RegisterUserPrefs(prefs_.registry()); }

 protected:
  void UpdateAudioRanking(
      const media::AudioDeviceDescription& preferred_device,
      const std::vector<media::AudioDeviceDescription>& infos) {
    media_prefs::UpdateAudioDevicePreferenceRanking(
        prefs_, GetIterForInfo(infos, preferred_device), infos);
  }

  void UpdateVideoRanking(
      const media::VideoCaptureDeviceInfo& preferred_device,
      const std::vector<media::VideoCaptureDeviceInfo>& infos) {
    media_prefs::UpdateVideoDevicePreferenceRanking(
        prefs_, GetIterForInfo(infos, preferred_device), infos);
  }

  void ExpectAudioRanking(
      std::vector<media::AudioDeviceDescription> infos,
      const std::vector<media::AudioDeviceDescription>& expected_output) {
    media_prefs::PreferenceRankAudioDeviceInfos(prefs_, infos);
    EXPECT_THAT(infos, expected_output);
  }

  void ExpectVideoRanking(
      std::vector<media::VideoCaptureDeviceInfo> infos,
      const std::vector<media::VideoCaptureDeviceInfo>& expected_output) {
    media_prefs::PreferenceRankVideoDeviceInfos(prefs_, infos);
    EXPECT_THAT(
        infos, testing::Pointwise(VideoCaptureDeviceInfoEq(), expected_output));
  }

  TestingPrefServiceSimple prefs_;
};

TEST_F(CaptureDeviceRankingTest, PreferenceRankVideoDeviceInfos) {
  const media::VideoCaptureDeviceInfo kIntegratedCamera(
      {/*display_name=*/"Integrated Camera",
       /*device_id=*/"integrated_camera"});
  const media::VideoCaptureDeviceInfo kUsbCamera({/*display_name=*/"USB Camera",
                                                  /*device_id=*/"usb_camera"});
  const media::VideoCaptureDeviceInfo kDevice3({/*display_name=*/"Device 3",
                                                /*device_id=*/"device_3"});
  const media::VideoCaptureDeviceInfo kDeviceLost(
      {/*display_name=*/"Device Lost",
       /*device_id=*/"device_lost"});
  const media::VideoCaptureDeviceInfo kDeviceExtra(
      {/*display_name=*/"Device Extra",
       /*device_id=*/"device_extra"});

  UpdateVideoRanking(
      /*preferred_device=*/kIntegratedCamera,
      /*infos=*/{kDeviceLost, kDevice3, kIntegratedCamera, kUsbCamera});

  UpdateVideoRanking(
      /*preferred_device=*/kUsbCamera,
      /*infos=*/{kDevice3, kIntegratedCamera, kUsbCamera});

  ExpectVideoRanking(
      /*infos=*/{kDevice3, kIntegratedCamera, kUsbCamera},
      /*expected_output=*/{kUsbCamera, kIntegratedCamera, kDevice3});

  // Remove USB camera and select the integrated camera. Integrated
  // should stay below USB in the ranking  because the USB camera isn't
  // present.
  UpdateVideoRanking(/*preferred_device=*/kIntegratedCamera,
                     /*infos=*/{kDevice3, kIntegratedCamera});

  ExpectVideoRanking(
      /*infos=*/{kDeviceExtra, kDevice3, kIntegratedCamera},
      /*expected_output=*/{kIntegratedCamera, kDevice3, kDeviceExtra});

  // Bring back USB camera. The USB camera should be ranked as the most
  // preferred device even without an update.
  ExpectVideoRanking(
      /*infos=*/{kDeviceExtra, kDevice3, kIntegratedCamera, kUsbCamera},
      /*expected_output=*/{kUsbCamera, kIntegratedCamera, kDevice3,
                           kDeviceExtra});
}

TEST_F(CaptureDeviceRankingTest, PreferenceRankAudioDeviceInfos) {
  const media::AudioDeviceDescription kIntegratedMic(
      {/*device_name=*/"Integrated Mic",
       /*unique_id=*/"integrated_mic",
       /*group_id=*/"integrated_group"});
  const media::AudioDeviceDescription kUsbMic({
      /*device_name=*/"USB Mic",
      /*unique_id=*/"usb_mic",
      /*group_id=*/"usb_group",
  });
  const media::AudioDeviceDescription kDefaultMic({
      /*device_name=*/"",
      /*unique_id=*/media::AudioDeviceDescription::kDefaultDeviceId,
      /*group_id=*/"default_group",
  });
  const media::AudioDeviceDescription kDevice3({/*device_name=*/"Device 3",
                                                /*unique_id=*/"device_3",
                                                /*group_id=*/"device_group"});
  const media::AudioDeviceDescription kDeviceLost(
      {/*device_name=*/"Device Lost",
       /*unique_id=*/"device_lost",
       /*group_id=*/"device_group"});
  const media::AudioDeviceDescription kDeviceExtra(
      {/*device_name=*/"Device Extra",
       /*unique_id=*/"device_extra",
       /*group_id=*/"device_group"});

  UpdateAudioRanking(
      /*preferred_device=*/kIntegratedMic,
      /*infos=*/{kDeviceLost, kDevice3, kIntegratedMic, kUsbMic});

  UpdateAudioRanking(/*preferred_device=*/kUsbMic,
                     /*infos=*/{kDevice3, kIntegratedMic, kUsbMic});

  ExpectAudioRanking(
      /*infos=*/{kDevice3, kIntegratedMic, kUsbMic},
      /*expected_output=*/{kUsbMic, kIntegratedMic, kDevice3});

  // Remove USB mic and select the integrated mic. Integrated
  // should stay below USB in the ranking  because the USB mic isn't
  // present.
  UpdateAudioRanking(/*preferred_device=*/kIntegratedMic,
                     /*infos=*/{kDevice3, kIntegratedMic});

  ExpectAudioRanking(
      /*infos=*/{kDeviceExtra, kDevice3, kIntegratedMic},
      /*expected_output=*/{kIntegratedMic, kDevice3, kDeviceExtra});

  // Bring back USB mic. The USB mic should be ranked as the most
  // preferred device even without an update.
  ExpectAudioRanking(
      /*infos=*/{kDeviceExtra, kDevice3, kIntegratedMic, kUsbMic},
      /*expected_output=*/{kUsbMic, kIntegratedMic, kDevice3, kDeviceExtra});

  // Include the default mic, which has an empty name.
  UpdateAudioRanking(/*preferred_device=*/kDefaultMic, /*infos=*/{
                         kUsbMic, kIntegratedMic, kDefaultMic, kDevice3});
  ExpectAudioRanking(
      /*infos=*/{kUsbMic, kIntegratedMic, kDefaultMic, kDevice3},
      /*expected_output=*/{kDefaultMic, kUsbMic, kIntegratedMic, kDevice3});
}

TEST_F(CaptureDeviceRankingTest, PreferenceRankDefaultAudioDevice) {
  const media::AudioDeviceDescription kIntegratedMic(
      {/*device_name=*/"Integrated Mic",
       /*unique_id=*/"integrated_mic",
       /*group_id=*/"integrated_group"});
  const media::AudioDeviceDescription kUsbMic({
      /*device_name=*/"USB Mic",
      /*unique_id=*/"usb_mic",
      /*group_id=*/"usb_group",
  });
  const media::AudioDeviceDescription kDefaultMic({
      /*device_name=*/"",
      /*unique_id=*/media::AudioDeviceDescription::kDefaultDeviceId,
      /*group_id=*/"default_group",
  });

  // Include the default mic, which has an empty name. Then expect that
  // preference ranking works correctly for the other device info types.
  UpdateAudioRanking(/*preferred_device=*/kDefaultMic,
                     /*infos=*/{kUsbMic, kIntegratedMic, kDefaultMic});
  ExpectAudioRanking(
      /*infos=*/{kUsbMic, kDefaultMic, kIntegratedMic},
      /*expected_output=*/{kDefaultMic, kUsbMic, kIntegratedMic});

  {
    const blink::WebMediaDeviceInfo kUsbDevice(
        /*device_id=*/"usb_device",
        /*label=*/"USB Device",
        /*group_id=*/"usb_group");
    const blink::WebMediaDeviceInfo kDefaultDevice(
        /*device_id=*/media::AudioDeviceDescription::kDefaultDeviceId,
        /*label=*/"Default",
        /*group_id=*/"default_group");
    std::vector infos = {kUsbDevice, kDefaultDevice};
    media_prefs::PreferenceRankAudioDeviceInfos(prefs_, infos);
    std::vector expected = {kDefaultDevice, kUsbDevice};
    EXPECT_EQ(infos, expected);
  }

  {
    const blink::MediaStreamDevice kUsbDevice(
        /*type=*/blink::mojom::MediaStreamType::DEVICE_AUDIO_CAPTURE,
        /*id=*/"usb_device",
        /*name=*/"USB Device");
    const blink::MediaStreamDevice kDefaultDevice(
        /*type=*/blink::mojom::MediaStreamType::DEVICE_AUDIO_CAPTURE,
        /*id=*/media::AudioDeviceDescription::kDefaultDeviceId,
        /*name=*/"Default");
    std::vector infos = {kUsbDevice, kDefaultDevice};
    media_prefs::PreferenceRankAudioDeviceInfos(prefs_, infos);
    std::vector expected = {kDefaultDevice, kUsbDevice};
    EXPECT_EQ(infos, expected);
  }
}

TEST_F(CaptureDeviceRankingTest, InitializeAudioDeviceInfosRanking) {
  const media::AudioDeviceDescription kIntegratedMic(
      {/*device_name=*/"Integrated Mic",
       /*unique_id=*/"integrated_mic",
       /*group_id=*/"integrated_group"});
  const media::AudioDeviceDescription kUsbMic({
      /*device_name=*/"USB Mic",
      /*unique_id=*/"usb_mic",
      /*group_id=*/"usb_group",
  });

  prefs_.registry()->RegisterStringPref(
      prefs::kDefaultAudioCaptureDeviceDeprecated, "");

  // The default device is set to "" so the output should be unmodified.
  ExpectAudioRanking({kIntegratedMic, kUsbMic}, {kIntegratedMic, kUsbMic});

  // The default device isn't in the passed device list, so the output should be
  // unmodified.
  prefs_.SetString(prefs::kDefaultAudioCaptureDeviceDeprecated, "not_found_id");
  ExpectAudioRanking({kIntegratedMic, kUsbMic}, {kIntegratedMic, kUsbMic});

  // The default device is USB mic so the device ranking gets initialized to put
  // that first.
  prefs_.SetString(prefs::kDefaultAudioCaptureDeviceDeprecated,
                   kUsbMic.unique_id);
  ExpectAudioRanking({kIntegratedMic, kUsbMic}, {kUsbMic, kIntegratedMic});

  // The device ranking pref now has a value, so use that instead of the default
  // device pref.
  UpdateAudioRanking(kIntegratedMic, {kIntegratedMic, kUsbMic});
  ExpectAudioRanking({kUsbMic, kIntegratedMic}, {kIntegratedMic, kUsbMic});
}

TEST_F(CaptureDeviceRankingTest, InitializeVideoDeviceInfosRanking) {
  const media::VideoCaptureDeviceInfo kIntegratedCamera(
      {/*display_name=*/"Integrated Camera",
       /*device_id=*/"integrated_camera"});
  const media::VideoCaptureDeviceInfo kUsbCamera({/*display_name=*/"USB Camera",
                                                  /*device_id=*/"usb_camera"});

  prefs_.registry()->RegisterStringPref(
      prefs::kDefaultVideoCaptureDeviceDeprecated, "");

  // The default device is set to "" so the output should be unmodified.
  ExpectVideoRanking({kIntegratedCamera, kUsbCamera},
                     {kIntegratedCamera, kUsbCamera});

  // The default device isn't in the passed device list, so the output should be
  // unmodified.
  prefs_.SetString(prefs::kDefaultVideoCaptureDeviceDeprecated, "not_found_id");
  ExpectVideoRanking({kIntegratedCamera, kUsbCamera},
                     {kIntegratedCamera, kUsbCamera});

  // The default device is usb camera so the device ranking gets Initialized to
  // put that first.
  prefs_.SetString(prefs::kDefaultVideoCaptureDeviceDeprecated,
                   kUsbCamera.descriptor.device_id);
  ExpectVideoRanking({kIntegratedCamera, kUsbCamera},
                     {kUsbCamera, kIntegratedCamera});

  // The device ranking pref now has a value, so use that instead of the default
  // device pref.
  UpdateVideoRanking(kIntegratedCamera, {kIntegratedCamera, kUsbCamera});
  ExpectVideoRanking({kUsbCamera, kIntegratedCamera},
                     {kIntegratedCamera, kUsbCamera});
}

class CaptureDeviceRankingWebMediaDeviceTest
    : public CaptureDeviceRankingTest,
      public testing::WithParamInterface<blink::mojom::MediaDeviceType> {
 protected:
  void UpdateDeviceRanking(
      blink::mojom::MediaDeviceType device_type,
      const blink::WebMediaDeviceInfo& preferred_device,
      const std::vector<blink::WebMediaDeviceInfo>& infos) {
    if (device_type == blink::mojom::MediaDeviceType::kMediaAudioInput) {
      media_prefs::UpdateAudioDevicePreferenceRanking(
          prefs_, GetIterForInfo(infos, preferred_device), infos);
    } else if (device_type == blink::mojom::MediaDeviceType::kMediaVideoInput) {
      media_prefs::UpdateVideoDevicePreferenceRanking(
          prefs_, GetIterForInfo(infos, preferred_device), infos);
    } else {
      FAIL() << "Called with an unsupported type: " << device_type;
    }
  }

  void ExpectDeviceRanking(
      blink::mojom::MediaDeviceType device_type,
      std::vector<blink::WebMediaDeviceInfo> infos,
      const std::vector<blink::WebMediaDeviceInfo>& expected_output) {
    if (device_type == blink::mojom::MediaDeviceType::kMediaAudioInput) {
      media_prefs::PreferenceRankAudioDeviceInfos(prefs_, infos);
      EXPECT_EQ(infos, expected_output);
    } else if (device_type == blink::mojom::MediaDeviceType::kMediaVideoInput) {
      media_prefs::PreferenceRankVideoDeviceInfos(prefs_, infos);
      EXPECT_EQ(infos, expected_output);
    } else {
      FAIL() << "Called with an unsupported type: " << device_type;
    }
  }
};

INSTANTIATE_TEST_SUITE_P(
    WebMediaDeviceAudioVideoInput,
    CaptureDeviceRankingWebMediaDeviceTest,
    ::testing::Values(blink::mojom::MediaDeviceType::kMediaAudioInput,
                      blink::mojom::MediaDeviceType::kMediaVideoInput));

TEST_P(CaptureDeviceRankingWebMediaDeviceTest, PreferenceWebMediaDeviceInfos) {
  const blink::WebMediaDeviceInfo kIntegratedDevice(
      /*device_id=*/"integrated_device",
      /*label=*/"Integrated Device",
      /*group_id=*/"integrated_group");
  const blink::WebMediaDeviceInfo kUsbDevice(
      /*device_id=*/"usb_device",
      /*label=*/"USB Device",
      /*group_id=*/"usb_group");
  const blink::WebMediaDeviceInfo kDefaultDevice(
      /*device_id=*/media::AudioDeviceDescription::kDefaultDeviceId,
      /*label=*/"Default",
      /*group_id=*/"default_group");
  const blink::WebMediaDeviceInfo kDevice3(
      /*device_id=*/"device_3",
      /*label=*/"Device 3",
      /*group_id=*/"device_group");
  const blink::WebMediaDeviceInfo kDeviceLost(
      /*device_id=*/"device_lost",
      /*label=*/"Device Lost",
      /*group_id=*/"device_group");
  const blink::WebMediaDeviceInfo kDeviceExtra(
      /*device_id=*/"device_extra",
      /*label=*/"Device Extra",
      /*group_id=*/"device_group");

  const blink::mojom::MediaDeviceType device_type = GetParam();

  UpdateDeviceRanking(
      device_type,
      /*preferred_device=*/kIntegratedDevice,
      /*infos=*/{kDeviceLost, kDevice3, kIntegratedDevice, kUsbDevice});

  UpdateDeviceRanking(device_type,
                      /*preferred_device=*/kUsbDevice,
                      /*infos=*/{kDevice3, kIntegratedDevice, kUsbDevice});

  ExpectDeviceRanking(
      device_type,
      /*infos=*/{kDevice3, kIntegratedDevice, kUsbDevice},
      /*expected_output=*/{kUsbDevice, kIntegratedDevice, kDevice3});

  // Remove USB device and select the integrated device. Integrated
  // should stay below USB in the ranking  because the USB device isn't
  // present.
  UpdateDeviceRanking(device_type,
                      /*preferred_device=*/kIntegratedDevice,
                      /*infos=*/{kDevice3, kIntegratedDevice});

  ExpectDeviceRanking(
      device_type,
      /*infos=*/{kDeviceExtra, kDevice3, kIntegratedDevice},
      /*expected_output=*/{kIntegratedDevice, kDevice3, kDeviceExtra});

  // Bring back USB device. The USB device should be ranked as the most
  // preferred device even without an update.
  ExpectDeviceRanking(
      device_type,
      /*infos=*/{kDeviceExtra, kDevice3, kIntegratedDevice, kUsbDevice},
      /*expected_output=*/
      {kUsbDevice, kIntegratedDevice, kDevice3, kDeviceExtra});

  // Include the default device.
  UpdateDeviceRanking(
      device_type, /*preferred_device=*/kDefaultDevice,
      /*infos=*/{kUsbDevice, kIntegratedDevice, kDefaultDevice, kDevice3});
  ExpectDeviceRanking(
      device_type,
      /*infos=*/{kUsbDevice, kIntegratedDevice, kDefaultDevice, kDevice3},
      /*expected_output=*/
      {kDefaultDevice, kUsbDevice, kIntegratedDevice, kDevice3});
}

class CaptureDeviceRankingMediaStreamDeviceTest
    : public CaptureDeviceRankingTest,
      public testing::WithParamInterface<blink::mojom::MediaStreamType> {
 protected:
  void UpdateDeviceRanking(blink::mojom::MediaStreamType device_type,
                           const blink::MediaStreamDevice& preferred_device,
                           const std::vector<blink::MediaStreamDevice>& infos) {
    if (device_type == blink::mojom::MediaStreamType::DEVICE_AUDIO_CAPTURE) {
      media_prefs::UpdateAudioDevicePreferenceRanking(
          prefs_, GetIterForInfo(infos, preferred_device), infos);
    } else if (device_type ==
               blink::mojom::MediaStreamType::DEVICE_VIDEO_CAPTURE) {
      media_prefs::UpdateVideoDevicePreferenceRanking(
          prefs_, GetIterForInfo(infos, preferred_device), infos);
    } else {
      FAIL() << "Called with an unsupported type: " << device_type;
    }
  }

  void ExpectDeviceRanking(
      blink::mojom::MediaStreamType device_type,
      std::vector<blink::MediaStreamDevice> infos,
      const std::vector<blink::MediaStreamDevice>& expected_output) {
    if (device_type == blink::mojom::MediaStreamType::DEVICE_AUDIO_CAPTURE) {
      media_prefs::PreferenceRankAudioDeviceInfos(prefs_, infos);
      EXPECT_THAT(infos, testing::Pointwise(MediaStreamDeviceInfoEq(),
                                            expected_output));
    } else if (device_type ==
               blink::mojom::MediaStreamType::DEVICE_VIDEO_CAPTURE) {
      media_prefs::PreferenceRankVideoDeviceInfos(prefs_, infos);
      EXPECT_THAT(infos, testing::Pointwise(MediaStreamDeviceInfoEq(),
                                            expected_output));
    } else {
      FAIL() << "Called with an unsupported type: " << device_type;
    }
  }
};

INSTANTIATE_TEST_SUITE_P(
    MediaStreamDeviceAudioVideoInput,
    CaptureDeviceRankingMediaStreamDeviceTest,
    ::testing::Values(blink::mojom::MediaStreamType::DEVICE_AUDIO_CAPTURE,
                      blink::mojom::MediaStreamType::DEVICE_VIDEO_CAPTURE));

TEST_P(CaptureDeviceRankingMediaStreamDeviceTest,
       PreferenceMediaStreamDevices) {
  const blink::mojom::MediaStreamType device_type = GetParam();

  const blink::MediaStreamDevice kIntegratedDevice(
      /*type=*/device_type,
      /*id=*/"integrated_device",
      /*name=*/"Integrated Device");
  const blink::MediaStreamDevice kUsbDevice(
      /*type=*/device_type,
      /*id=*/"usb_device",
      /*name=*/"USB Device");
  const blink::MediaStreamDevice kDefaultDevice(
      /*type=*/device_type,
      /*id=*/media::AudioDeviceDescription::kDefaultDeviceId,
      /*name=*/"Default");
  const blink::MediaStreamDevice kDevice3(
      /*type=*/device_type,
      /*id=*/"device_3",
      /*name=*/"Device 3");
  const blink::MediaStreamDevice kDeviceLost(
      /*type=*/device_type,
      /*id=*/"device_lost",
      /*name=*/"Device Lost");
  const blink::MediaStreamDevice kDeviceExtra(
      /*type=*/device_type,
      /*id=*/"device_extra",
      /*name=*/"Device Extra");

  UpdateDeviceRanking(
      device_type,
      /*preferred_device=*/kIntegratedDevice,
      /*infos=*/{kDeviceLost, kDevice3, kIntegratedDevice, kUsbDevice});

  UpdateDeviceRanking(device_type,
                      /*preferred_device=*/kUsbDevice,
                      /*infos=*/{kDevice3, kIntegratedDevice, kUsbDevice});

  ExpectDeviceRanking(
      device_type,
      /*infos=*/{kDevice3, kIntegratedDevice, kUsbDevice},
      /*expected_output=*/{kUsbDevice, kIntegratedDevice, kDevice3});

  // Remove USB device and select the integrated device. Integrated
  // should stay below USB in the ranking  because the USB device isn't
  // present.
  UpdateDeviceRanking(device_type,
                      /*preferred_device=*/kIntegratedDevice,
                      /*infos=*/{kDevice3, kIntegratedDevice});

  ExpectDeviceRanking(
      device_type,
      /*infos=*/{kDeviceExtra, kDevice3, kIntegratedDevice},
      /*expected_output=*/{kIntegratedDevice, kDevice3, kDeviceExtra});

  // Bring back USB device. The USB device should be ranked as the most
  // preferred device even without an update.
  ExpectDeviceRanking(
      device_type,
      /*infos=*/{kDeviceExtra, kDevice3, kIntegratedDevice, kUsbDevice},
      /*expected_output=*/
      {kUsbDevice, kIntegratedDevice, kDevice3, kDeviceExtra});

  // Include the default device.
  UpdateDeviceRanking(
      device_type, /*preferred_device=*/kDefaultDevice,
      /*infos=*/{kUsbDevice, kIntegratedDevice, kDefaultDevice, kDevice3});
  ExpectDeviceRanking(
      device_type,
      /*infos=*/{kUsbDevice, kIntegratedDevice, kDefaultDevice, kDevice3},
      /*expected_output=*/
      {kDefaultDevice, kUsbDevice, kIntegratedDevice, kDevice3});
}