// Copyright 2012 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/ui/ash/network/network_state_notifier.h"

#include <string>

#include "ash/constants/ash_features.h"
#include "ash/constants/notifier_catalogs.h"
#include "ash/public/cpp/notification_utils.h"
#include "ash/public/cpp/system_tray_client.h"
#include "base/functional/bind.h"
#include "base/location.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "chrome/app/vector_icons/vector_icons.h"
#include "chrome/browser/notifications/system_notification_helper.h"
#include "chrome/grit/generated_resources.h"
#include "chromeos/ash/components/network/cellular_esim_profile_handler.h"
#include "chromeos/ash/components/network/network_configuration_handler.h"
#include "chromeos/ash/components/network/network_connect.h"
#include "chromeos/ash/components/network/network_connection_handler.h"
#include "chromeos/ash/components/network/network_event_log.h"
#include "chromeos/ash/components/network/network_name_util.h"
#include "chromeos/ash/components/network/network_state.h"
#include "chromeos/ash/components/network/shill_property_util.h"
#include "third_party/cros_system_api/dbus/service_constants.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/chromeos/devicetype_utils.h"
#include "ui/chromeos/shill_error.h"
#include "ui/chromeos/strings/grit/ui_chromeos_strings.h"
#include "ui/gfx/vector_icon_types.h"
#include "ui/message_center/public/cpp/notification.h"

namespace ash {

namespace {

const int kMinTimeBetweenOutOfCreditsNotifySeconds = 10 * 60;

const char kNotifierNetwork[] = "ash.network";
const char kNotifierNetworkError[] = "ash.network.error";

// Ignore in-progress errors and disconnect errors (which may occur when a new
// connect request occurs while a previous connect is in-progress).
bool ShillErrorIsIgnored(const std::string& shill_error) {
  return shill_error == shill::kErrorResultInProgress ||
         shill_error == shill::kErrorDisconnect;
}

// Returns true if |shill_error| is known to be a configuration error.
bool IsConfigurationError(const std::string& shill_error) {
  if (shill_error.empty()) {
    return false;
  }
  return shill_error == shill::kErrorPinMissing ||
         shill_error == shill::kErrorBadPassphrase ||
         shill_error == shill::kErrorResultInvalidPassphrase ||
         shill_error == shill::kErrorBadWEPKey;
}

std::string GetStringFromDictionary(
    const std::optional<base::Value::Dict>& dict,
    const std::string& key) {
  const std::string* v = dict ? dict->FindString(key) : nullptr;
  return v ? *v : std::string();
}

// Error messages based on |error_name|, not network_state->GetError().
std::u16string GetConnectErrorString(const std::string& error_name) {
  if (error_name == NetworkConnectionHandler::kErrorNotFound) {
    return l10n_util::GetStringUTF16(IDS_CHROMEOS_NETWORK_ERROR_CONNECT_FAILED);
  }
  if (error_name == NetworkConnectionHandler::kErrorConfigureFailed) {
    return l10n_util::GetStringUTF16(
        IDS_CHROMEOS_NETWORK_ERROR_CONFIGURE_FAILED);
  }
  if (error_name == NetworkConnectionHandler::kErrorCertLoadTimeout) {
    return l10n_util::GetStringUTF16(
        IDS_CHROMEOS_NETWORK_ERROR_CERTIFICATES_NOT_LOADED);
  }
  if (error_name == NetworkConnectionHandler::kErrorActivateFailed) {
    return l10n_util::GetStringUTF16(
        IDS_CHROMEOS_NETWORK_ERROR_ACTIVATION_FAILED);
  }
  if (error_name == NetworkConnectionHandler::kErrorSimPinPukLocked) {
    return l10n_util::GetStringUTF16(IDS_NETWORK_LIST_SIM_CARD_LOCKED);
  }
  if (error_name == NetworkConnectionHandler::kErrorSimCarrierLocked) {
    return l10n_util::GetStringUTF16(IDS_NETWORK_LIST_SIM_CARD_CARRIER_LOCKED);
  }
  return std::u16string();
}

const gfx::VectorIcon& GetErrorNotificationVectorIcon(
    const std::string& network_type) {
  if (network_type == shill::kTypeVPN) {
    return kNotificationVpnIcon;
  }
  if (network_type == shill::kTypeCellular) {
    return kNotificationMobileDataOffIcon;
  }
  return kNotificationWifiOffIcon;
}

// |identifier| may be a service path or guid.
void ShowErrorNotification(const std::string& identifier,
                           const std::string& notification_id,
                           const NotificationCatalogName& catalog_name,
                           const std::string& network_type,
                           const std::u16string& title,
                           const std::u16string& message,
                           base::RepeatingClosure callback) {
  NET_LOG(ERROR) << "ShowErrorNotification: " << identifier << ": "
                 << base::UTF16ToUTF8(title);
  message_center::Notification notification = CreateSystemNotification(
      message_center::NOTIFICATION_TYPE_SIMPLE, notification_id, title, message,
      std::u16string() /* display_source */, GURL(),
      message_center::NotifierId(message_center::NotifierType::SYSTEM_COMPONENT,
                                 kNotifierNetworkError, catalog_name),
      message_center::RichNotificationData(),
      new message_center::HandleNotificationClickDelegate(std::move(callback)),
      GetErrorNotificationVectorIcon(network_type),
      message_center::SystemNotificationWarningLevel::WARNING);
  SystemNotificationHelper::GetInstance()->Display(notification);
}

bool ShouldConnectFailedNotificationBeShown(const std::string& error_name,
                                            const NetworkState* network_state) {
  // Only show a notification for certain errors. Other failures are expected
  // to be handled by the UI that initiated the connect request.
  // Note: kErrorConnectFailed may also cause the configure dialog to be
  // displayed, but we rely on the notification system to show additional
  // details if available.
  if (error_name != NetworkConnectionHandler::kErrorConnectFailed &&
      error_name != NetworkConnectionHandler::kErrorNotFound &&
      error_name != NetworkConnectionHandler::kErrorConfigureFailed &&
      error_name != NetworkConnectionHandler::kErrorCertLoadTimeout &&
      error_name != NetworkConnectionHandler::kErrorSimPinPukLocked &&
      error_name != NetworkConnectionHandler::kErrorSimCarrierLocked) {
    return false;
  }

  // When a connection to a Tether network fails, the Tether component shows its
  // own error notification. If this is the case, there is no need to show an
  // additional notification for the failure to connect to the underlying Wi-Fi
  // network.
  if (network_state && !network_state->tether_guid().empty()) {
    return false;
  }

  // Otherwise, the connection failed notification should be shown.
  return true;
}

const NetworkState* GetNetworkStateForGuid(const std::string& guid) {
  return guid.empty() ? nullptr
                      : NetworkHandler::Get()
                            ->network_state_handler()
                            ->GetNetworkStateFromGuid(guid);
}

bool IsSimLockConnectionFailure(const std::string& connection_error_name,
                                const NetworkState* network_state) {
  if (connection_error_name ==
      NetworkConnectionHandler::kErrorSimPinPukLocked) {
    return true;
  }

  return network_state && network_state->GetError() == shill::kErrorSimLocked;
}

}  // namespace

const char NetworkStateNotifier::kNetworkConnectNotificationId[] =
    "chrome://settings/internet/connect";
const char NetworkStateNotifier::kNetworkActivateNotificationId[] =
    "chrome://settings/internet/activate";
const char NetworkStateNotifier::kNetworkOutOfCreditsNotificationId[] =
    "chrome://settings/internet/out-of-credits";
const char NetworkStateNotifier::kNetworkCarrierUnlockNotificationId[] =
    "chrome://settings/internet/carrier-unlock";

NetworkStateNotifier::NetworkStateNotifier() {
  if (!NetworkHandler::IsInitialized()) {
    return;
  }
  NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
  network_state_handler_observer_.Observe(handler);
  NetworkStateHandler::NetworkStateList active_networks;
  handler->GetActiveNetworkListByType(NetworkTypePattern::Default(),
                                      &active_networks);
  ActiveNetworksChanged(active_networks);
  NetworkHandler::Get()->network_connection_handler()->AddObserver(this);
}

NetworkStateNotifier::~NetworkStateNotifier() {
  if (!NetworkHandler::IsInitialized()) {
    return;
  }
  NetworkHandler::Get()->network_connection_handler()->RemoveObserver(this);
}

void NetworkStateNotifier::ConnectToNetworkRequested(
    const std::string& service_path) {
  const NetworkState* network =
      NetworkHandler::Get()->network_state_handler()->GetNetworkState(
          service_path);
  if (network && network->type() == shill::kTypeVPN) {
    connected_vpn_.reset();
  }

  RemoveConnectNotification();
}

void NetworkStateNotifier::NetworkConnectionStateChanged(
    const NetworkState* network) {
  if (!network->IsConnectedState() ||
      connect_error_notification_network_guid_.empty() ||
      connect_error_notification_network_guid_ != network->guid()) {
    return;
  }
  RemoveConnectNotification();
}

void NetworkStateNotifier::NetworkIdentifierTransitioned(
    const std::string& old_service_path,
    const std::string& new_service_path,
    const std::string& old_guid,
    const std::string& new_guid) {
  if (old_guid == new_guid ||
      old_guid != connect_error_notification_network_guid_) {
    return;
  }

  connect_error_notification_network_guid_ = new_guid;
}

void NetworkStateNotifier::OnShuttingDown() {
  network_state_handler_observer_.Reset();
}

void NetworkStateNotifier::ConnectSucceeded(const std::string& service_path) {
  RemoveConnectNotification();
}

void NetworkStateNotifier::ConnectFailed(const std::string& service_path,
                                         const std::string& error_name) {
  const NetworkState* network =
      NetworkHandler::Get()->network_state_handler()->GetNetworkState(
          service_path);
  if (!ShouldConnectFailedNotificationBeShown(error_name, network)) {
    NET_LOG(EVENT) << "Skipping notification for: "
                   << NetworkPathId(service_path) << " Error: " << error_name;
    return;
  }
  ShowNetworkConnectErrorForGuid(error_name, network ? network->guid() : "");
}

void NetworkStateNotifier::DisconnectRequested(
    const std::string& service_path) {
  const NetworkState* network =
      NetworkHandler::Get()->network_state_handler()->GetNetworkState(
          service_path);
  if (network && network->type() == shill::kTypeVPN) {
    connected_vpn_.reset();
  }
}

void NetworkStateNotifier::ActiveNetworksChanged(
    const std::vector<const NetworkState*>& active_networks) {
  const NetworkState* active_vpn = nullptr;
  std::string active_non_vpn_network_guid;
  // NOTE: The list of 'active' networks includes disconnected networks that
  // were connected or connecting.
  for (const auto* network : active_networks) {
    if (network->type() == shill::kTypeVPN) {
      // Make sure that if there is an edge case with two active VPNs that we
      // track the first active one.
      if (!active_vpn) {
        active_vpn = network;
      }
    } else if (active_non_vpn_network_guid.empty()) {
      // We are only interested in the "default" (first active) non virtual
      // network.
      if (network->IsConnectingOrConnected()) {
        active_non_vpn_network_guid = network->guid();
      }
    }
  }
  UpdateVpnConnectionState(active_vpn);

  // If the default network changes, allow the out of credits notification to be
  // shown again. A delay prevents the notification from being shown too
  // frequently (see below).
  if (active_non_vpn_network_guid != active_non_vpn_network_guid_) {
    active_non_vpn_network_guid_ = active_non_vpn_network_guid;
    did_show_out_of_credits_ = false;
    UpdateCellularOutOfCredits();
  }
}

void NetworkStateNotifier::NetworkPropertiesUpdated(
    const NetworkState* network) {
  if (network->type() != shill::kTypeCellular) {
    return;
  }
  if (network->cellular_out_of_credits()) {
    UpdateCellularOutOfCredits();
  }
  UpdateCellularActivating(network);
}

void NetworkStateNotifier::UpdateVpnConnectionState(
    const NetworkState* active_vpn) {
  if (!active_vpn || !active_vpn->IsConnectingOrConnected()) {
    // No connecting or connected VPN. If we were tracking a connected VPN,
    // show a notification.
    if (connected_vpn_) {
      ShowVpnDisconnectedNotification(connected_vpn_.get());
      connected_vpn_.reset();
    }
    return;
  }
  if (connected_vpn_ && active_vpn->guid() == connected_vpn_->guid) {
    // The connected VPN is unchanged and still connected or connecting. If the
    // VPN goes from connected -> connecting -> connected, we do not want to
    // show a notification.
    return;
  }

  // Do not track ARC VPNs for showing disconnect notifications. Also make sure
  // |connected_vpn_| is cleared when connected to an ARC VPN.
  if (active_vpn->GetVpnProviderType() == shill::kProviderArcVpn) {
    connected_vpn_.reset();
    return;
  }

  // If we are connected to a new VPN, track it as the connected VPN. Do not
  // show a notification, even if we were tracking a different connected VPN,
  // since we are still connected to a VPN (i.e. just replace |connected_vpn_|).
  if (active_vpn->IsConnectedState()) {
    connected_vpn_ =
        std::make_unique<VpnDetails>(active_vpn->guid(), active_vpn->name());
  } else {
    // |active_vpn| is connecting. Clear |connected_vpn_| so that we do not
    // show a notification for the previous VPN.
    connected_vpn_.reset();
  }
}

void NetworkStateNotifier::UpdateCellularOutOfCredits() {
  // Only show the notification once (reset when the primary network changes).
  if (did_show_out_of_credits_) {
    return;
  }

  NetworkStateHandler::NetworkStateList active_networks;
  NetworkHandler::Get()->network_state_handler()->GetActiveNetworkListByType(
      NetworkTypePattern::NonVirtual(), &active_networks);
  const NetworkState* primary_network = nullptr;
  for (const auto* network : active_networks) {
    // Don't display notification if any network is connecting.
    if (network->IsConnectingState()) {
      return;
    }
    if (!primary_network) {
      primary_network = network;
    }
  }

  if (!primary_network ||
      !primary_network->Matches(NetworkTypePattern::Cellular()) ||
      !primary_network->cellular_out_of_credits()) {
    return;
  }

  did_show_out_of_credits_ = true;
  base::TimeDelta dtime = base::Time::Now() - out_of_credits_notify_time_;
  if (dtime.InSeconds() > kMinTimeBetweenOutOfCreditsNotifySeconds) {
    out_of_credits_notify_time_ = base::Time::Now();
    std::u16string error_msg =
        l10n_util::GetStringFUTF16(IDS_NETWORK_OUT_OF_CREDITS_BODY,
                                   base::UTF8ToUTF16(primary_network->name()));
    ShowErrorNotification(
        NetworkId(primary_network), kNetworkOutOfCreditsNotificationId,
        NotificationCatalogName::kNetworkOutOfCredits, primary_network->type(),
        l10n_util::GetStringUTF16(IDS_NETWORK_OUT_OF_CREDITS_TITLE), error_msg,
        base::BindRepeating(&NetworkStateNotifier::ShowCarrierAccountDetail,
                            weak_ptr_factory_.GetWeakPtr(),
                            primary_network->guid()));
  }
}

void NetworkStateNotifier::UpdateCellularActivating(
    const NetworkState* cellular) {
  const std::string cellular_guid = cellular->guid();
  // Keep track of any activating cellular network.
  std::string activation_state = cellular->activation_state();
  if (activation_state == shill::kActivationStateActivating) {
    cellular_activating_guids_.insert(cellular_guid);
    return;
  }
  // Only display a notification if this network was activating and is now
  // activated.
  if (!cellular_activating_guids_.count(cellular_guid) ||
      activation_state != shill::kActivationStateActivated) {
    return;
  }

  cellular_activating_guids_.erase(cellular_guid);
  message_center::Notification notification = CreateSystemNotification(
      message_center::NOTIFICATION_TYPE_SIMPLE, kNetworkActivateNotificationId,
      l10n_util::GetStringUTF16(IDS_NETWORK_CELLULAR_ACTIVATED_TITLE),
      l10n_util::GetStringFUTF16(IDS_NETWORK_CELLULAR_ACTIVATED,
                                 base::UTF8ToUTF16((cellular->name()))),
      std::u16string() /* display_source */, GURL(),
      message_center::NotifierId(
          message_center::NotifierType::SYSTEM_COMPONENT, kNotifierNetwork,
          NotificationCatalogName::kNetworkCellularActivated),
      {},
      new message_center::HandleNotificationClickDelegate(
          base::BindRepeating(&NetworkStateNotifier::ShowNetworkSettings,
                              weak_ptr_factory_.GetWeakPtr(), cellular_guid)),
      kNotificationMobileDataIcon,
      message_center::SystemNotificationWarningLevel::WARNING);
  SystemNotificationHelper::GetInstance()->Display(notification);
}

void NetworkStateNotifier::ShowNetworkConnectErrorForGuid(
    const std::string& error_name,
    const std::string& guid) {
  const NetworkState* network = GetNetworkStateForGuid(guid);
  if (!network) {
    ShowConnectErrorNotification(error_name,
                                 /*service_path=*/std::string(),
                                 /*shill_properties=*/std::nullopt);
    return;
  }
  // Get the up-to-date properties for the network and display the error.
  NetworkHandler::Get()->network_configuration_handler()->GetShillProperties(
      network->path(),
      base::BindRepeating(&NetworkStateNotifier::OnConnectErrorGetProperties,
                          weak_ptr_factory_.GetWeakPtr(), error_name));
}

void NetworkStateNotifier::ShowMobileActivationErrorForGuid(
    const std::string& guid) {
  const NetworkState* cellular = GetNetworkStateForGuid(guid);
  if (!cellular || cellular->type() != shill::kTypeCellular) {
    NET_LOG(ERROR) << "ShowMobileActivationError without Cellular network: "
                   << guid;
    return;
  }
  message_center::Notification notification = CreateSystemNotification(
      message_center::NOTIFICATION_TYPE_SIMPLE, kNetworkActivateNotificationId,
      l10n_util::GetStringUTF16(IDS_NETWORK_ACTIVATION_ERROR_TITLE),
      l10n_util::GetStringFUTF16(IDS_NETWORK_ACTIVATION_NEEDS_CONNECTION,
                                 base::UTF8ToUTF16((cellular->name()))),
      std::u16string() /* display_source */, GURL(),
      message_center::NotifierId(
          message_center::NotifierType::SYSTEM_COMPONENT, kNotifierNetworkError,
          NotificationCatalogName::kNetworkActivationError),
      {},
      new message_center::HandleNotificationClickDelegate(base::BindRepeating(
          &NetworkStateNotifier::ShowNetworkSettings,
          weak_ptr_factory_.GetWeakPtr(), cellular->guid())),
      kNotificationMobileDataOffIcon,
      message_center::SystemNotificationWarningLevel::WARNING);
  SystemNotificationHelper::GetInstance()->Display(notification);
}

void NetworkStateNotifier::RemoveConnectNotification() {
  SystemNotificationHelper::GetInstance()->Close(kNetworkConnectNotificationId);
  connect_error_notification_network_guid_.clear();
}

void NetworkStateNotifier::RemoveCarrierUnlockNotification() {
  SystemNotificationHelper::GetInstance()->Close(
      kNetworkCarrierUnlockNotificationId);
}

void NetworkStateNotifier::OnConnectErrorGetProperties(
    const std::string& error_name,
    const std::string& service_path,
    std::optional<base::Value::Dict> shill_properties) {
  if (!shill_properties) {
    ShowConnectErrorNotification(error_name, service_path,
                                 std::move(shill_properties));
    return;
  }

  std::string state =
      GetStringFromDictionary(shill_properties, shill::kStateProperty);
  if (NetworkState::StateIsConnected(state) ||
      NetworkState::StateIsConnecting(state)) {
    NET_LOG(EVENT) << "Skipping connect error notification. State: " << state;
    // Network is no longer in an error state. This can happen if an
    // unexpected idle state transition occurs, see http://crbug.com/333955.
    return;
  }
  ShowConnectErrorNotification(error_name, service_path,
                               std::move(shill_properties));
}

void NetworkStateNotifier::ShowConnectErrorNotification(
    const std::string& error_name,
    const std::string& service_path,
    std::optional<base::Value::Dict> shill_properties) {
  std::u16string error = GetConnectErrorString(error_name);
  NET_LOG(DEBUG) << "Notify: " << NetworkPathId(service_path)
                 << ": Connect error: " << error_name << ": "
                 << base::UTF16ToUTF8(error);

  const NetworkState* network =
      NetworkHandler::Get()->network_state_handler()->GetNetworkState(
          service_path);
  std::string guid = network ? network->guid() : "";
  std::string log_id =
      network ? NetworkId(network) : NetworkPathId(service_path);

  if (error.empty()) {
    std::string shill_error =
        GetStringFromDictionary(shill_properties, shill::kErrorProperty);
    if (!NetworkState::ErrorIsValid(shill_error)) {
      shill_error = GetStringFromDictionary(shill_properties,
                                            shill::kPreviousErrorProperty);
      NET_LOG(DEBUG) << "Notify: " << log_id
                     << ": Service.PreviousError: " << shill_error;
      if (!NetworkState::ErrorIsValid(shill_error)) {
        shill_error.clear();
      }
    } else {
      NET_LOG(DEBUG) << "Notify: " << log_id
                     << ": Service.Error: " << shill_error;
    }

    if (network) {
      // Log all error values for debugging.
      NET_LOG(DEBUG) << "Notify: " << log_id
                     << ": Network.GetError(): " << network->GetError()
                     << " shill_connect_error: "
                     << network->shill_connect_error();
      if (shill_error.empty()) {
        shill_error = network->GetError();
      }
      if (shill_error.empty()) {
        shill_error = network->shill_connect_error();
      }
    }

    if (ShillErrorIsIgnored(shill_error)) {
      NET_LOG(DEBUG) << "Notify: " << log_id
                     << ": Ignoring error: " << error_name;
      return;
    }
    error = ui::shill_error::GetShillErrorString(shill_error, guid);
    if (error.empty()) {
      if (error_name == NetworkConnectionHandler::kErrorConnectFailed &&
          network && !network->connectable()) {
        // Connect failure on non connectable network with no additional
        // information. We expect the UI to show configuration UI so do not
        // show an additional (and unhelpful) notification.
        return;
      }
      error = l10n_util::GetStringUTF16(IDS_CHROMEOS_NETWORK_ERROR_UNKNOWN);
    }
  }
  NET_LOG(ERROR) << "Notify: " << log_id
                 << ": Connect error: " + base::UTF16ToUTF8(error);

  CellularESimProfileHandler* cellular_esim_profile_handler =
      NetworkHandler::Get()->cellular_esim_profile_handler();
  std::string network_name;
  if (network) {
    std::optional<std::string> esim_name =
        network_name_util::GetESimProfileName(cellular_esim_profile_handler,
                                              network);
    if (esim_name) {
      network_name = *esim_name;
    }
  }
  if (network_name.empty() && shill_properties) {
    network_name = shill_property_util::GetNameFromProperties(
        service_path, shill_properties.value());
  }

  std::string network_error_details =
      GetStringFromDictionary(shill_properties, shill::kErrorDetailsProperty);

  std::u16string error_msg;
  if (!network_error_details.empty()) {
    // network_name shouldn't be empty if network_error_details is set.
    error_msg = l10n_util::GetStringFUTF16(
        IDS_NETWORK_CONNECTION_ERROR_MESSAGE_WITH_SERVER_MESSAGE,
        base::UTF8ToUTF16(network_name), error,
        base::UTF8ToUTF16(network_error_details));
  } else if (network_name.empty()) {
    error_msg = l10n_util::GetStringFUTF16(
        IDS_NETWORK_CONNECTION_ERROR_MESSAGE_NO_NAME, error);
  } else {
    error_msg =
        l10n_util::GetStringFUTF16(IDS_NETWORK_CONNECTION_ERROR_MESSAGE,
                                   base::UTF8ToUTF16(network_name), error);
  }

  std::string network_type =
      GetStringFromDictionary(shill_properties, shill::kTypeProperty);

  base::RepeatingClosure on_click;
  if (IsSimLockConnectionFailure(error_name, network)) {
    on_click = base::BindRepeating(&NetworkStateNotifier::ShowSimUnlockSettings,
                                   weak_ptr_factory_.GetWeakPtr());
  } else if (features::IsApnRevampEnabled() && network &&
             network->GetError() == shill::kErrorInvalidAPN) {
    on_click = base::BindRepeating(&NetworkStateNotifier::ShowApnSettings,
                                   weak_ptr_factory_.GetWeakPtr(), guid);
  } else {
    on_click = base::BindRepeating(&NetworkStateNotifier::ShowNetworkSettings,
                                   weak_ptr_factory_.GetWeakPtr(), guid);
  }

  connect_error_notification_network_guid_ = guid;
  ShowErrorNotification(
      NetworkPathId(service_path), kNetworkConnectNotificationId,
      NotificationCatalogName::kNetworkConnectionError, network_type,
      l10n_util::GetStringUTF16(IDS_NETWORK_CONNECTION_ERROR_TITLE), error_msg,
      std::move(on_click));
}

void NetworkStateNotifier::ShowVpnDisconnectedNotification(VpnDetails* vpn) {
  DCHECK(vpn);
  std::u16string error_msg = l10n_util::GetStringFUTF16(
      IDS_NETWORK_VPN_CONNECTION_LOST_BODY, base::UTF8ToUTF16(vpn->name));
  ShowErrorNotification(
      NetworkGuidId(vpn->guid), kNetworkConnectNotificationId,
      NotificationCatalogName::kNetworkVPNConnectionLost, shill::kTypeVPN,
      l10n_util::GetStringUTF16(IDS_NETWORK_VPN_CONNECTION_LOST_TITLE),
      error_msg,
      base::BindRepeating(&NetworkStateNotifier::ShowNetworkSettings,
                          weak_ptr_factory_.GetWeakPtr(), vpn->guid));
}

void NetworkStateNotifier::ShowCarrierUnlockNotification() {
  std::u16string message =
      l10n_util::GetStringUTF16(IDS_NETWORK_CARRIER_UNLOCK_BODY);
  message_center::Notification notification = CreateSystemNotification(
      message_center::NOTIFICATION_TYPE_SIMPLE,
      kNetworkCarrierUnlockNotificationId,
      l10n_util::GetStringFUTF16(IDS_NETWORK_CARRIER_UNLOCK_TITLE,
                                 ui::GetChromeOSDeviceName()),
      message, std::u16string() /* display_source */, GURL(),
      message_center::NotifierId(
          message_center::NotifierType::SYSTEM_COMPONENT, kNotifierNetworkError,
          NotificationCatalogName::kNetworkCarrierUnlock),
      message_center::RichNotificationData(),
      new message_center::HandleNotificationClickDelegate(
          base::BindRepeating(&NetworkStateNotifier::ShowMobileDataSubpage,
                              weak_ptr_factory_.GetWeakPtr())),
      gfx::VectorIcon::EmptyIcon(),
      message_center::SystemNotificationWarningLevel::NORMAL);
  SystemNotificationHelper::GetInstance()->Display(notification);
}

void NetworkStateNotifier::ShowNetworkSettings(const std::string& network_id) {
  if (!system_tray_client_) {
    return;
  }
  const NetworkState* network = GetNetworkStateForGuid(network_id);
  if (!network) {
    return;
  }
  std::string error = network->GetError();
  if (!error.empty()) {
    NET_LOG(ERROR) << "Notify ShowNetworkSettings: " << NetworkId(network)
                   << ": Error: " << error;
  }
  if (!NetworkTypePattern::Primitive(network->type())
           .MatchesPattern(NetworkTypePattern::Mobile()) &&
      IsConfigurationError(error)) {
    system_tray_client_->ShowNetworkConfigure(network_id);
  } else {
    system_tray_client_->ShowNetworkSettings(network_id);
  }
}

void NetworkStateNotifier::ShowSimUnlockSettings() {
  if (!system_tray_client_) {
    return;
  }

  NET_LOG(USER) << "Opening SIM unlock settings";
  system_tray_client_->ShowSettingsSimUnlock();
}

void NetworkStateNotifier::ShowMobileDataSubpage() {
  if (!system_tray_client_) {
    return;
  }

  NET_LOG(USER) << "Opening Mobile data subpage";
  system_tray_client_->ShowMobileDataSubpage();
}

void NetworkStateNotifier::ShowApnSettings(const std::string& network_id) {
  CHECK(features::IsApnRevampEnabled());
  if (!system_tray_client_) {
    return;
  }

  NET_LOG(USER) << "Opening APN subpage for network: " << network_id;
  system_tray_client_->ShowApnSubpage(network_id);
}

void NetworkStateNotifier::ShowCarrierAccountDetail(
    const std::string& network_id) {
  NetworkConnect::Get()->ShowCarrierAccountDetail(network_id);
}

}  // namespace ash