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

#include "chromeos/ash/components/audio/audio_selection_notification_handler.h"

#include <cstring>
#include <optional>

#include "ash/strings/grit/ash_strings.h"
#include "base/functional/bind.h"
#include "base/notreached.h"
#include "base/strings/string_split.h"
#include "base/strings/utf_string_conversions.h"
#include "chromeos/ash/components/audio/audio_device.h"
#include "chromeos/ash/components/audio/cras_audio_handler.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/message_center/message_center.h"
#include "ui/message_center/public/cpp/notification.h"
#include "ui/message_center/public/cpp/notification_delegate.h"
#include "ui/message_center/vector_icons.h"

namespace ash {

namespace {

// Separator used to split the audio device name.
constexpr char kAudioDeviceNameSeparator[] = ":";

// Extracts the audio device source name of an audio device. e.g. the source
// name for "Razer USB Sound Card: USB Audio:2,0: Mic" would be "Razer USB Sound
// Card". The source name for "Airpods" would be "Airpods".
std::string ExtractDeviceSourceName(const AudioDevice& device) {
  std::vector<std::string> parts =
      base::SplitString(device.display_name, kAudioDeviceNameSeparator,
                        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
  return parts.front();
}

// Checks if a given device is in a device list
bool IsDeviceInList(const AudioDevice& target_device,
                    const AudioDeviceList& device_list) {
  for (const AudioDevice& device : device_list) {
    if (target_device.stable_device_id == device.stable_device_id) {
      return true;
    }
  }
  return false;
}

}  // namespace

AudioSelectionNotificationHandler::AudioSelectionNotificationHandler() =
    default;
AudioSelectionNotificationHandler::~AudioSelectionNotificationHandler() =
    default;

AudioSelectionNotificationHandler::NotificationTemplate::NotificationTemplate(
    NotificationType type,
    std::optional<std::string> input_device_name,
    std::optional<std::string> output_device_name)
    : type(type),
      input_device_name(input_device_name),
      output_device_name(output_device_name) {}

AudioSelectionNotificationHandler::NotificationTemplate::
    ~NotificationTemplate() = default;

bool AudioSelectionNotificationHandler::AudioNodesBelongToSameSource(
    const AudioDevice& input_device,
    const AudioDevice& output_device) {
  CHECK(input_device.is_input);
  CHECK(!output_device.is_input);

  // Handle internal audio device.
  if ((input_device.type == AudioDeviceType::kInternalMic ||
       input_device.type == AudioDeviceType::kFrontMic ||
       input_device.type == AudioDeviceType::kRearMic) &&
      output_device.type == AudioDeviceType::kInternalSpeaker) {
    return true;
  }

  // Handle special cases where input and output device are the same source but
  // different device types. kMic and kHeadphone are the types for 3.5mm jack
  // headphone's input and output. Similarly, kBluetoothNbMic and kBluetooth are
  // the types for a bluetooth device.
  if ((input_device.type == AudioDeviceType::kMic &&
       output_device.type == AudioDeviceType::kHeadphone) ||
      (input_device.type == AudioDeviceType::kBluetoothNbMic &&
       output_device.type == AudioDeviceType::kBluetooth)) {
    return true;
  }

  // For other devices, different device types indicate different device
  // sources.
  if (input_device.type != output_device.type) {
    return false;
  }

  // With same device type, checks their device source name.
  return ExtractDeviceSourceName(input_device)
             .compare(ExtractDeviceSourceName(output_device)) == 0;
}

void AudioSelectionNotificationHandler::ShowAudioSelectionNotification(
    const AudioDeviceList& hotplug_input_devices,
    const AudioDeviceList& hotplug_output_devices,
    const std::optional<std::string>& active_input_device_name,
    const std::optional<std::string>& active_output_device_name,
    SwitchToDeviceCallback switch_to_device_callback,
    OpenSettingsAudioPageCallback open_settings_audio_page_callback) {
  // At least input or output has hotplug device.
  CHECK(!hotplug_input_devices.empty() || !hotplug_output_devices.empty());

  // If show_notification callback is already in the queue, stop it and append
  // new hot plugged devices to the existing list, so that the notification can
  // handle them together. Otherwise, reset the existing hot plugged list.
  if (show_notification_debounce_timer_.IsRunning()) {
    show_notification_debounce_timer_.Stop();
    for (const AudioDevice& device : hotplug_input_devices) {
      hotplug_input_devices_.push_back(device);
    }
    for (const AudioDevice& device : hotplug_output_devices) {
      hotplug_output_devices_.push_back(device);
    }
  } else {
    hotplug_input_devices_.clear();
    hotplug_input_devices_ = hotplug_input_devices;
    hotplug_output_devices_.clear();
    hotplug_output_devices_ = hotplug_output_devices;
  }

  show_notification_debounce_timer_.Start(
      FROM_HERE, kDebounceTime,
      base::BindRepeating(&AudioSelectionNotificationHandler::ShowNotification,
                          weak_ptr_factory_.GetWeakPtr(),
                          active_input_device_name, active_output_device_name,
                          switch_to_device_callback,
                          open_settings_audio_page_callback));
}

void AudioSelectionNotificationHandler::ShowNotification(
    const std::optional<std::string>& active_input_device_name,
    const std::optional<std::string>& active_output_device_name,
    SwitchToDeviceCallback switch_to_device_callback,
    OpenSettingsAudioPageCallback open_settings_audio_page_callback) {
  AudioDeviceList devices_to_activate;
  std::u16string title_message_id;
  std::u16string body_message_id;
  std::vector<message_center::ButtonInfo> buttons_info;
  AudioDeviceMetricsHandler::AudioSelectionNotificationEvents
      notification_event;

  NotificationTemplate notification_template = GetNotificationTemplate(
      hotplug_input_devices_, hotplug_output_devices_, active_input_device_name,
      active_output_device_name);

  // Use different notification titles and messages based on notification types.
  switch (notification_template.type) {
    case NotificationType::kSingleSourceWithInputOnly:
      title_message_id =
          l10n_util::GetStringUTF16(IDS_ASH_AUDIO_SELECTION_SWITCH_INPUT_TITLE);
      body_message_id = l10n_util::GetStringFUTF16(
          IDS_ASH_AUDIO_SELECTION_SWITCH_INPUT_OR_OUTPUT_BODY,
          base::UTF8ToUTF16(hotplug_input_devices_.front().display_name));
      devices_to_activate.push_back(hotplug_input_devices_.front());
      buttons_info.emplace_back(
          l10n_util::GetStringUTF16(IDS_ASH_AUDIO_SELECTION_BUTTON_SWITCH));
      notification_event =
          AudioDeviceMetricsHandler::AudioSelectionNotificationEvents::
              kNotificationWithInputOnlyDeviceShowsUp;
      break;
    case NotificationType::kSingleSourceWithOutputOnly:
      title_message_id = l10n_util::GetStringUTF16(
          IDS_ASH_AUDIO_SELECTION_SWITCH_OUTPUT_TITLE);
      body_message_id = l10n_util::GetStringFUTF16(
          IDS_ASH_AUDIO_SELECTION_SWITCH_INPUT_OR_OUTPUT_BODY,
          base::UTF8ToUTF16(hotplug_output_devices_.front().display_name));
      devices_to_activate.push_back(hotplug_output_devices_.front());
      buttons_info.emplace_back(
          l10n_util::GetStringUTF16(IDS_ASH_AUDIO_SELECTION_BUTTON_SWITCH));
      notification_event =
          AudioDeviceMetricsHandler::AudioSelectionNotificationEvents::
              kNotificationWithOutputOnlyDeviceShowsUp;
      break;
    case NotificationType::kSingleSourceWithInputAndOutput:
      title_message_id = l10n_util::GetStringUTF16(
          IDS_ASH_AUDIO_SELECTION_SWITCH_SOURCE_TITLE);
      body_message_id = l10n_util::GetStringFUTF16(
          IDS_ASH_AUDIO_SELECTION_SWITCH_INPUT_AND_OUTPUT_BODY,
          base::UTF8ToUTF16(
              ExtractDeviceSourceName(hotplug_output_devices_.front())));
      devices_to_activate.push_back(hotplug_input_devices_.front());
      devices_to_activate.push_back(hotplug_output_devices_.front());
      buttons_info.emplace_back(
          l10n_util::GetStringUTF16(IDS_ASH_AUDIO_SELECTION_BUTTON_SWITCH));
      notification_event =
          AudioDeviceMetricsHandler::AudioSelectionNotificationEvents::
              kNotificationWithBothInputAndOutputDevicesShowsUp;
      break;
    case NotificationType::kMultipleSources:
      title_message_id = l10n_util::GetStringUTF16(
          IDS_ASH_AUDIO_SELECTION_MULTIPLE_DEVICES_TITLE);
      body_message_id =
          active_input_device_name.has_value() &&
                  active_output_device_name.has_value()
              ? l10n_util::GetStringFUTF16(
                    IDS_ASH_AUDIO_SELECTION_MULTIPLE_DEVICES_BODY,
                    base::UTF8ToUTF16(active_input_device_name.value()),
                    base::UTF8ToUTF16(active_output_device_name.value()))
              : l10n_util::GetStringUTF16(
                    IDS_ASH_AUDIO_SELECTION_MULTIPLE_DEVICES_BODY_WITH_NAME_UNAVAILABLE);
      buttons_info.emplace_back(
          l10n_util::GetStringUTF16(IDS_ASH_AUDIO_SELECTION_BUTTON_SETTINGS));
      notification_event =
          AudioDeviceMetricsHandler::AudioSelectionNotificationEvents::
              kNotificationWithMultipleSourcesDevicesShowsUp;
      break;
  }

  audio_device_metrics_handler_.RecordNotificationEvents(notification_event);

  message_center::RichNotificationData optional_fields;
  optional_fields.buttons = buttons_info;

  // If notification type is kMultipleSources, show Settings button and pass
  // HandleSettingsButtonClicked function.
  auto notification_delegate =
      notification_template.type == NotificationType::kMultipleSources
          ? base::BindRepeating(
                &AudioSelectionNotificationHandler::HandleSettingsButtonClicked,
                weak_ptr_factory_.GetWeakPtr(),
                open_settings_audio_page_callback)
          : base::BindRepeating(
                &AudioSelectionNotificationHandler::HandleSwitchButtonClicked,
                weak_ptr_factory_.GetWeakPtr(), devices_to_activate,
                switch_to_device_callback, notification_template.type);

  message_center::Notification notification{
      /*type=*/message_center::NOTIFICATION_TYPE_SIMPLE,
      /*id=*/kAudioSelectionNotificationId,
      /*title=*/title_message_id,
      /*message=*/body_message_id, ui::ImageModel(),
      /*display_source=*/
      l10n_util::GetStringUTF16(IDS_ASH_AUDIO_SELECTION_SOURCE),
      /*origin_url=*/GURL(),
      /*notifier_id=*/
      message_center::NotifierId(message_center::NotifierType::SYSTEM_COMPONENT,
                                 kAudioSelectionNotifierId,
                                 NotificationCatalogName::kAudioSelection),
      optional_fields,
      /*delegate=*/
      base::MakeRefCounted<message_center::HandleNotificationClickDelegate>(
          notification_delegate)};
  auto* message_center = message_center::MessageCenter::Get();
  message_center->RemoveNotification(notification.id(),
                                     /*by_user=*/false);
  message_center->AddNotification(
      std::make_unique<message_center::Notification>(notification));
}

void AudioSelectionNotificationHandler::HandleSwitchButtonClicked(
    const AudioDeviceList& devices_to_activate,
    SwitchToDeviceCallback switch_to_device_callback,
    NotificationType notification_type,
    std::optional<int> button_index) {
  if (!button_index.has_value()) {
    // Do not do anything when notification body is clicked. If the button is
    // clicked, the button_index will have a value.
    return;
  }

  switch (notification_type) {
    case NotificationType::kSingleSourceWithInputOnly:
      audio_device_metrics_handler_.RecordNotificationEvents(
          AudioDeviceMetricsHandler::AudioSelectionNotificationEvents::
              kNotificationWithInputOnlyDeviceClicked);
      break;
    case NotificationType::kSingleSourceWithOutputOnly:
      audio_device_metrics_handler_.RecordNotificationEvents(
          AudioDeviceMetricsHandler::AudioSelectionNotificationEvents::
              kNotificationWithOutputOnlyDeviceClicked);
      break;
    case NotificationType::kSingleSourceWithInputAndOutput:
      audio_device_metrics_handler_.RecordNotificationEvents(
          AudioDeviceMetricsHandler::AudioSelectionNotificationEvents::
              kNotificationWithBothInputAndOutputDevicesClicked);
      break;
    case NotificationType::kMultipleSources:
      // Do not record in this case. When the notification type is
      // kMultipleSources, notification with settings button should display.
      NOTREACHED();
  }

  // Activate audio devices.
  for (const AudioDevice& device : devices_to_activate) {
    switch_to_device_callback.Run(device, /*notify=*/true,
                                  DeviceActivateType::kActivateByUser);
  }

  // Remove notification and hotplug_input/output_devices_.
  auto* message_center = message_center::MessageCenter::Get();
  message_center->RemoveNotification(kAudioSelectionNotificationId,
                                     /*by_user=*/true);
  hotplug_input_devices_.clear();
  hotplug_output_devices_.clear();
}

void AudioSelectionNotificationHandler::HandleSettingsButtonClicked(
    base::RepeatingCallback<void()> open_settigns_callback,
    std::optional<int> button_index) {
  if (!button_index.has_value()) {
    // Do not do anything when notification body is clicked. If the button is
    // clicked, the button_index will have a value.
    return;
  }

  audio_device_metrics_handler_.RecordNotificationEvents(
      AudioDeviceMetricsHandler::AudioSelectionNotificationEvents::
          kNotificationWithMultipleSourcesDevicesClicked);

  // Open OS Settings audio page.
  open_settigns_callback.Run();

  // Remove notification.
  auto* message_center = message_center::MessageCenter::Get();
  message_center->RemoveNotification(kAudioSelectionNotificationId,
                                     /*by_user=*/true);
}

AudioSelectionNotificationHandler::NotificationTemplate
AudioSelectionNotificationHandler::GetNotificationTemplate(
    const AudioDeviceList& hotplug_input_devices,
    const AudioDeviceList& hotplug_output_devices,
    const std::optional<std::string>& active_input_device_name,
    const std::optional<std::string>& active_output_device_name) {
  // There must be either hotplug input devices, or hotplug output devices, or
  // both. Otherwise, this function shouldn't be called.
  CHECK(!hotplug_input_devices.empty() || !hotplug_output_devices.empty());

  // Hot plugged devices that are used to determine notification type must be
  // simple usage audio devices.
  for (const AudioDevice& device : hotplug_input_devices) {
    CHECK(device.is_for_simple_usage());
  }
  for (const AudioDevice& device : hotplug_output_devices) {
    CHECK(device.is_for_simple_usage());
  }

  // If there are more than one input devices, or more than one output devices,
  // they must come from multiple audio sources.
  if (hotplug_input_devices.size() > 1 || hotplug_output_devices.size() > 1) {
    return {
        AudioSelectionNotificationHandler::NotificationType::kMultipleSources,
        active_input_device_name, active_output_device_name};
  }

  CHECK(hotplug_input_devices.size() <= 1 &&
        hotplug_output_devices.size() <= 1);

  // If there is exactly one input and one output device, check if they belong
  // to the same source.
  if (hotplug_input_devices.size() == 1 && hotplug_output_devices.size() == 1) {
    if (AudioSelectionNotificationHandler::AudioNodesBelongToSameSource(
            hotplug_input_devices.front(), hotplug_output_devices.front())) {
      return {AudioSelectionNotificationHandler::NotificationType::
                  kSingleSourceWithInputAndOutput,
              hotplug_input_devices.front().display_name,
              hotplug_output_devices.front().display_name};
    } else {
      return {
          AudioSelectionNotificationHandler::NotificationType::kMultipleSources,
          active_input_device_name, active_output_device_name};
    }
  }

  CHECK(hotplug_input_devices.size() + hotplug_output_devices.size() == 1);

  // If there is exactly one input device and no output device, it's
  // kSingleSourceWithInputOnly notification type.
  if (hotplug_input_devices.size() == 1) {
    return {AudioSelectionNotificationHandler::NotificationType::
                kSingleSourceWithInputOnly,
            hotplug_input_devices.front().display_name, std::nullopt};
  }

  // If there is exactly one output device and no input device, it's
  // kSingleSourceWithOutputOnly notification type.
  return {AudioSelectionNotificationHandler::NotificationType::
              kSingleSourceWithOutputOnly,
          std::nullopt, hotplug_output_devices.front().display_name};
}

void AudioSelectionNotificationHandler::
    RemoveNotificationIfHotpluggedDeviceActivated(
        const AudioDeviceList& activated_devices) {
  const AudioDeviceList& hotplug_devices = activated_devices.front().is_input
                                               ? hotplug_input_devices_
                                               : hotplug_output_devices_;
  for (const AudioDevice& device : activated_devices) {
    if (IsDeviceInList(device, hotplug_devices)) {
      // Remove notification and hotplug_input/output_devices_.
      auto* message_center = message_center::MessageCenter::Get();
      message_center->RemoveNotification(kAudioSelectionNotificationId,
                                         /*by_user=*/false);

      hotplug_input_devices_.clear();
      hotplug_output_devices_.clear();
      return;
    }
  }
}

void AudioSelectionNotificationHandler::
    RemoveNotificationIfHotpluggedDeviceDisconnected(
        bool is_input,
        const AudioDeviceList& current_devices) {
  const AudioDeviceList& hotplug_devices =
      is_input ? hotplug_input_devices_ : hotplug_output_devices_;

  // If hotplugged devices that trigger the notification does not exist in
  // current devices, remove the notification.
  for (const AudioDevice& device : hotplug_devices) {
    if (!IsDeviceInList(device, current_devices)) {
      // Remove notification and hotplug_input/output_devices_.
      auto* message_center = message_center::MessageCenter::Get();
      message_center->RemoveNotification(kAudioSelectionNotificationId,
                                         /*by_user=*/false);

      hotplug_input_devices_.clear();
      hotplug_output_devices_.clear();
      return;
    }
  }
}

}  // namespace ash