// 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 "chromeos/ash/components/network/metrics/cellular_network_metrics_logger.h"

#include "ash/constants/ash_features.h"
#include "base/metrics/histogram_functions.h"

#include "chromeos/ash/components/dbus/hermes/constants.h"
#include "chromeos/ash/components/network/metrics/connection_info_metrics_logger.h"
#include "chromeos/ash/components/network/metrics/connection_results.h"
#include "chromeos/ash/components/network/network_metadata_store.h"
#include "chromeos/ash/components/network/network_state_handler.h"
#include "chromeos/ash/components/network/text_message_suppression_state.h"
#include "components/device_event_log/device_event_log.h"
#include "components/onc/onc_constants.h"

namespace ash {
namespace {

using ApnType = chromeos::network_config::mojom::ApnType;

const base::TimeDelta kSmdsScanDurationMinimum = base::Milliseconds(1);
const base::TimeDelta kSmdsScanDurationMaximum = base::Milliseconds(
    ::ash::hermes_constants::kHermesNetworkOperationTimeoutMs);
const size_t kSmdsScanDurationBuckets = 50;

std::optional<CellularNetworkMetricsLogger::ApnTypes> GetApnTypes(
    std::vector<ApnType> apn_types) {
  if (apn_types.empty())
    return std::nullopt;

  bool is_default = false;
  bool is_attach = false;
  for (const auto& apn_type : apn_types) {
    if (apn_type == ApnType::kDefault)
      is_default = true;
    if (apn_type == ApnType::kAttach)
      is_attach = true;
  }
  if (is_default && is_attach)
    return CellularNetworkMetricsLogger::ApnTypes::kDefaultAndAttach;

  if (is_attach)
    return CellularNetworkMetricsLogger::ApnTypes::kAttach;

  return CellularNetworkMetricsLogger::ApnTypes::kDefault;
}

const char* GetESimUserInstallationResultHistogram(
    CellularNetworkMetricsLogger::ESimUserInstallMethod method,
    bool user_errors_included) {
  using ESimUserInstallMethod =
      CellularNetworkMetricsLogger::ESimUserInstallMethod;
  switch (method) {
    case ESimUserInstallMethod::kViaSmds:
      return user_errors_included
                 ? CellularNetworkMetricsLogger::
                       kESimUserInstallUserErrorsIncludedViaSmds
                 : CellularNetworkMetricsLogger::
                       kESimUserInstallUserErrorsFilteredViaSmds;
    case ESimUserInstallMethod::kViaActivationCodeAfterSmds:
      return user_errors_included
                 ? CellularNetworkMetricsLogger::
                       kESimUserInstallUserErrorsIncludedViaActivationCodeAfterSmds
                 : CellularNetworkMetricsLogger::
                       kESimUserInstallUserErrorsFilteredViaActivationCodeAfterSmds;
    case ESimUserInstallMethod::kViaActivationCodeSkippedSmds:
      return user_errors_included
                 ? CellularNetworkMetricsLogger::
                       kESimUserInstallUserErrorsIncludedViaActivationCodeSkippedSmds
                 : CellularNetworkMetricsLogger::
                       kESimUserInstallUserErrorsFilteredViaActivationCodeSkippedSmds;
    case ESimUserInstallMethod::kViaQrCodeAfterSmds:
      return user_errors_included
                 ? CellularNetworkMetricsLogger::
                       kESimUserInstallUserErrorsIncludedViaQrCodeAfterSmds
                 : CellularNetworkMetricsLogger::
                       kESimUserInstallUserErrorsFilteredViaQrCodeAfterSmds;
    case ESimUserInstallMethod::kViaQrCodeSkippedSmds:
      return user_errors_included
                 ? CellularNetworkMetricsLogger::
                       kESimUserInstallUserErrorsIncludedViaQrCodeSkippedSmds
                 : CellularNetworkMetricsLogger::
                       kESimUserInstallUserErrorsFilteredViaQrCodeSkippedSmds;
  }
}

const char* GetESimPolicyInstallationResultHistogram(
    CellularNetworkMetricsLogger::ESimPolicyInstallMethod method,
    bool is_initial,
    bool user_errors_included) {
  using ESimPolicyInstallMethod =
      CellularNetworkMetricsLogger::ESimPolicyInstallMethod;
  switch (method) {
    case ESimPolicyInstallMethod::kViaSmdp:
      if (is_initial) {
        return user_errors_included
                   ? CellularNetworkMetricsLogger::
                         kESimPolicyInstallUserErrorsIncludedViaSmdpInitial
                   : CellularNetworkMetricsLogger::
                         kESimPolicyInstallUserErrorsFilteredViaSmdpInitial;
      }
      return user_errors_included
                 ? CellularNetworkMetricsLogger::
                       kESimPolicyInstallUserErrorsIncludedViaSmdpRetry
                 : CellularNetworkMetricsLogger::
                       kESimPolicyInstallUserErrorsFilteredViaSmdpRetry;
    case ESimPolicyInstallMethod::kViaSmds:
      if (is_initial) {
        return user_errors_included
                   ? CellularNetworkMetricsLogger::
                         kESimPolicyInstallUserErrorsIncludedViaSmdsInitial
                   : CellularNetworkMetricsLogger::
                         kESimPolicyInstallUserErrorsFilteredViaSmdsInitial;
      }
      return user_errors_included
                 ? CellularNetworkMetricsLogger::
                       kESimPolicyInstallUserErrorsIncludedViaSmdsRetry
                 : CellularNetworkMetricsLogger::
                       kESimPolicyInstallUserErrorsFilteredViaSmdsRetry;
  }
}

bool IsAndroidActivationCode(const std::string& smds_activation_code) {
  return smds_activation_code == cellular_utils::kSmdsAndroidProduction ||
         smds_activation_code == cellular_utils::kSmdsAndroidStaging;
}

bool IsGmsaActivationCode(const std::string& smds_activation_code) {
  return smds_activation_code == cellular_utils::kSmdsGsma;
}

const char* GetSmdsScanResultHistogram(const std::string& smds_activation_code,
                                       bool user_errors_included) {
  if (IsAndroidActivationCode(smds_activation_code)) {
    return user_errors_included ? CellularNetworkMetricsLogger::
                                      kESimSmdsScanAndroidUserErrorsIncluded
                                : CellularNetworkMetricsLogger::
                                      kESimSmdsScanAndroidUserErrorsFiltered;
  }
  if (smds_activation_code == cellular_utils::kSmdsGsma) {
    return user_errors_included ? CellularNetworkMetricsLogger::
                                      kESimSmdsScanGsmaUserErrorsIncluded
                                : CellularNetworkMetricsLogger::
                                      kESimSmdsScanGsmaUserErrorsFiltered;
  }
  return user_errors_included ? CellularNetworkMetricsLogger::
                                    kESimSmdsScanOtherUserErrorsIncluded
                              : CellularNetworkMetricsLogger::
                                    kESimSmdsScanOtherUserErrorsFiltered;
}

}  // namespace

CellularNetworkMetricsLogger::CellularNetworkMetricsLogger(
    NetworkStateHandler* network_state_handler,
    NetworkMetadataStore* network_metadata_store,
    ConnectionInfoMetricsLogger* connection_info_metrics_logger)
    : network_state_handler_(network_state_handler),
      network_metadata_store_(network_metadata_store) {
  if (connection_info_metrics_logger) {
    connection_info_metrics_logger_observation_.Observe(
        connection_info_metrics_logger);
  }
}

CellularNetworkMetricsLogger::~CellularNetworkMetricsLogger() = default;

// static
void CellularNetworkMetricsLogger::LogCreateCustomApnResult(
    CreateCustomApnResult result,
    chromeos::network_config::mojom::ApnPropertiesPtr apn,
    const std::optional<std::string>& shill_error) {
  base::UmaHistogramEnumeration(kCreateCustomApnResultHistogram, result);

  // Only emit APN property metrics if the APN was successfully added.
  if (result != CreateCustomApnResult::kSuccess) {
    if (shill_error) {
      ShillConnectResult connect_result =
          ShillErrorToConnectResult(*shill_error);
      base::UmaHistogramEnumeration(kCreateCustomApnShillErrorHistogram,
                                    connect_result);
    }
    return;
  }

  base::UmaHistogramEnumeration(kCreateCustomApnAuthenticationTypeHistogram,
                                apn->authentication);
  base::UmaHistogramEnumeration(kCreateCustomApnIpTypeHistogram, apn->ip_type);

  std::optional<CellularNetworkMetricsLogger::ApnTypes> apn_types =
      GetApnTypes(apn->apn_types);
  if (!apn_types.has_value()) {
    NET_LOG(DEBUG) << "CreateCustomApn.ApnTypes not logged for APN because it "
                   << "doesn't have any APN types.";
    return;
  }
  base::UmaHistogramEnumeration(kCreateCustomApnApnTypesHistogram,
                                apn_types.value());
}

// static
void CellularNetworkMetricsLogger::LogCreateExclusivelyEnabledCustomApnResult(
    bool success,
    chromeos::network_config::mojom::ApnPropertiesPtr apn) {
  base::UmaHistogramBoolean(kCreateExclusivelyEnabledCustomApnResultHistogram,
                            success);

  // Only emit APN property metrics if the APN was successfully added.
  if (!success) {
    return;
  }

  base::UmaHistogramEnumeration(
      kCreateExclusivelyEnabledCustomApnAuthenticationTypeHistogram,
      apn->authentication);
  base::UmaHistogramEnumeration(
      kCreateExclusivelyEnabledCustomApnIpTypeHistogram, apn->ip_type);

  std::optional<CellularNetworkMetricsLogger::ApnTypes> apn_types =
      GetApnTypes(apn->apn_types);
  if (!apn_types.has_value()) {
    NET_LOG(DEBUG) << "CreateExclusivelyEnabledCustomApn.ApnTypes not logged "
                   << "for APN because it doesn't have any APN types.";
    return;
  }
  base::UmaHistogramEnumeration(
      kCreateExclusivelyEnabledCustomApnApnTypesHistogram, apn_types.value());
}

// static
void CellularNetworkMetricsLogger::LogRemoveCustomApnResult(
    bool success,
    std::vector<chromeos::network_config::mojom::ApnType> apn_types) {
  base::UmaHistogramBoolean(kRemoveCustomApnResultHistogram, success);

  // Only emit APN property metrics if the APN was successfully removed.
  if (!success)
    return;

  std::optional<CellularNetworkMetricsLogger::ApnTypes> apn_types_enum =
      GetApnTypes(apn_types);
  if (!apn_types_enum.has_value()) {
    NET_LOG(DEBUG) << "RemoveCustomApn.ApnTypes not logged for APN because it "
                   << "doesn't have any APN types.";
    return;
  }
  base::UmaHistogramEnumeration(kRemoveCustomApnApnTypesHistogram,
                                apn_types_enum.value());
}

// static
void CellularNetworkMetricsLogger::LogModifyCustomApnResult(
    bool success,
    std::vector<chromeos::network_config::mojom::ApnType> old_apn_types,
    std::optional<chromeos::network_config::mojom::ApnState> apn_state,
    std::optional<chromeos::network_config::mojom::ApnState> old_apn_state) {
  using ApnState = chromeos::network_config::mojom::ApnState;
  base::UmaHistogramBoolean(kModifyCustomApnResultHistogram, success);

  bool has_apn_state = old_apn_state.has_value() && apn_state.has_value();
  bool was_apn_disabled = has_apn_state &&
                          old_apn_state == ApnState::kEnabled &&
                          apn_state == ApnState::kDisabled;
  bool was_apn_enabled = has_apn_state &&
                         old_apn_state == ApnState::kDisabled &&
                         apn_state == ApnState::kEnabled;

  if (was_apn_enabled) {
    base::UmaHistogramBoolean(kEnableCustomApnResultHistogram, success);
  } else if (was_apn_disabled) {
    base::UmaHistogramBoolean(kDisableCustomApnResultHistogram, success);
  }

  // Only emit APN property metrics if the APN was successfully modified.
  if (!success) {
    return;
  }

  std::optional<CellularNetworkMetricsLogger::ApnTypes> apn_types_enum =
      GetApnTypes(old_apn_types);
  if (!apn_types_enum.has_value()) {
    NET_LOG(DEBUG) << "ApnTypes not logged for APN because it "
                   << "doesn't have any APN types.";
    return;
  }
  base::UmaHistogramEnumeration(kModifyCustomApnApnTypesHistogram,
                                apn_types_enum.value());
  if (was_apn_enabled) {
    base::UmaHistogramEnumeration(kEnableCustomApnApnTypesHistogram,
                                  apn_types_enum.value());
  } else if (was_apn_disabled) {
    base::UmaHistogramEnumeration(kDisableCustomApnApnTypesHistogram,
                                  apn_types_enum.value());
  }
}

// static
void CellularNetworkMetricsLogger::LogUnmanagedCustomApnMigrationType(
    UnmanagedApnMigrationType type) {
  base::UmaHistogramEnumeration(kCustomApnsUnmanagedMigrationTypeHistogram,
                                type);
}

// static
void CellularNetworkMetricsLogger::LogManagedCustomApnMigrationType(
    ManagedApnMigrationType type) {
  base::UmaHistogramEnumeration(kCustomApnsManagedMigrationTypeHistogram, type);
}

// static
void CellularNetworkMetricsLogger::LogSmdsScanProfileCount(
    size_t count,
    SmdsScanMethod method) {
  switch (method) {
    case SmdsScanMethod::kViaPolicy:
      base::UmaHistogramCounts100(kSmdsScanViaPolicyProfileCount, count);
      break;
    case SmdsScanMethod::kViaUser:
      base::UmaHistogramCounts100(kSmdsScanViaUserProfileCount, count);
      break;
  }
}

// static
void CellularNetworkMetricsLogger::LogSmdsScanDuration(
    const base::TimeDelta& duration,
    bool success,
    const std::string& smds_activation_code) {
  std::string histogram;
  if (IsAndroidActivationCode(smds_activation_code)) {
    histogram = success ? kSmdsScanAndroidDurationSuccess
                        : kSmdsScanAndroidDurationFailure;
  } else if (IsGmsaActivationCode(smds_activation_code)) {
    histogram =
        success ? kSmdsScanGsmaDurationSuccess : kSmdsScanGsmaDurationFailure;
  } else {
    histogram =
        success ? kSmdsScanOtherDurationSuccess : kSmdsScanOtherDurationFailure;
  }
  base::UmaHistogramCustomTimes(histogram, duration, kSmdsScanDurationMinimum,
                                kSmdsScanDurationMaximum,
                                kSmdsScanDurationBuckets);
}

// static
void CellularNetworkMetricsLogger::LogESimUserInstallMethod(
    ESimUserInstallMethod method) {
  base::UmaHistogramEnumeration(kESimUserInstallMethod, method);
}

// static
void CellularNetworkMetricsLogger::LogESimPolicyInstallMethod(
    ESimPolicyInstallMethod method) {
  base::UmaHistogramEnumeration(kESimPolicyInstallMethod, method);
}

// static
void CellularNetworkMetricsLogger::LogESimPolicyInstallNoAvailableProfiles(
    ESimPolicyInstallMethod method) {
  base::UmaHistogramEnumeration(kESimPolicyInstallNoAvailableProfiles, method);
}

// static
void CellularNetworkMetricsLogger::LogESimUserInstallResult(
    ESimUserInstallMethod method,
    ESimOperationResult result,
    bool is_user_error) {
  if (!is_user_error) {
    base::UmaHistogramEnumeration(kESimUserInstallUserErrorsFilteredAll,
                                  result);
    base::UmaHistogramEnumeration(GetESimUserInstallationResultHistogram(
                                      method, /*user_errors_included=*/false),
                                  result);
  }
  base::UmaHistogramEnumeration(kESimUserInstallUserErrorsIncludedAll, result);
  base::UmaHistogramEnumeration(GetESimUserInstallationResultHistogram(
                                    method, /*user_errors_included=*/true),
                                result);
}

// static
void CellularNetworkMetricsLogger::LogESimPolicyInstallResult(
    ESimPolicyInstallMethod method,
    ESimOperationResult result,
    bool is_initial,
    bool is_user_error) {
  if (!is_user_error) {
    base::UmaHistogramEnumeration(kESimPolicyInstallUserErrorsFilteredAll,
                                  result);
    base::UmaHistogramEnumeration(GetESimPolicyInstallationResultHistogram(
                                      method, /*is_initial=*/is_initial,
                                      /*user_errors_included=*/false),
                                  result);
  }
  base::UmaHistogramEnumeration(kESimPolicyInstallUserErrorsIncludedAll,
                                result);
  base::UmaHistogramEnumeration(
      GetESimPolicyInstallationResultHistogram(
          method, /*is_initial=*/is_initial, /*user_errors_included=*/true),
      result);
}

// static
void CellularNetworkMetricsLogger::LogSmdsScanResult(
    const std::string& smds_activation_code,
    std::optional<HermesResponseStatus> status) {
  const bool is_user_error =
      status.has_value() &&
      CellularNetworkMetricsLogger::HermesResponseStatusIsUserError(*status);
  const ESimOperationResult result =
      CellularNetworkMetricsLogger::ComputeESimOperationResult(status);

  if (!is_user_error) {
    base::UmaHistogramEnumeration(
        GetSmdsScanResultHistogram(smds_activation_code,
                                   /*user_errors_included=*/false),
        result);
  }
  base::UmaHistogramEnumeration(
      GetSmdsScanResultHistogram(smds_activation_code,
                                 /*user_errors_included=*/true),
      result);
}

// static
CellularNetworkMetricsLogger::ESimOperationResult
CellularNetworkMetricsLogger::ComputeESimOperationResult(
    std::optional<HermesResponseStatus> status) {
  if (status.has_value()) {
    return *status == HermesResponseStatus::kSuccess
               ? ESimOperationResult::kSuccess
               : ESimOperationResult::kHermesFailed;
  }
  return ESimOperationResult::kInhibitFailed;
}

// static
bool CellularNetworkMetricsLogger::HermesResponseStatusIsUserError(
    HermesResponseStatus status) {
  switch (status) {
    case HermesResponseStatus::kSuccess:
      [[fallthrough]];
    case HermesResponseStatus::kErrorUnknown:
      [[fallthrough]];
    case HermesResponseStatus::kErrorInternalLpaFailure:
      [[fallthrough]];
    case HermesResponseStatus::kErrorSendNotificationFailure:
      [[fallthrough]];
    case HermesResponseStatus::kErrorTestProfileInProd:
      [[fallthrough]];
    case HermesResponseStatus::kErrorUnsupported:
      [[fallthrough]];
    case HermesResponseStatus::kErrorWrongState:
      [[fallthrough]];
    case HermesResponseStatus::kErrorBadRequest:
      [[fallthrough]];
    case HermesResponseStatus::kErrorBadNotification:
      [[fallthrough]];
    case HermesResponseStatus::kErrorPendingProfile:
      [[fallthrough]];
    case HermesResponseStatus::kErrorSendApduFailure:
      [[fallthrough]];
    case HermesResponseStatus::kErrorUnexpectedModemManagerState:
      [[fallthrough]];
    case HermesResponseStatus::kErrorModemMessageProcessing:
      [[fallthrough]];
    case HermesResponseStatus::kErrorNoResponse:
      [[fallthrough]];
    case HermesResponseStatus::kErrorUnknownResponse:
      return false;
    case HermesResponseStatus::kErrorAlreadyDisabled:
      [[fallthrough]];
    case HermesResponseStatus::kErrorAlreadyEnabled:
      [[fallthrough]];
    case HermesResponseStatus::kErrorInvalidActivationCode:
      [[fallthrough]];
    case HermesResponseStatus::kErrorInvalidIccid:
      [[fallthrough]];
    case HermesResponseStatus::kErrorInvalidParameter:
      [[fallthrough]];
    case HermesResponseStatus::kErrorNeedConfirmationCode:
      [[fallthrough]];
    case HermesResponseStatus::kErrorInvalidResponse:
      [[fallthrough]];
    case HermesResponseStatus::kErrorMalformedResponse:
      [[fallthrough]];
    case HermesResponseStatus::kErrorSendHttpsFailure:
      [[fallthrough]];
    case HermesResponseStatus::kErrorEmptyResponse:
      return true;
  }
  // Do not provide a default return here; all cases should be handled inside
  // the switch statement above.
}

// static
void CellularNetworkMetricsLogger::LogUserTextMessageSuppressionState(
    ash::UserTextMessageSuppressionState state) {
  UserTextMessageSuppressionState histogram_type;
  switch (state) {
    case ash::UserTextMessageSuppressionState::kAllow:
      histogram_type = UserTextMessageSuppressionState::kTextMessagesAllow;
      break;
    case ash::UserTextMessageSuppressionState::kSuppress:
      histogram_type = UserTextMessageSuppressionState::kTextMessagesSuppress;
      break;
  }
  base::UmaHistogramEnumeration(kUserAllowTextMessagesSuppressionStateHistogram,
                                histogram_type);
}

// static
void CellularNetworkMetricsLogger::LogPolicyTextMessageSuppressionState(
    ash::PolicyTextMessageSuppressionState state) {
  PolicyTextMessageSuppressionState histogram_type;
  switch (state) {
    case ash::PolicyTextMessageSuppressionState::kAllow:
      histogram_type = PolicyTextMessageSuppressionState::kTextMessagesAllow;
      break;
    case ash::PolicyTextMessageSuppressionState::kSuppress:
      histogram_type = PolicyTextMessageSuppressionState::kTextMessagesSuppress;
      break;
    case ash::PolicyTextMessageSuppressionState::kUnset:
      histogram_type = PolicyTextMessageSuppressionState::kUnset;
      break;
  }
  base::UmaHistogramEnumeration(
      kPolicyAllowTextMessagesSuppressionStateHistogram, histogram_type);
}

// static
void CellularNetworkMetricsLogger::CellularNetworkMetricsLogger::
    LogTextMessageNotificationSuppressionState(
        NotificationSuppressionState state) {
  base::UmaHistogramEnumeration(kAllowTextMessagesNotificationSuppressionState,
                                state);
}

void CellularNetworkMetricsLogger::OnConnectionResult(
    const std::string& guid,
    const std::optional<std::string>& shill_error) {
  DCHECK(network_metadata_store_)
      << "OnConnectionResult() called with no NetworkMetadataStore.";

  const NetworkState* network_state =
      network_state_handler_->GetNetworkStateFromGuid(guid);
  if (!network_state) {
    NET_LOG(ERROR)
        << "OnConnectionResult() call but no network found for guid: " << guid;
    return;
  }

  // Ignore any non-cellular networks.
  if (network_state->GetNetworkTechnologyType() !=
      NetworkState::NetworkTechnologyType::kCellular) {
    return;
  }

  ShillConnectResult connect_result =
      shill_error ? ShillErrorToConnectResult(*shill_error)
                  : ShillConnectResult::kSuccess;

  size_t custom_apns_count = 0u;
  size_t enabled_custom_apns_count = 0u;
  const base::Value::List* custom_apn_list =
      network_metadata_store_->GetCustomApnList(network_state->guid());
  if (custom_apn_list) {
    custom_apns_count = custom_apn_list->size();

    if (ash::features::IsApnRevampEnabled()) {
      enabled_custom_apns_count = std::count_if(
          custom_apn_list->begin(), custom_apn_list->end(),
          [](const base::Value& apn) -> bool {
            const std::string* apn_type =
                apn.GetDict().FindString(::onc::cellular_apn::kState);
            return *apn_type == ::onc::cellular_apn::kStateEnabled;
          });
    }
  }

  // If the connection was successful, log the number of custom APNs the network
  // has saved for it.
  if (!shill_error) {
    base::UmaHistogramCounts100(kCustomApnsCountHistogram, custom_apns_count);

    if (ash::features::IsApnRevampEnabled() && custom_apns_count > 0) {
      base::UmaHistogramCounts100(kCustomApnsEnabledCountHistogram,
                                  enabled_custom_apns_count);
      base::UmaHistogramCounts100(
          kCustomApnsDisabledCountHistogram,
          custom_apns_count - enabled_custom_apns_count);
    }
  }

  // For pre-revamp cases, we consider all custom APNs to be enabled.
  const bool has_enabled_custom_apns = ash::features::IsApnRevampEnabled()
                                           ? (enabled_custom_apns_count > 0)
                                           : (custom_apns_count > 0);
  base::UmaHistogramEnumeration(
      has_enabled_custom_apns ? kConnectResultHasEnabledCustomApnsAllHistogram
                              : kConnectResultNoEnabledCustomApnsAllHistogram,
      connect_result);
}

}  // namespace ash