// Copyright 2020 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/webui/nearby_internals/nearby_internals_ui_trigger_handler.h"

#include <memory>
#include <utility>
#include <vector>

#include "base/functional/bind.h"
#include "base/time/time.h"
#include "chrome/browser/nearby_sharing/attachment.h"
#include "chrome/browser/nearby_sharing/nearby_notification_manager.h"
#include "chrome/browser/nearby_sharing/nearby_sharing_service_factory.h"
#include "chrome/browser/nearby_sharing/share_target.h"
#include "chrome/browser/nearby_sharing/text_attachment.h"
#include "chromeos/ash/services/nearby/public/mojom/nearby_share_target_types.mojom.h"
#include "components/cross_device/logging/logging.h"

namespace {

// Text Payload Example used in SendText().
const char kPayloadExample[] = "TEXT PAYLOAD EXAMPLE";

// Keys in the JSON representation of a dictionaries sent to the UITriggerTab.
const char kTimeStampKey[] = "time";
const char kShareTargetDeviceNamesKey[] = "deviceName";
const char kShareTargetIdKey[] = "share_targetId";
const char kStatusCodeKey[] = "statusCode";
const char kTriggerEventKey[] = "triggerEvent";
const char kTransferUpdateMetaDataKey[] = "transfer_metadataStatus";

// Keys in the JSON representation of a dictiory send to UITriggerTab for
// the state of the transfer.
const char kIsConnecting[] = "isConnecting";
const char kIsInHighVisibility[] = "isInHighVisibility";
const char kIsReceiving[] = "isReceiving";
const char kIsScanning[] = "isScanning";
const char kIsSending[] = "isSending";
const char kIsTransferring[] = "isTransferring";

// KFields used in ShowReceiveNotification.
const char kShareTargetFakeFullName[] = "Daniel's Rotom";
const char kTextAttachmentFakeBodyText[] = "Long text that should be truncated";

// TriggerEvents in alphabetical order.
enum class TriggerEvent {
  kAccept,
  kCancel,
  kOpen,
  kRegisterBackgroundReceiveSurface,
  kRegisterBackgroundSendSurface,
  kRegisterForegroundReceiveSurface,
  kRegisterForegroundSendSurface,
  kReject,
  kSendText,
  kUnregisterReceiveSurface,
  kUnregisterSendSurface,
};

base::Value GetJavascriptTimestamp() {
  return base::Value(
      base::Time::Now().InMillisecondsFSinceUnixEpochIgnoringNull());
}

std::string StatusCodeToString(
    const NearbySharingService::StatusCodes status_code) {
  std::string status_code_string;
  switch (status_code) {
    case NearbySharingService::StatusCodes::kOk:
      return "OK";
    case NearbySharingService::StatusCodes::kError:
      return "ERROR";
    case NearbySharingService::StatusCodes::kOutOfOrderApiCall:
      return "OUT OF ORDER API CALL";
    case NearbySharingService::StatusCodes::kStatusAlreadyStopped:
      return "STATUS ALREADY STOPPED";
    case NearbySharingService::StatusCodes::kTransferAlreadyInProgress:
      return "TRANSFER ALREADY IN PROGRESS";
    case NearbySharingService::StatusCodes::kNoAvailableConnectionMedium:
      return "NO AVAILABLE CONNECTION MEDIUM";
  }
}

std::string TriggerEventToString(const TriggerEvent trigger_event) {
  switch (trigger_event) {
    case TriggerEvent::kSendText:
      return "SendText";
    case TriggerEvent::kAccept:
      return "Accept";
    case TriggerEvent::kCancel:
      return "Cancel";
    case TriggerEvent::kOpen:
      return "Open";
    case TriggerEvent::kReject:
      return "Reject";
    case TriggerEvent::kRegisterBackgroundSendSurface:
      return "Register SendSurface (BACKGROUND)";
    case TriggerEvent::kRegisterForegroundSendSurface:
      return "Register SendSurface (FOREGROUND)";
    case TriggerEvent::kUnregisterSendSurface:
      return "Unregister SendSurface";
    case TriggerEvent::kRegisterBackgroundReceiveSurface:
      return "Register ReceiveSurface (BACKGROUND)";
    case TriggerEvent::kRegisterForegroundReceiveSurface:
      return "Register ReceiveSurface (FOREGROUND)";
    case TriggerEvent::kUnregisterReceiveSurface:
      return "Unregister ReceiveSurface";
  }
}

std::string TransferUpdateMetaDataToString(
    const TransferMetadata& transfer_metadata) {
  switch (transfer_metadata.status()) {
    case TransferMetadata::Status::kUnknown:
      return "Transfer status: Unknown";
    case TransferMetadata::Status::kAwaitingLocalConfirmation:
      return "Transfer status: Awaiting Local Confirmation";
    case TransferMetadata::Status::kAwaitingRemoteAcceptance:
      return "Transfer status: Awaiting Remote Acceptance";
    case TransferMetadata::Status::kAwaitingRemoteAcceptanceFailed:
      return "Transfer status: Awaiting Remote Acceptance Failed";
    case TransferMetadata::Status::kInProgress:
      return "Transfer status: In Progress";
    case TransferMetadata::Status::kComplete:
      return "Transfer status: Complete";
    case TransferMetadata::Status::kFailed:
      return "Transfer status: Failed";
    case TransferMetadata::Status::kRejected:
      return "Transfer status: Rejected";
    case TransferMetadata::Status::kCancelled:
      return "Transfer status: Cancelled";
    case TransferMetadata::Status::kTimedOut:
      return "Transfer status: Timed Out";
    case TransferMetadata::Status::kMediaUnavailable:
      return "Transfer status: Media Unavailable";
    case TransferMetadata::Status::kMediaDownloading:
      return "Transfer status: Media Downloading";
    case TransferMetadata::Status::kNotEnoughSpace:
      return "Transfer status: Not Enough Space";
    case TransferMetadata::Status::kUnsupportedAttachmentType:
      return "Transfer status: Unsupported Attachment Type";
    case TransferMetadata::Status::kExternalProviderLaunched:
      return "Transfer status: External Provider Launched";
    case TransferMetadata::Status::kConnecting:
      return "Transfer status: Connecting";
    case TransferMetadata::Status::kDecodeAdvertisementFailed:
      return "Transfer status: Decode Advertistement Failed";
    case TransferMetadata::Status::kMissingTransferUpdateCallback:
      return "Transfer status: Missing Transfer Update Callback";
    case TransferMetadata::Status::kMissingShareTarget:
      return "Transfer status: Missing Share Target";
    case TransferMetadata::Status::kMissingEndpointId:
      return "Transfer status: Missing Endpoint Id";
    case TransferMetadata::Status::kMissingPayloads:
      return "Transfer status: Missing Payloads";
    case TransferMetadata::Status::kPairedKeyVerificationFailed:
      return "Transfer status: Paired Key Verification Failed";
    case TransferMetadata::Status::kInvalidIntroductionFrame:
      return "Transfer status: Invalid Introduction Frame";
    case TransferMetadata::Status::kIncompletePayloads:
      return "Transfer status: Incomplete Payloads";
    case TransferMetadata::Status::kFailedToCreateShareTarget:
      return "Transfer status: Failed To Create Share Target";
    case TransferMetadata::Status::kFailedToInitiateOutgoingConnection:
      return "Transfer status: Failed To Initiate Outgoing Connection";
    case TransferMetadata::Status::kFailedToReadOutgoingConnectionResponse:
      return "Transfer status: Failed To Read Outgoing Connection Response.";
    case TransferMetadata::Status::kUnexpectedDisconnection:
      return "Transfer status: Unexpected Disconnection";
  }
}

// Converts |status_code| to a raw dictionary value used as a JSON argument
// to JavaScript functions.
base::Value::Dict StatusCodeToDictionary(
    const NearbySharingService::StatusCodes status_code,
    TriggerEvent trigger_event) {
  base::Value::Dict dictionary;
  dictionary.Set(kStatusCodeKey, StatusCodeToString(status_code));
  dictionary.Set(kTriggerEventKey, TriggerEventToString(trigger_event));
  dictionary.Set(kTimeStampKey, GetJavascriptTimestamp());
  return dictionary;
}

// Converts |share_target| to a raw dictionary value used as a JSON argument
// to JavaScript functions.
base::Value::Dict ShareTargetToDictionary(const ShareTarget share_target) {
  base::Value::Dict share_target_dictionary;
  share_target_dictionary.Set(kShareTargetDeviceNamesKey,
                              share_target.device_name);
  share_target_dictionary.Set(kShareTargetIdKey, share_target.id.ToString());
  share_target_dictionary.Set(kTimeStampKey, GetJavascriptTimestamp());
  return share_target_dictionary;
}

// Converts |id_to_share_target_map| to a raw dictionary value used as a JSON
// argument to JavaScript functions.
base::Value::List ShareTargetMapToList(
    const base::flat_map<std::string, ShareTarget>& id_to_share_target_map) {
  base::Value::List share_target_list;
  share_target_list.reserve(id_to_share_target_map.size());

  for (const auto& it : id_to_share_target_map) {
    share_target_list.Append(ShareTargetToDictionary(it.second));
  }

  return share_target_list;
}

// Converts |transfer_metadata| to a raw dictionary value used as a JSON
// argument to JavaScript functions.
base::Value::Dict TransferUpdateToDictionary(
    const ShareTarget& share_target,
    const TransferMetadata& transfer_metadata) {
  base::Value::Dict dictionary;
  dictionary.Set(kTransferUpdateMetaDataKey,
                 TransferUpdateMetaDataToString(transfer_metadata));
  dictionary.Set(kTimeStampKey, GetJavascriptTimestamp());
  dictionary.Set(kShareTargetDeviceNamesKey, share_target.device_name);
  dictionary.Set(kShareTargetIdKey, share_target.id.ToString());
  return dictionary;
}

base::Value::Dict StatusBooleansToDictionary(const bool is_scanning,
                                             const bool is_transferring,
                                             const bool is_receiving_files,
                                             const bool is_sending_files,
                                             const bool is_conecting,
                                             const bool is_in_high_visibility) {
  base::Value::Dict dictionary;
  dictionary.Set(kIsScanning, is_scanning);
  dictionary.Set(kIsTransferring, is_transferring);
  dictionary.Set(kIsSending, is_sending_files);
  dictionary.Set(kIsReceiving, is_receiving_files);
  dictionary.Set(kIsConnecting, is_conecting);
  dictionary.Set(kIsInHighVisibility, is_in_high_visibility);
  dictionary.Set(kTimeStampKey, GetJavascriptTimestamp());
  return dictionary;
}

}  // namespace

NearbyInternalsUiTriggerHandler::NearbyInternalsUiTriggerHandler(
    content::BrowserContext* context)
    : context_(context) {}

NearbyInternalsUiTriggerHandler::~NearbyInternalsUiTriggerHandler() = default;

void NearbyInternalsUiTriggerHandler::RegisterMessages() {
  web_ui()->RegisterMessageCallback(
      "initializeUiTrigger",
      base::BindRepeating(&NearbyInternalsUiTriggerHandler::InitializeContents,
                          base::Unretained(this)));
  web_ui()->RegisterMessageCallback(
      "sendText",
      base::BindRepeating(&NearbyInternalsUiTriggerHandler::SendText,
                          base::Unretained(this)));
  web_ui()->RegisterMessageCallback(
      "accept", base::BindRepeating(&NearbyInternalsUiTriggerHandler::Accept,
                                    base::Unretained(this)));
  web_ui()->RegisterMessageCallback(
      "reject", base::BindRepeating(&NearbyInternalsUiTriggerHandler::Reject,
                                    base::Unretained(this)));
  web_ui()->RegisterMessageCallback(
      "cancel", base::BindRepeating(&NearbyInternalsUiTriggerHandler::Cancel,
                                    base::Unretained(this)));
  web_ui()->RegisterMessageCallback(
      "open", base::BindRepeating(&NearbyInternalsUiTriggerHandler::Open,
                                  base::Unretained(this)));
  web_ui()->RegisterMessageCallback(
      "registerSendSurfaceForeground",
      base::BindRepeating(
          &NearbyInternalsUiTriggerHandler::RegisterSendSurfaceForeground,
          base::Unretained(this)));
  web_ui()->RegisterMessageCallback(
      "registerSendSurfaceBackground",
      base::BindRepeating(
          &NearbyInternalsUiTriggerHandler::RegisterSendSurfaceBackground,
          base::Unretained(this)));
  web_ui()->RegisterMessageCallback(
      "unregisterSendSurface",
      base::BindRepeating(
          &NearbyInternalsUiTriggerHandler::UnregisterSendSurface,
          base::Unretained(this)));
  web_ui()->RegisterMessageCallback(
      "registerReceiveSurfaceForeground",
      base::BindRepeating(
          &NearbyInternalsUiTriggerHandler::RegisterReceiveSurfaceForeground,
          base::Unretained(this)));
  web_ui()->RegisterMessageCallback(
      "registerReceiveSurfaceBackground",
      base::BindRepeating(
          &NearbyInternalsUiTriggerHandler::RegisterReceiveSurfaceBackground,
          base::Unretained(this)));
  web_ui()->RegisterMessageCallback(
      "unregisterReceiveSurface",
      base::BindRepeating(
          &NearbyInternalsUiTriggerHandler::UnregisterReceiveSurface,
          base::Unretained(this)));
  web_ui()->RegisterMessageCallback(
      "getStates",
      base::BindRepeating(&NearbyInternalsUiTriggerHandler::GetState,
                          base::Unretained(this)));
  web_ui()->RegisterMessageCallback(
      "showNearbyShareReceivedNotification",
      base::BindRepeating(
          &NearbyInternalsUiTriggerHandler::ShowReceivedNotification,
          base::Unretained(this)));
}

void NearbyInternalsUiTriggerHandler::InitializeContents(
    const base::Value::List& args) {
  AllowJavascript();
}

void NearbyInternalsUiTriggerHandler::RegisterSendSurfaceForeground(
    const base::Value::List& args) {
  NearbySharingService* service_ =
      NearbySharingServiceFactory::GetForBrowserContext(context_);
  if (!service_) {
    CD_LOG(ERROR, Feature::NS) << "No NearbyShareService instance to call.";
    return;
  }

  const base::Value& callback_id = args[0];
  ResolveJavascriptCallback(
      callback_id,
      StatusCodeToDictionary(
          service_->RegisterSendSurface(
              this, this, NearbySharingService::SendSurfaceState::kForeground),
          TriggerEvent::kRegisterForegroundSendSurface));
}

void NearbyInternalsUiTriggerHandler::RegisterSendSurfaceBackground(
    const base::Value::List& args) {
  NearbySharingService* service_ =
      NearbySharingServiceFactory::GetForBrowserContext(context_);
  if (!service_) {
    CD_LOG(ERROR, Feature::NS) << "No NearbyShareService instance to call.";
    return;
  }

  const base::Value& callback_id = args[0];
  ResolveJavascriptCallback(
      callback_id,
      StatusCodeToDictionary(
          service_->RegisterSendSurface(
              this, this, NearbySharingService::SendSurfaceState::kBackground),
          TriggerEvent::kRegisterBackgroundSendSurface));
}

void NearbyInternalsUiTriggerHandler::UnregisterSendSurface(
    const base::Value::List& args) {
  NearbySharingService* service_ =
      NearbySharingServiceFactory::GetForBrowserContext(context_);
  if (!service_) {
    CD_LOG(ERROR, Feature::NS) << "No NearbyShareService instance to call.";
    return;
  }

  const base::Value& callback_id = args[0];
  ResolveJavascriptCallback(
      callback_id,
      StatusCodeToDictionary(service_->UnregisterSendSurface(this, this),
                             TriggerEvent::kUnregisterSendSurface));
}

void NearbyInternalsUiTriggerHandler::RegisterReceiveSurfaceForeground(
    const base::Value::List& args) {
  NearbySharingService* service_ =
      NearbySharingServiceFactory::GetForBrowserContext(context_);
  if (!service_) {
    CD_LOG(ERROR, Feature::NS) << "No NearbyShareService instance to call.";
    return;
  }

  const base::Value& callback_id = args[0];
  ResolveJavascriptCallback(
      callback_id,
      StatusCodeToDictionary(
          service_->RegisterReceiveSurface(
              this, NearbySharingService::ReceiveSurfaceState::kForeground),
          TriggerEvent::kRegisterForegroundReceiveSurface));
}

void NearbyInternalsUiTriggerHandler::RegisterReceiveSurfaceBackground(
    const base::Value::List& args) {
  NearbySharingService* service_ =
      NearbySharingServiceFactory::GetForBrowserContext(context_);
  if (!service_) {
    CD_LOG(ERROR, Feature::NS) << "No NearbyShareService instance to call.";
    return;
  }

  const base::Value& callback_id = args[0];
  ResolveJavascriptCallback(
      callback_id,
      StatusCodeToDictionary(
          service_->RegisterReceiveSurface(
              this, NearbySharingService::ReceiveSurfaceState::kBackground),
          TriggerEvent::kRegisterBackgroundReceiveSurface));
}

void NearbyInternalsUiTriggerHandler::UnregisterReceiveSurface(
    const base::Value::List& args) {
  NearbySharingService* service_ =
      NearbySharingServiceFactory::GetForBrowserContext(context_);
  if (!service_) {
    CD_LOG(ERROR, Feature::NS) << "No NearbyShareService instance to call.";
    return;
  }

  const base::Value& callback_id = args[0];
  ResolveJavascriptCallback(
      callback_id,
      StatusCodeToDictionary(service_->UnregisterReceiveSurface(this),
                             TriggerEvent::kUnregisterReceiveSurface));
}

void NearbyInternalsUiTriggerHandler::OnTransferUpdate(
    const ShareTarget& share_target,
    const TransferMetadata& transfer_metadata) {
  FireWebUIListener("transfer-updated", TransferUpdateToDictionary(
                                            share_target, transfer_metadata));
}

void NearbyInternalsUiTriggerHandler::OnShareTargetDiscovered(
    ShareTarget share_target) {
  id_to_share_target_map_.insert({share_target.id.ToString(), share_target});
  FireWebUIListener("share-target-discovered",
                    ShareTargetToDictionary(share_target));
  FireWebUIListener("share-target-map-updated",
                    ShareTargetMapToList(id_to_share_target_map_));
}

void NearbyInternalsUiTriggerHandler::OnShareTargetLost(
    ShareTarget share_target) {
  id_to_share_target_map_.erase(share_target.id.ToString());
  FireWebUIListener("share-target-lost", ShareTargetToDictionary(share_target));
  FireWebUIListener("share-target-map-updated",
                    ShareTargetMapToList(id_to_share_target_map_));
}

void NearbyInternalsUiTriggerHandler::OnAcceptCalled(
    NearbySharingService::StatusCodes status_codes) {
  FireWebUIListener(
      "on-status-code-returned",
      StatusCodeToDictionary(status_codes, TriggerEvent::kAccept));
}

void NearbyInternalsUiTriggerHandler::OnOpenCalled(
    NearbySharingService::StatusCodes status_codes) {
  FireWebUIListener("on-status-code-returned",
                    StatusCodeToDictionary(status_codes, TriggerEvent::kOpen));
}

void NearbyInternalsUiTriggerHandler::OnRejectCalled(
    NearbySharingService::StatusCodes status_codes) {
  FireWebUIListener(
      "on-status-code-returned",
      StatusCodeToDictionary(status_codes, TriggerEvent::kReject));
}

void NearbyInternalsUiTriggerHandler::OnCancelCalled(
    NearbySharingService::StatusCodes status_codes) {
  FireWebUIListener(
      "on-status-code-returned",
      StatusCodeToDictionary(status_codes, TriggerEvent::kCancel));
}

void NearbyInternalsUiTriggerHandler::SendText(const base::Value::List& args) {
  NearbySharingService* service_ =
      NearbySharingServiceFactory::GetForBrowserContext(context_);
  if (!service_) {
    CD_LOG(ERROR, Feature::NS) << "No NearbyShareService instance to call.";
    return;
  }

  std::string share_target_id = args[1].GetString();
  auto it = id_to_share_target_map_.find(share_target_id);
  if (it == id_to_share_target_map_.end()) {
    CD_LOG(ERROR, Feature::NS)
        << "Invalid ShareTarget ID " << share_target_id << " for SendText.";
    return;
  }

  std::vector<std::unique_ptr<Attachment>> attachments;
  attachments.push_back(std::make_unique<TextAttachment>(
      TextAttachment::Type::kText, kPayloadExample, /*title=*/std::nullopt,
      /*mime_type=*/std::nullopt));

  const base::Value& callback_id = args[0];
  ResolveJavascriptCallback(
      callback_id,
      StatusCodeToDictionary(
          service_->SendAttachments(it->second, std::move(attachments)),
          TriggerEvent::kSendText));
}

void NearbyInternalsUiTriggerHandler::Accept(const base::Value::List& args) {
  NearbySharingService* service_ =
      NearbySharingServiceFactory::GetForBrowserContext(context_);
  if (!service_) {
    CD_LOG(ERROR, Feature::NS) << "No NearbyShareService instance to call.";
    return;
  }

  std::string share_target_id = args[0].GetString();
  auto it = id_to_share_target_map_.find(share_target_id);
  if (it == id_to_share_target_map_.end()) {
    CD_LOG(ERROR, Feature::NS)
        << "Invalid ShareTarget ID " << share_target_id << " for Accept.";
    return;
  }

  service_->Accept(
      it->second,
      base::BindOnce(&NearbyInternalsUiTriggerHandler::OnAcceptCalled,
                     weak_ptr_factory_.GetWeakPtr()));
}

void NearbyInternalsUiTriggerHandler::Open(const base::Value::List& args) {
  NearbySharingService* service_ =
      NearbySharingServiceFactory::GetForBrowserContext(context_);
  if (!service_) {
    CD_LOG(ERROR, Feature::NS) << "No NearbyShareService instance to call.";
    return;
  }

  std::string share_target_id = args[0].GetString();
  auto it = id_to_share_target_map_.find(share_target_id);
  if (it == id_to_share_target_map_.end()) {
    CD_LOG(ERROR, Feature::NS)
        << "Invalid ShareTarget ID " << share_target_id << " for Open.";
    return;
  }

  service_->Open(it->second,
                 base::BindOnce(&NearbyInternalsUiTriggerHandler::OnOpenCalled,
                                weak_ptr_factory_.GetWeakPtr()));
}

void NearbyInternalsUiTriggerHandler::Reject(const base::Value::List& args) {
  NearbySharingService* service_ =
      NearbySharingServiceFactory::GetForBrowserContext(context_);
  if (!service_) {
    CD_LOG(ERROR, Feature::NS) << "No NearbyShareService instance to call.";
    return;
  }

  std::string share_target_id = args[0].GetString();
  auto it = id_to_share_target_map_.find(share_target_id);
  if (it == id_to_share_target_map_.end()) {
    CD_LOG(ERROR, Feature::NS)
        << "Invalid ShareTarget ID " << share_target_id << " for Reject.";
    return;
  }

  service_->Reject(
      it->second,
      base::BindOnce(&NearbyInternalsUiTriggerHandler::OnRejectCalled,
                     weak_ptr_factory_.GetWeakPtr()));
}

void NearbyInternalsUiTriggerHandler::Cancel(const base::Value::List& args) {
  NearbySharingService* service_ =
      NearbySharingServiceFactory::GetForBrowserContext(context_);
  if (!service_) {
    CD_LOG(ERROR, Feature::NS) << "No NearbyShareService instance to call.";
    return;
  }

  std::string share_target_id = args[0].GetString();
  auto it = id_to_share_target_map_.find(share_target_id);
  if (it == id_to_share_target_map_.end()) {
    CD_LOG(ERROR, Feature::NS)
        << "Invalid ShareTarget ID " << share_target_id << " for Cancel.";
    return;
  }

  service_->Cancel(
      it->second,
      base::BindOnce(&NearbyInternalsUiTriggerHandler::OnCancelCalled,
                     weak_ptr_factory_.GetWeakPtr()));
}

void NearbyInternalsUiTriggerHandler::GetState(const base::Value::List& args) {
  NearbySharingService* service_ =
      NearbySharingServiceFactory::GetForBrowserContext(context_);
  if (!service_) {
    CD_LOG(ERROR, Feature::NS) << "No NearbyShareService instance to call.";
    return;
  }

  const base::Value& callback_id = args[0];
  ResolveJavascriptCallback(
      callback_id,
      StatusBooleansToDictionary(
          service_->IsScanning(), service_->IsTransferring(),
          service_->IsReceivingFile(), service_->IsSendingFile(),
          service_->IsConnecting(), service_->IsInHighVisibility()));
}

void NearbyInternalsUiTriggerHandler::ShowReceivedNotification(
    const base::Value::List& args) {
  NearbySharingService* service =
      NearbySharingServiceFactory::GetForBrowserContext(context_);
  if (!service) {
    CD_LOG(ERROR, Feature::NS) << "No NearbyShareService instance to call.";
    return;
  }

  NearbyNotificationManager* manager = service->GetNotificationManager();

  if (!manager) {
    CD_LOG(ERROR, Feature::NS)
        << "No NearbyNotificationManager instance to call.";
    return;
  }

  // Create a share target with a fake text attachment.
  TextAttachment attachment(TextAttachment::Type::kText,
                            kTextAttachmentFakeBodyText,
                            /*title=*/std::nullopt,
                            /*mime_type=*/std::nullopt);
  ShareTarget target;
  target.is_incoming = true;
  target.device_name = kShareTargetFakeFullName;
  attachment.MoveToShareTarget(target);

  manager->ShowSuccess(target);
}