// 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_device_metrics_handler.h"

#include "base/metrics/histogram_functions.h"
#include "chromeos/ash/components/audio/audio_device_encoding.h"
#include "chromeos/ash/components/audio/cras_audio_handler.h"

namespace ash {

namespace {

// The time threshold whether user override system decision metrics would be
// fired or not. This is the time delta since the system decision was triggered.
constexpr int kUserOverrideSystemDecisionTimeThresholdInMinutes = 60;

}  // namespace

AudioDeviceMetricsHandler::AudioDeviceMetricsHandler() = default;
AudioDeviceMetricsHandler::~AudioDeviceMetricsHandler() = default;

void AudioDeviceMetricsHandler::MaybeRecordSystemSwitchDecisionAndContext(
    bool is_input,
    bool has_alternative_device,
    bool is_switched,
    const AudioDeviceMap& audio_devices_,
    const AudioDeviceMap& previous_audio_devices_) {
  if (is_input) {
    AudioDeviceList input_devices =
        CrasAudioHandler::GetSimpleUsageAudioDevices(audio_devices_,
                                                     /*is_input=*/true);

    // Do not record if there is only one audio device since it will definitely
    // be activated. The metric aims to measure how well the system selection
    // works when there are more than one available devices.
    if (!has_alternative_device || input_devices.size() <= 1) {
      // Reset timestamp since no interested system selection decision is made
      // and to prevent previous system decision from being used to record the
      // user override.
      ResetSystemSwitchTimestamp(is_input);
      return;
    }

    uint32_t input_devices_bits = EncodeAudioDeviceSet(input_devices);
    AudioDeviceList previous_input_devices =
        CrasAudioHandler::GetSimpleUsageAudioDevices(previous_audio_devices_,
                                                     /*is_input=*/true);
    uint32_t previous_input_devices_bits =
        EncodeAudioDeviceSet(previous_input_devices);

    // Do not record system decision metrics since the device set doesn't
    // change. No interested system selection decision in this case. This could
    // happen when cras lost the active device, or cras fires extra node change
    // signal.
    if (input_devices_bits == previous_input_devices_bits) {
      // Reset timestamp since no interested system selection decision is made
      // and to prevent previous system decision from being used to record the
      // user override.
      ResetSystemSwitchTimestamp(is_input);
      return;
    }

    base::UmaHistogramBoolean(kSystemSwitchInputAudio, is_switched);
    base::UmaHistogramEnumeration(
        kAudioSelectionPerformance,
        is_switched ? AudioSelectionEvents::kSystemSwitchInput
                    : AudioSelectionEvents::kSystemNotSwitchInput);

    // Record the number of audio devices at the moment.
    base::UmaHistogramExactLinear(is_switched
                                      ? kSystemSwitchInputAudioDeviceCount
                                      : kSystemNotSwitchInputAudioDeviceCount,
                                  input_devices.size(), kMaxAudioDevicesCount);

    // Record the encoded device set.
    base::UmaHistogramSparse(is_switched ? kSystemSwitchInputAudioDeviceSet
                                         : kSystemNotSwitchInputAudioDeviceSet,
                             input_devices_bits);

    // Record the before and after encoded device sets.
    uint32_t before_and_after_input_device_set_bits =
        EncodeBeforeAndAfterAudioDeviceSets(previous_input_devices,
                                            input_devices);
    base::UmaHistogramSparse(
        is_switched ? kSystemSwitchInputBeforeAndAfterAudioDeviceSet
                    : kSystemNotSwitchInputBeforeAndAfterAudioDeviceSet,
        before_and_after_input_device_set_bits);

    // Record chrome restarts related metrics.
    RecordAudioSelectionMetricsSeparatedByChromeRestarts(
        /*is_input=*/true, is_switched, is_chrome_restarts_,
        /*previous_device_list=*/previous_input_devices,
        /*current_device_list=*/input_devices);

    // Set up timestamp. Make sure setting one timestamp will reset the other,
    // since only one decision can be made either switching or not switching.
    input_switched_by_system_at_ =
        is_switched ? std::make_optional(base::TimeTicks::Now()) : std::nullopt;
    input_not_switched_by_system_at_ =
        is_switched ? std::nullopt : std::make_optional(base::TimeTicks::Now());
    is_system_decision_at_chrome_restarts_ = is_chrome_restarts_;
    before_and_after_input_device_set_bits_ =
        before_and_after_input_device_set_bits;
  } else {
    AudioDeviceList output_devices =
        CrasAudioHandler::GetSimpleUsageAudioDevices(audio_devices_,
                                                     /*is_input=*/false);

    // Do not record if there is only one audio device. Same as above.
    if (!has_alternative_device || output_devices.size() <= 1) {
      // Reset timestamp. Same as above.
      ResetSystemSwitchTimestamp(is_input);
      return;
    }

    uint32_t output_devices_bits = EncodeAudioDeviceSet(output_devices);
    AudioDeviceList previous_output_devices =
        CrasAudioHandler::GetSimpleUsageAudioDevices(previous_audio_devices_,
                                                     /*is_input=*/false);
    uint32_t previous_output_devices_bits =
        EncodeAudioDeviceSet(previous_output_devices);

    // Do not record system decision metrics since the device set doesn't
    // change. No interested system selection decision in this case. This could
    // happen when cras lost the active device, or cras fires extra node change
    // signal.
    if (output_devices_bits == previous_output_devices_bits) {
      // Reset timestamp since no interested system selection decision is made
      // and to prevent previous system decision from being used to record the
      // user override.
      ResetSystemSwitchTimestamp(is_input);
      return;
    }

    base::UmaHistogramBoolean(kSystemSwitchOutputAudio, is_switched);
    base::UmaHistogramEnumeration(
        kAudioSelectionPerformance,
        is_switched ? AudioSelectionEvents::kSystemSwitchOutput
                    : AudioSelectionEvents::kSystemNotSwitchOutput);

    // Record the number of audio devices at the moment.
    base::UmaHistogramExactLinear(is_switched
                                      ? kSystemSwitchOutputAudioDeviceCount
                                      : kSystemNotSwitchOutputAudioDeviceCount,
                                  output_devices.size(), kMaxAudioDevicesCount);

    // Record the encoded device set.
    base::UmaHistogramSparse(is_switched ? kSystemSwitchOutputAudioDeviceSet
                                         : kSystemNotSwitchOutputAudioDeviceSet,
                             output_devices_bits);

    // Record the before and after encoded device sets.
    uint32_t before_and_after_output_device_set_bits =
        EncodeBeforeAndAfterAudioDeviceSets(previous_output_devices,
                                            output_devices);
    base::UmaHistogramSparse(
        is_switched ? kSystemSwitchOutputBeforeAndAfterAudioDeviceSet
                    : kSystemNotSwitchOutputBeforeAndAfterAudioDeviceSet,
        before_and_after_output_device_set_bits);

    // Record chrome restarts related metrics.
    RecordAudioSelectionMetricsSeparatedByChromeRestarts(
        /*is_input=*/false, is_switched, is_chrome_restarts_,
        /*previous_device_list=*/previous_output_devices,
        /*current_device_list=*/output_devices);

    // Set up timestamp. Make sure setting one timestamp will reset the other,
    // same as above.
    output_switched_by_system_at_ =
        is_switched ? std::make_optional(base::TimeTicks::Now()) : std::nullopt;
    output_not_switched_by_system_at_ =
        is_switched ? std::nullopt : std::make_optional(base::TimeTicks::Now());
    is_system_decision_at_chrome_restarts_ = is_chrome_restarts_;
    before_and_after_output_device_set_bits_ =
        before_and_after_output_device_set_bits;
  }
}

void AudioDeviceMetricsHandler::ResetSystemSwitchTimestamp(bool is_input) {
  if (is_input) {
    input_switched_by_system_at_ = std::nullopt;
    input_not_switched_by_system_at_ = std::nullopt;
  } else {
    output_switched_by_system_at_ = std::nullopt;
    output_not_switched_by_system_at_ = std::nullopt;
  }
}

void AudioDeviceMetricsHandler::RecordUserSwitchAudioDevice(bool is_input) {
  if (is_input) {
    base::RecordAction(base::UserMetricsAction(kUserActionSwitchInput));
    if (!input_device_selected_by_user_) {
      base::RecordAction(
          base::UserMetricsAction(kUserActionSwitchInputOverridden));
    }

    MaybeRecordUserOverrideSystemDecision(
        is_input, is_system_decision_at_chrome_restarts_,
        input_switched_by_system_at_, input_not_switched_by_system_at_);
  } else {
    base::RecordAction(base::UserMetricsAction(kUserActionSwitchOutput));
    if (!output_device_selected_by_user_) {
      base::RecordAction(
          base::UserMetricsAction(kUserActionSwitchOutputOverridden));
    }

    MaybeRecordUserOverrideSystemDecision(
        is_input, is_system_decision_at_chrome_restarts_,
        output_switched_by_system_at_, output_not_switched_by_system_at_);
  }
}

void AudioDeviceMetricsHandler::MaybeRecordUserOverrideSystemDecision(
    bool is_input,
    bool is_system_decision_at_chrome_restarts,
    std::optional<base::TimeTicks>& switched_by_system_at,
    std::optional<base::TimeTicks>& not_switched_by_system_at) {
  if (switched_by_system_at.has_value()) {
    // There should be only one decision made by system, either switching or not
    // switching the audio device.
    CHECK(!not_switched_by_system_at.has_value());

    const std::string& histogram_name_switched =
        is_input ? kUserOverrideSystemSwitchInputAudio
                 : kUserOverrideSystemSwitchOutputAudio;
    int time_delta_since_system_decision =
        (base::TimeTicks::Now() - switched_by_system_at.value()).InMinutes();
    AudioSelectionEvents audio_selection_event =
        is_input ? AudioSelectionEvents::kUserOverrideSystemSwitchInput
                 : AudioSelectionEvents::kUserOverrideSystemSwitchOutput;
    RecordUserOverrideMetricsHelper(histogram_name_switched,
                                    audio_selection_event,
                                    time_delta_since_system_decision);

    // Record user override metrics separated by chrome restarts.
    RecordUserOverrideMetricsSeparatedByChromeRestarts(
        is_input, /*is_switched=*/true,
        /*is_chrome_restarts=*/is_system_decision_at_chrome_restarts,
        time_delta_since_system_decision);

    // Record the before and after encoded device sets.
    base::UmaHistogramSparse(
        is_input ? kUserOverrideSystemSwitchInputBeforeAndAfterAudioDeviceSet
                 : kUserOverrideSystemSwitchOutputBeforeAndAfterAudioDeviceSet,
        is_input ? before_and_after_input_device_set_bits_
                 : before_and_after_output_device_set_bits_);

    // Reset the system_switch timestamp since user has activated an audio
    // device now. User activating again is not considered overriding system
    // decision, thus not recorded.
    switched_by_system_at = std::nullopt;
  } else if (not_switched_by_system_at.has_value()) {
    // There should be only one decision made by system, same as above.
    CHECK(!switched_by_system_at.has_value());

    const std::string& histogram_name_not_switched =
        is_input ? kUserOverrideSystemNotSwitchInputAudio
                 : kUserOverrideSystemNotSwitchOutputAudio;
    int time_delta_since_system_decision =
        (base::TimeTicks::Now() - not_switched_by_system_at.value())
            .InMinutes();
    AudioSelectionEvents audio_selection_event =
        is_input ? AudioSelectionEvents::kUserOverrideSystemNotSwitchInput
                 : AudioSelectionEvents::kUserOverrideSystemNotSwitchOutput;
    RecordUserOverrideMetricsHelper(histogram_name_not_switched,
                                    audio_selection_event,
                                    time_delta_since_system_decision);

    // Record user override metrics separated by chrome restarts.
    RecordUserOverrideMetricsSeparatedByChromeRestarts(
        is_input, /*is_switched=*/false,
        /*is_chrome_restarts=*/is_system_decision_at_chrome_restarts,
        time_delta_since_system_decision);

    // Record the before and after encoded device sets.
    base::UmaHistogramSparse(
        is_input
            ? kUserOverrideSystemNotSwitchInputBeforeAndAfterAudioDeviceSet
            : kUserOverrideSystemNotSwitchOutputBeforeAndAfterAudioDeviceSet,
        is_input ? before_and_after_input_device_set_bits_
                 : before_and_after_output_device_set_bits_);

    // Reset the system_not_switch timestamp since user has activated an audio
    // device now.
    not_switched_by_system_at = std::nullopt;
  }
}

void AudioDeviceMetricsHandler::
    RecordAudioSelectionMetricsSeparatedByChromeRestarts(
        bool is_input,
        bool is_switched,
        bool is_chrome_restarts,
        const AudioDeviceList& previous_device_list,
        const AudioDeviceList& current_device_list) const {
  std::string system_switch_histogram_name;
  std::string device_count_histogram_name;
  std::string device_set_histogram_name;
  std::string before_and_after_device_set_histogram_name;
  AudioSelectionEvents audio_selection_event;

  if (is_chrome_restarts) {
    system_switch_histogram_name = is_input
                                       ? kSystemSwitchInputAudioChromeRestarts
                                       : kSystemSwitchOutputAudioChromeRestarts;

    if (is_switched) {
      audio_selection_event =
          is_input ? AudioSelectionEvents::kSystemSwitchInputChromeRestart
                   : AudioSelectionEvents::kSystemSwitchOutputChromeRestart;

      device_count_histogram_name =
          is_input ? kSystemSwitchInputAudioDeviceCountChromeRestarts
                   : kSystemSwitchOutputAudioDeviceCountChromeRestarts;
      device_set_histogram_name =
          is_input ? kSystemSwitchInputAudioDeviceSetChromeRestarts
                   : kSystemSwitchOutputAudioDeviceSetChromeRestarts;
      before_and_after_device_set_histogram_name =
          is_input
              ? kSystemSwitchInputBeforeAndAfterAudioDeviceSetChromeRestarts
              : kSystemSwitchOutputBeforeAndAfterAudioDeviceSetChromeRestarts;
    } else {
      audio_selection_event =
          is_input ? AudioSelectionEvents::kSystemNotSwitchInputChromeRestart
                   : AudioSelectionEvents::kSystemNotSwitchOutputChromeRestart;
      device_count_histogram_name =
          is_input ? kSystemNotSwitchInputAudioDeviceCountChromeRestarts
                   : kSystemNotSwitchOutputAudioDeviceCountChromeRestarts;
      device_set_histogram_name =
          is_input ? kSystemNotSwitchInputAudioDeviceSetChromeRestarts
                   : kSystemNotSwitchOutputAudioDeviceSetChromeRestarts;
      before_and_after_device_set_histogram_name =
          is_input
              ? kSystemNotSwitchInputBeforeAndAfterAudioDeviceSetChromeRestarts
              : kSystemNotSwitchOutputBeforeAndAfterAudioDeviceSetChromeRestarts;
    }
  } else {
    system_switch_histogram_name =
        is_input ? kSystemSwitchInputAudioNonChromeRestarts
                 : kSystemSwitchOutputAudioNonChromeRestarts;

    if (is_switched) {
      audio_selection_event =
          is_input ? AudioSelectionEvents::kSystemSwitchInputNonChromeRestart
                   : AudioSelectionEvents::kSystemSwitchOutputNonChromeRestart;
      device_count_histogram_name =
          is_input ? kSystemSwitchInputAudioDeviceCountNonChromeRestarts
                   : kSystemSwitchOutputAudioDeviceCountNonChromeRestarts;
      device_set_histogram_name =
          is_input ? kSystemSwitchInputAudioDeviceSetNonChromeRestarts
                   : kSystemSwitchOutputAudioDeviceSetNonChromeRestarts;
      before_and_after_device_set_histogram_name =
          is_input
              ? kSystemSwitchInputBeforeAndAfterAudioDeviceSetNonChromeRestarts
              : kSystemSwitchOutputBeforeAndAfterAudioDeviceSetNonChromeRestarts;
    } else {
      audio_selection_event =
          is_input
              ? AudioSelectionEvents::kSystemNotSwitchInputNonChromeRestart
              : AudioSelectionEvents::kSystemNotSwitchOutputNonChromeRestart;
      device_count_histogram_name =
          is_input ? kSystemNotSwitchInputAudioDeviceCountNonChromeRestarts
                   : kSystemNotSwitchOutputAudioDeviceCountNonChromeRestarts;
      device_set_histogram_name =
          is_input ? kSystemNotSwitchInputAudioDeviceSetNonChromeRestarts
                   : kSystemNotSwitchOutputAudioDeviceSetNonChromeRestarts;
      before_and_after_device_set_histogram_name =
          is_input
              ? kSystemNotSwitchInputBeforeAndAfterAudioDeviceSetNonChromeRestarts
              : kSystemNotSwitchOutputBeforeAndAfterAudioDeviceSetNonChromeRestarts;
    }
  }

  // Record the system switch decision.
  base::UmaHistogramBoolean(system_switch_histogram_name, is_switched);

  base::UmaHistogramEnumeration(kAudioSelectionPerformance,
                                audio_selection_event);

  // Record the number of audio devices.
  base::UmaHistogramExactLinear(device_count_histogram_name,
                                current_device_list.size(),
                                kMaxAudioDevicesCount);

  // Record the encoded device set.
  base::UmaHistogramSparse(device_set_histogram_name,
                           EncodeAudioDeviceSet(current_device_list));

  // Record the before and after encoded device sets.
  base::UmaHistogramSparse(before_and_after_device_set_histogram_name,
                           EncodeBeforeAndAfterAudioDeviceSets(
                               previous_device_list, current_device_list));
}

void AudioDeviceMetricsHandler::RecordUserOverrideMetricsHelper(
    std::string_view histogram_name,
    AudioSelectionEvents audio_selection_event,
    int time_delta_since_system_decision) const {
  base::UmaHistogramCustomCounts(
      histogram_name.data(), time_delta_since_system_decision,
      kMinTimeInMinuteOfUserOverrideSystemDecision,
      base::Hours(kMaxTimeInHourOfUserOverrideSystemDecision).InMinutes(),
      kUserOverrideSystemDecisionTimeDeltaBucketCount);

  // The user override system decision metrics are only recorded within a time
  // threshold of system making the decision. This is because the metrics aim to
  // measure how well the system makes the decision. The shorter the user
  // overrides the system decision, the more likely that the system didn't make
  // a good decision. Current threshold is a reasonable value picked based on
  // the existing metrics (UserOverrideSystemSwitchTimeElapsed).
  if (time_delta_since_system_decision <=
      kUserOverrideSystemDecisionTimeThresholdInMinutes) {
    base::UmaHistogramEnumeration(kAudioSelectionPerformance,
                                  audio_selection_event);
  }
}

void AudioDeviceMetricsHandler::
    RecordUserOverrideMetricsSeparatedByChromeRestarts(
        bool is_input,
        bool is_switched,
        bool is_chrome_restarts,
        int time_delta_since_system_decision) const {
  std::string user_override_histogram_name;
  AudioSelectionEvents audio_selection_event;
  if (is_chrome_restarts) {
    if (is_switched) {
      user_override_histogram_name =
          is_input ? kUserOverrideSystemSwitchInputAudioChromeRestarts
                   : kUserOverrideSystemSwitchOutputAudioChromeRestarts;
      audio_selection_event =
          is_input ? AudioSelectionEvents::
                         kUserOverrideSystemSwitchInputChromeRestart
                   : AudioSelectionEvents::
                         kUserOverrideSystemSwitchOutputChromeRestart;
    } else {
      user_override_histogram_name =
          is_input ? kUserOverrideSystemNotSwitchInputAudioChromeRestarts
                   : kUserOverrideSystemNotSwitchOutputAudioChromeRestarts;

      audio_selection_event =
          is_input ? AudioSelectionEvents::
                         kUserOverrideSystemNotSwitchInputChromeRestart
                   : AudioSelectionEvents::
                         kUserOverrideSystemNotSwitchOutputChromeRestart;
    }
  } else {
    if (is_switched) {
      user_override_histogram_name =
          is_input ? kUserOverrideSystemSwitchInputAudioNonChromeRestarts
                   : kUserOverrideSystemSwitchOutputAudioNonChromeRestarts;
      audio_selection_event =
          is_input ? AudioSelectionEvents::
                         kUserOverrideSystemSwitchInputNonChromeRestart
                   : AudioSelectionEvents::
                         kUserOverrideSystemSwitchOutputNonChromeRestart;
    } else {
      user_override_histogram_name =
          is_input ? kUserOverrideSystemNotSwitchInputAudioNonChromeRestarts
                   : kUserOverrideSystemNotSwitchOutputAudioNonChromeRestarts;
      audio_selection_event =
          is_input ? AudioSelectionEvents::
                         kUserOverrideSystemNotSwitchInputNonChromeRestart
                   : AudioSelectionEvents::
                         kUserOverrideSystemNotSwitchOutputNonChromeRestart;
    }
  }

  RecordUserOverrideMetricsHelper(user_override_histogram_name,
                                  audio_selection_event,
                                  time_delta_since_system_decision);
}

void AudioDeviceMetricsHandler::RecordConsecutiveAudioDevicsChangeTimeElapsed(
    bool is_input,
    bool is_device_added) {
  base::TimeTicks now = base::TimeTicks::Now();
  std::optional<base::TimeTicks>& devices_changed_at =
      is_input ? input_devices_changed_at_ : output_devices_changed_at_;
  if (devices_changed_at.has_value()) {
    int time_delta_since_system_decision =
        (now - devices_changed_at.value()).InSeconds();
    base::UmaHistogramSparse(is_input ? kConsecutiveInputDevicsChanged
                                      : kConsecutiveOutputDevicsChanged,
                             time_delta_since_system_decision);
  }
  devices_changed_at = now;

  if (is_device_added) {
    std::optional<base::TimeTicks>& devices_added_at =
        is_input ? input_devices_added_at_ : output_devices_added_at_;
    if (devices_added_at.has_value()) {
      int time_delta_since_system_decision =
          (now - devices_added_at.value()).InSeconds();
      base::UmaHistogramSparse(is_input ? kConsecutiveInputDevicsAdded
                                        : kConsecutiveOutputDevicsAdded,
                               time_delta_since_system_decision);
    }
    devices_added_at = now;
  }
}

void AudioDeviceMetricsHandler::RecordExceptionRulesMet(
    AudioSelectionExceptionRules rule) {
  base::UmaHistogramEnumeration(kAudioSelectionExceptionRuleMetrics, rule);
}

void AudioDeviceMetricsHandler::RecordNotificationEvents(
    AudioSelectionNotificationEvents notification_event) {
  base::UmaHistogramEnumeration(kAudioSelectionNotification,
                                notification_event);
}

}  // namespace ash