// Copyright 2021 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/ash/extensions/file_manager/system_notification_manager.h"

#include <optional>
#include <string>

#include "ash/resources/vector_icons/vector_icons.h"
#include "ash/webui/file_manager/file_manager_ui.h"
#include "ash/webui/settings/public/constants/routes.mojom.h"
#include "base/functional/bind.h"
#include "base/functional/callback_forward.h"
#include "base/functional/callback_helpers.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_refptr.h"
#include "base/metrics/histogram_macros.h"
#include "base/notreached.h"
#include "base/numerics/safe_conversions.h"
#include "base/strings/strcat.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "base/types/cxx23_to_underlying.h"
#include "chrome/browser/ash/drive/file_system_util.h"
#include "chrome/browser/ash/extensions/file_manager/drivefs_event_router.h"
#include "chrome/browser/ash/file_manager/fileapi_util.h"
#include "chrome/browser/ash/file_manager/io_task.h"
#include "chrome/browser/ash/file_manager/io_task_controller.h"
#include "chrome/browser/ash/file_manager/path_util.h"
#include "chrome/browser/ash/policy/dlp/dialogs/files_policy_dialog.h"
#include "chrome/browser/ash/policy/dlp/files_policy_notification_manager.h"
#include "chrome/browser/ash/policy/dlp/files_policy_notification_manager_factory.h"
#include "chrome/browser/platform_util.h"
#include "chrome/browser/ui/settings_window_manager_chromeos.h"
#include "chrome/common/extensions/api/file_manager_private.h"
#include "chrome/grit/generated_resources.h"
#include "chromeos/ash/experiences/arc/arc_prefs.h"
#include "components/prefs/pref_service.h"
#include "content/public/browser/browser_task_traits.h"
#include "content/public/browser/browser_thread.h"
#include "extensions/browser/extension_event_histogram_value.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/chromeos/strings/grit/ui_chromeos_strings.h"
#include "ui/message_center/public/cpp/notification.h"

namespace file_manager {
namespace {

namespace fmp = extensions::api::file_manager_private;

using base::BindRepeating;
using base::MakeRefCounted;
using base::RepeatingClosure;
using base::UTF8ToUTF16;
using extensions::Event;
using file_manager::io_task::IOTaskController;
using file_manager::io_task::IOTaskId;
using file_manager::io_task::OperationType;
using file_manager::io_task::ProgressStatus;
using file_manager::util::GetDisplayablePath;
using fmp::MountCompletedEvent;
using fmp::ToString;
using l10n_util::GetStringFUTF16;
using l10n_util::GetStringUTF16;
using message_center::ButtonInfo;
using message_center::HandleNotificationClickDelegate;
using message_center::Notification;
using message_center::NotificationDelegate;
using message_center::NotifierId;
using message_center::RichNotificationData;
using message_center::SystemNotificationWarningLevel;
using NotificationPtr = std::unique_ptr<Notification>;
using DelegatePtr = scoped_refptr<NotificationDelegate>;
using OperationID = storage::FileSystemOperationRunner::OperationID;
using FileSystemContextPtr = scoped_refptr<storage::FileSystemContext>;

using enum extensions::events::HistogramValue;
using enum message_center::NotificationType;

void CancelCopyOnIOThread(FileSystemContextPtr file_system_context,
                          OperationID operation_id) {
  file_system_context->operation_runner()->Cancel(
      operation_id, base::BindOnce([](base::File::Error error) {
        DLOG_IF(WARNING, error != base::File::FILE_OK)
            << "Failed to cancel copy: " << error;
      }));
}

constexpr char kSwaFileOperationPrefix[] = "swa-file-operation-";

bool NotificationIdToOperationId(const std::string& notification_id,
                                 OperationID* operation_id) {
  *operation_id = 0;
  std::string id_string;
  if (base::RemoveChars(notification_id, kSwaFileOperationPrefix, &id_string)) {
    if (base::StringToUint64(id_string, operation_id)) {
      return true;
    }
  }

  return false;
}

void RecordDeviceNotificationMetric(DeviceNotificationUmaType type) {
  UMA_HISTOGRAM_ENUMERATION(kNotificationShowHistogramName, type);
}

void RecordDeviceNotificationUserActionMetric(
    DeviceNotificationUserActionUmaType type) {
  UMA_HISTOGRAM_ENUMERATION(kNotificationUserActionHistogramName, type);
}

std::u16string GetIOTaskMessage(Profile* profile,
                                const ProgressStatus& status) {
  int single_file_message_id;
  int multiple_file_message_id;

  // Display special copy to help users understand that pasting files to "My
  // Drive" does not mean that they are immediately synced.
  drive::DriveIntegrationService* const service =
      drive::util::GetIntegrationServiceByProfile(profile);
  bool is_destination_drive =
      service && service->GetMountPointPath().IsParent(
                     status.GetDestinationFolder().path());

  switch (status.type) {
    case OperationType::kCopy:
      if (is_destination_drive) {
        single_file_message_id = IDS_FILE_BROWSER_PREPARING_FILE_NAME_MY_DRIVE;
        multiple_file_message_id = IDS_FILE_BROWSER_PREPARING_ITEMS_MY_DRIVE;
      } else {
        single_file_message_id = IDS_FILE_BROWSER_COPY_FILE_NAME;
        multiple_file_message_id = IDS_FILE_BROWSER_COPY_ITEMS_REMAINING;
      }
      break;

    case OperationType::kMove:
      if (is_destination_drive) {
        single_file_message_id = IDS_FILE_BROWSER_PREPARING_FILE_NAME_MY_DRIVE;
        multiple_file_message_id = IDS_FILE_BROWSER_PREPARING_ITEMS_MY_DRIVE;
      } else {
        single_file_message_id = IDS_FILE_BROWSER_MOVE_FILE_NAME;
        multiple_file_message_id = IDS_FILE_BROWSER_MOVE_ITEMS_REMAINING;
      }
      break;

    case OperationType::kDelete:
      single_file_message_id = IDS_FILE_BROWSER_DELETE_FILE_NAME;
      multiple_file_message_id = IDS_FILE_BROWSER_DELETE_ITEMS_REMAINING;
      break;

    case OperationType::kExtract:
      single_file_message_id = IDS_FILE_BROWSER_EXTRACT_FILE_NAME;
      multiple_file_message_id = IDS_FILE_BROWSER_EXTRACT_ITEMS_REMAINING;
      break;

    case OperationType::kZip:
      single_file_message_id = IDS_FILE_BROWSER_ZIP_FILE_NAME;
      multiple_file_message_id = IDS_FILE_BROWSER_ZIP_ITEMS_REMAINING;
      break;

    case OperationType::kRestoreToDestination:
      single_file_message_id = IDS_FILE_BROWSER_RESTORING_FROM_TRASH_FILE_NAME;
      multiple_file_message_id =
          IDS_FILE_BROWSER_RESTORING_FROM_TRASH_ITEMS_REMAINING;
      break;

    case OperationType::kTrash:
      single_file_message_id = IDS_FILE_BROWSER_MOVE_TO_TRASH_FILE_NAME;
      multiple_file_message_id = IDS_FILE_BROWSER_MOVE_TO_TRASH_ITEMS_REMAINING;
      break;

    case OperationType::kEmptyTrash:
    case OperationType::kRestore:
    default:
      NOTREACHED() << "Unexpected operation type " << status.type;
  }

  if (status.sources.size() > 1) {
    return GetStringFUTF16(multiple_file_message_id,
                           base::NumberToString16(status.sources.size()));
  }

  return GetStringFUTF16(
      single_file_message_id,
      UTF8ToUTF16(GetDisplayablePath(profile, status.sources.back().url)
                      .value_or(base::FilePath())
                      .BaseName()
                      .value()));
}
}  // namespace

std::string GetNotificationId(io_task::IOTaskId task_id) {
  return base::StrCat({kSwaFileOperationPrefix, base::NumberToString(task_id)});
}

NotificationPtr CreateSystemNotification(
    const std::string& notification_id,
    const std::u16string& title,
    const std::u16string& message,
    DelegatePtr delegate,
    message_center::RichNotificationData optional_fields) {
  return ash::CreateSystemNotificationPtr(
      NOTIFICATION_TYPE_SIMPLE, notification_id, title, message,
      GetStringUTF16(IDS_FILEMANAGER_APP_NAME), GURL(), NotifierId(),
      optional_fields, std::move(delegate), ash::kFolderIcon,
      SystemNotificationWarningLevel::NORMAL);
}

NotificationPtr CreateSystemNotification(const std::string& notification_id,
                                         int title_id,
                                         int message_id,
                                         DelegatePtr delegate) {
  return CreateSystemNotification(notification_id, GetStringUTF16(title_id),
                                  GetStringUTF16(message_id),
                                  std::move(delegate));
}

NotificationPtr CreateSystemNotification(
    const std::string& notification_id,
    const std::u16string& title,
    const std::u16string& message,
    const RepeatingClosure& click_callback) {
  return CreateSystemNotification(
      notification_id, title, message,
      MakeRefCounted<HandleNotificationClickDelegate>(click_callback));
}

SystemNotificationManager::SystemNotificationManager(Profile* profile)
    : profile_(profile), app_name_(GetStringUTF16(IDS_FILEMANAGER_APP_NAME)) {}

SystemNotificationManager::~SystemNotificationManager() = default;

bool SystemNotificationManager::DoFilesSwaWindowsExist() {
  return ash::file_manager::FileManagerUI::GetNumInstances() != 0;
}

NotificationPtr SystemNotificationManager::CreateNotification(
    const std::string& notification_id,
    const std::u16string& title,
    const std::u16string& message) {
  return CreateSystemNotification(
      notification_id, title, message,
      BindRepeating(&SystemNotificationManager::Dismiss,
                    weak_ptr_factory_.GetWeakPtr(), notification_id));
}

NotificationPtr SystemNotificationManager::CreateNotification(
    const std::string& notification_id,
    int title_id,
    int message_id) {
  return CreateNotification(notification_id, GetStringUTF16(title_id),
                            GetStringUTF16(message_id));
}

void SystemNotificationManager::HandleProgressClick(
    const std::string& notification_id,
    std::optional<int> button_index) {
  if (button_index) {
    // Cancel the copy operation.
    FileSystemContextPtr file_system_context =
        util::GetFileManagerFileSystemContext(profile_);
    OperationID operation_id;
    if (NotificationIdToOperationId(notification_id, &operation_id)) {
      content::GetIOThreadTaskRunner({})->PostTask(
          FROM_HERE, base::BindOnce(&CancelCopyOnIOThread, file_system_context,
                                    operation_id));
    }
  }
}

NotificationPtr SystemNotificationManager::CreateProgressNotification(
    const std::string& notification_id,
    const std::u16string& title,
    const std::u16string& message,
    int progress) {
  RichNotificationData rich_data;
  rich_data.progress = progress;
  rich_data.progress_status = message;

  return ash::CreateSystemNotificationPtr(
      NOTIFICATION_TYPE_PROGRESS, notification_id, title, message, app_name_,
      GURL(), NotifierId(), rich_data,
      MakeRefCounted<HandleNotificationClickDelegate>(
          BindRepeating(&SystemNotificationManager::HandleProgressClick,
                        weak_ptr_factory_.GetWeakPtr(), notification_id)),
      ash::kFolderIcon, SystemNotificationWarningLevel::NORMAL);
}

NotificationPtr SystemNotificationManager::CreateIOTaskProgressNotification(
    IOTaskId task_id,
    const std::string& notification_id,
    const std::u16string& title,
    const std::u16string& message,
    const bool paused,
    int progress) {
  RichNotificationData rich_data;
  rich_data.progress = progress;
  rich_data.progress_status = message;

  // Button click delegate to handle the state::PAUSED IOTask case, where the
  // user [X] closes this system notification, but did not press its buttons.
  // In that case, default behavior is to auto-click button 1.
  // TODO(b/255264604): ask UX here, which button should be the default?
  class IOTaskProgressNotificationClickDelegate
      : public HandleNotificationClickDelegate {
   public:
    IOTaskProgressNotificationClickDelegate(const ButtonClickCallback& callback,
                                            bool paused)
        : HandleNotificationClickDelegate(callback), paused_(paused) {}

    void Close(bool by_user) override {
      if (paused_ && by_user) {  // Click button at index 1.
        HandleNotificationClickDelegate::Click(1, {});
      }
    }

   protected:
    ~IOTaskProgressNotificationClickDelegate() override = default;

   private:
    bool paused_;  // True if the IOTask is in state::PAUSED.
  };

  auto notification_click_handler = BindRepeating(
      &SystemNotificationManager::HandleIOTaskProgressNotificationClick,
      weak_ptr_factory_.GetWeakPtr(), task_id, notification_id, paused);

  auto notification = ash::CreateSystemNotificationPtr(
      NOTIFICATION_TYPE_PROGRESS, notification_id, title, message, app_name_,
      GURL(), NotifierId(), rich_data,
      MakeRefCounted<IOTaskProgressNotificationClickDelegate>(
          std::move(notification_click_handler), paused),
      ash::kFolderIcon, SystemNotificationWarningLevel::NORMAL);

  std::vector<ButtonInfo> notification_buttons;

  // Add "Cancel" button.
  notification_buttons.emplace_back(
      GetStringUTF16(IDS_FILE_BROWSER_CANCEL_LABEL));

  if (paused) {  // For paused tasks, add "Open Files app" button.
    notification_buttons.emplace_back(
        GetStringUTF16(IDS_REMOVABLE_DEVICE_NAVIGATION_BUTTON_LABEL));
  }

  notification->set_buttons(notification_buttons);
  return notification;
}

void SystemNotificationManager::HandleIOTaskProgressNotificationClick(
    IOTaskId task_id,
    const std::string& notification_id,
    const bool paused,
    std::optional<int> button_index) {
  if (!button_index.has_value()) {
    return;
  }

  if (button_index.value() == 0) {
    CancelTask(task_id);
  }

  if (paused && button_index.value() == 1) {
    platform_util::ShowItemInFolder(
        profile_, file_manager::util::GetMyFilesFolderForProfile(profile_));
    Dismiss(notification_id);
  }
}

void SystemNotificationManager::Dismiss(const std::string& notification_id) {
  GetNotificationDisplayService()->Close(NotificationHandler::Type::TRANSIENT,
                                         notification_id);
}

static const char kDeviceFailNotificationId[] = "swa-device-fail-id";

void SystemNotificationManager::HandleDeviceEvent(
    const fmp::DeviceEvent& event) {
  NotificationPtr notification;
  const std::string id = ToString(event.type);
  switch (event.type) {
    case fmp::DeviceEventType::kDisabled:
      notification =
          CreateNotification(id, IDS_REMOVABLE_DEVICE_DETECTION_TITLE,
                             IDS_EXTERNAL_STORAGE_DISABLED_MESSAGE);
      RecordDeviceNotificationMetric(
          DeviceNotificationUmaType::DEVICE_EXTERNAL_STORAGE_DISABLED);
      break;

    case fmp::DeviceEventType::kRemoved:
      // Hide device fail & storage disabled notifications.
      GetNotificationDisplayService()->Close(
          NotificationHandler::Type::TRANSIENT, kDeviceFailNotificationId);
      GetNotificationDisplayService()->Close(
          NotificationHandler::Type::TRANSIENT,
          ToString(fmp::DeviceEventType::kDisabled));
      // Remove the device from the mount status map.
      mount_status_.erase(event.device_path);
      break;

    case fmp::DeviceEventType::kHardUnplugged:
      notification = CreateNotification(id, IDS_DEVICE_HARD_UNPLUGGED_TITLE,
                                        IDS_DEVICE_HARD_UNPLUGGED_MESSAGE);
      RecordDeviceNotificationMetric(
          DeviceNotificationUmaType::DEVICE_HARD_UNPLUGGED);
      break;

    case fmp::DeviceEventType::kFormatStart:
      notification = CreateNotification(
          id,
          GetStringFUTF16(IDS_FILE_BROWSER_FORMAT_DIALOG_TITLE,
                          UTF8ToUTF16(event.device_label)),
          GetStringFUTF16(IDS_FILE_BROWSER_FORMAT_PROGRESS_MESSAGE,
                          UTF8ToUTF16(event.device_label)));
      RecordDeviceNotificationMetric(DeviceNotificationUmaType::FORMAT_START);
      break;

    case fmp::DeviceEventType::kFormatSuccess:
    case fmp::DeviceEventType::kFormatFail:
    case fmp::DeviceEventType::kPartitionFail: {
      // Hide the formatting notification.
      GetNotificationDisplayService()->Close(
          NotificationHandler::Type::TRANSIENT,
          ToString(fmp::DeviceEventType::kFormatStart));
      std::u16string message;
      if (event.type == fmp::DeviceEventType::kFormatSuccess) {
        message = GetStringFUTF16(IDS_FILE_BROWSER_FORMAT_SUCCESS_MESSAGE,
                                  UTF8ToUTF16(event.device_label));
        RecordDeviceNotificationMetric(
            DeviceNotificationUmaType::FORMAT_SUCCESS);
      } else {
        message = GetStringFUTF16(IDS_FILE_BROWSER_FORMAT_FAILURE_MESSAGE,
                                  UTF8ToUTF16(event.device_label));
        RecordDeviceNotificationMetric(
            event.type == fmp::DeviceEventType::kFormatFail
                ? DeviceNotificationUmaType::FORMAT_FAIL
                : DeviceNotificationUmaType::PARTITION_FAIL);
      }
      notification = CreateNotification(
          id,
          GetStringFUTF16(IDS_FILE_BROWSER_FORMAT_DIALOG_TITLE,
                          UTF8ToUTF16(event.device_label)),
          std::move(message));
      break;
    }

    case fmp::DeviceEventType::kPartitionStart:
    case fmp::DeviceEventType::kPartitionSuccess:
      // No-op.
      break;

    case fmp::DeviceEventType::kRenameFail:
      notification =
          CreateNotification(id, IDS_RENAMING_OF_DEVICE_FAILED_TITLE,
                             IDS_RENAMING_OF_DEVICE_FINISHED_FAILURE_MESSAGE);
      RecordDeviceNotificationMetric(DeviceNotificationUmaType::RENAME_FAIL);
      break;

    case fmp::DeviceEventType::kNone:
    case fmp::DeviceEventType::kRenameStart:
    case fmp::DeviceEventType::kRenameSuccess:
    default:
      VLOG(1) << "No notification for device event " << id;
      break;
  }

  if (notification) {
    GetNotificationDisplayService()->Display(
        NotificationHandler::Type::TRANSIENT, *notification,
        /*metadata=*/nullptr);
  }
}

static const char kBulkPinningNotificationId[] = "drive-bulk-pinning-error";

void SystemNotificationManager::HandleBulkPinningNotificationClick() {
  chrome::SettingsWindowManager::GetInstance()->ShowOSSettings(
      profile_, chromeos::settings::mojom::kGoogleDriveSubpagePath);
  GetNotificationDisplayService()->Close(NotificationHandler::Type::TRANSIENT,
                                         kBulkPinningNotificationId);
}

NotificationPtr SystemNotificationManager::MakeBulkPinningErrorNotification(
    const Event& event) {
  // Parse the event args as a bulk-pinning progress struct.
  DCHECK(!event.event_args.empty());
  auto progress = fmp::BulkPinProgress::FromValue(event.event_args[0]);
  if (!progress) {
    LOG(ERROR) << "Cannot parse BulkPinProgress from " << event.event_args[0];
    return nullptr;
  }

  // Remember the bulk-pinning stage.
  using enum BulkPinStage;
  const BulkPinStage old_stage = bulk_pin_stage_;
  bulk_pin_stage_ = progress->stage;

  if (!progress->should_pin) {
    return nullptr;
  }

  if (old_stage != BulkPinStage::kListingFiles &&
      old_stage != BulkPinStage::kSyncing) {
    return nullptr;
  }

  // Check the bulk-pinning stage.
  switch (bulk_pin_stage_) {
    case BulkPinStage::kNone:
    case BulkPinStage::kStopped:
    case BulkPinStage::kPausedOffline:
    case BulkPinStage::kPausedBatterySaver:
    case BulkPinStage::kGettingFreeSpace:
    case BulkPinStage::kListingFiles:
    case BulkPinStage::kSyncing:
    case BulkPinStage::kSuccess:
      return nullptr;

    case BulkPinStage::kNotEnoughSpace:
    case BulkPinStage::kCannotGetFreeSpace:
    case BulkPinStage::kCannotListFiles:
    case BulkPinStage::kCannotEnableDocsOffline:
      break;
  }

  VLOG(1) << "Creating bulk-pinning error notification";
  int title_id, message_id;

  if (bulk_pin_stage_ == BulkPinStage::kNotEnoughSpace) {
    if (progress->emptied_queue) {
      title_id = IDS_FILE_BROWSER_DRIVE_SYNC_TURNED_OFF_TITLE;
      message_id =
          IDS_FILE_BROWSER_BULK_PINNING_NOT_ENOUGH_SPACE_NOTIFICATION_2;
    } else {
      title_id = IDS_FILE_BROWSER_DRIVE_SYNC_ERROR_TITLE;
      message_id = IDS_FILE_BROWSER_BULK_PINNING_NOT_ENOUGH_SPACE_NOTIFICATION;
    }
  } else {
    title_id = IDS_FILE_BROWSER_DRIVE_SYNC_TURNED_OFF_TITLE;
    message_id = IDS_FILE_BROWSER_BULK_PINNING_ERROR;
  }

  NotificationPtr notification = CreateSystemNotification(
      kBulkPinningNotificationId, GetStringUTF16(title_id),
      GetStringUTF16(message_id),
      BindRepeating(
          &SystemNotificationManager::HandleBulkPinningNotificationClick,
          weak_ptr_factory_.GetWeakPtr()));

  return notification;
}

NotificationPtr SystemNotificationManager::MakeDriveSyncErrorNotification(
    const Event& event) {
  DCHECK(!event.event_args.empty());
  auto sync_error = fmp::DriveSyncErrorEvent::FromValue(event.event_args[0]);
  if (!sync_error) {
    LOG(ERROR) << "Cannot parse DriveSyncErrorEvent from "
               << event.event_args[0];
    return nullptr;
  }

  const std::u16string title =
      GetStringUTF16(IDS_FILE_BROWSER_DRIVE_DIRECTORY_LABEL);
  const std::string id = ToString(sync_error->type);
  const GURL file_url(sync_error->file_url);

  switch (sync_error->type) {
    case fmp::DriveSyncErrorType::kDeleteWithoutPermission:
      return CreateNotification(
          id, title,
          GetStringFUTF16(IDS_FILE_BROWSER_SYNC_DELETE_WITHOUT_PERMISSION_ERROR,
                          util::GetDisplayableFileName16(file_url)));

    case fmp::DriveSyncErrorType::kServiceUnavailable:
      return CreateNotification(
          id, IDS_FILE_BROWSER_DRIVE_DIRECTORY_LABEL,
          IDS_FILE_BROWSER_SYNC_SERVICE_UNAVAILABLE_ERROR);

    case fmp::DriveSyncErrorType::kNoServerSpace:
      return CreateNotification(
          id, title, GetStringUTF16(IDS_FILE_BROWSER_SYNC_NO_SERVER_SPACE));

    case fmp::DriveSyncErrorType::kNoServerSpaceOrganization:
      return CreateNotification(
          id, title,
          GetStringUTF16(IDS_FILE_BROWSER_SYNC_NO_SERVER_SPACE_ORGANIZATION));

    case fmp::DriveSyncErrorType::kNoLocalSpace:
      return CreateNotification(id, IDS_FILE_BROWSER_DRIVE_DIRECTORY_LABEL,
                                IDS_FILE_BROWSER_DRIVE_OUT_OF_SPACE_HEADER);

    case fmp::DriveSyncErrorType::kMisc:
      return CreateNotification(
          id, title,
          GetStringFUTF16(IDS_FILE_BROWSER_SYNC_MISC_ERROR,
                          util::GetDisplayableFileName16(file_url)));

    case fmp::DriveSyncErrorType::kNoSharedDriveSpace:
      if (!sync_error->shared_drive.has_value()) {
        DLOG(WARNING) << "No shared drive provided for error notification";
        return nullptr;
      }

      return CreateNotification(
          id, title,
          GetStringFUTF16(IDS_FILE_BROWSER_SYNC_ERROR_SHARED_DRIVE_OUT_OF_SPACE,
                          UTF8ToUTF16(sync_error->shared_drive.value())));

    case fmp::DriveSyncErrorType::kNone:
      break;
  }

  LOG(ERROR) << "Unexpected Drive sync error: "
             << base::to_underlying(sync_error->type);
  return nullptr;
}

static const char kDriveDialogId[] = "swa-drive-confirm-dialog";

void SystemNotificationManager::HandleDriveDialogClick(
    std::optional<int> button_index) {
  drivefs::mojom::DialogResult result = drivefs::mojom::DialogResult::kDismiss;
  if (button_index) {
    if (button_index.value() == 1) {
      result = drivefs::mojom::DialogResult::kAccept;
    } else {
      result = drivefs::mojom::DialogResult::kReject;
    }
  }
  // Send the dialog result to the callback stored in DriveFS on dialog
  // creation.
  if (drivefs_event_router_) {
    drivefs_event_router_->OnDialogResult(result);
  }
  GetNotificationDisplayService()->Close(NotificationHandler::Type::TRANSIENT,
                                         kDriveDialogId);
}

NotificationPtr SystemNotificationManager::MakeDriveConfirmDialogNotification(
    const Event& event) {
  DCHECK(!event.event_args.empty());
  auto dialog_event =
      fmp::DriveConfirmDialogEvent::FromValue(event.event_args[0]);
  if (!dialog_event) {
    LOG(ERROR) << "Cannot parse DriveConfirmDialogEvent from "
               << event.event_args[0];
    return nullptr;
  }

  NotificationPtr notification = CreateSystemNotification(
      kDriveDialogId, IDS_FILE_BROWSER_DRIVE_DIRECTORY_LABEL,
      IDS_FILE_BROWSER_OFFLINE_ENABLE_MESSAGE,
      MakeRefCounted<HandleNotificationClickDelegate>(
          BindRepeating(&SystemNotificationManager::HandleDriveDialogClick,
                        weak_ptr_factory_.GetWeakPtr())));

  std::vector<ButtonInfo> buttons;
  buttons.emplace_back(GetStringUTF16(IDS_FILE_BROWSER_OFFLINE_ENABLE_REJECT));
  buttons.emplace_back(GetStringUTF16(IDS_FILE_BROWSER_OFFLINE_ENABLE_ACCEPT));
  notification->set_buttons(buttons);

  return notification;
}

void SystemNotificationManager::HandleEvent(const Event& event) {
  if (event.event_args.empty()) {
    DLOG(WARNING) << "Ignored empty Event {name: " << event.event_name
                  << ", histogram_value: " << event.histogram_value << "}";
    return;
  }

  // For some events we always display a system notification regardless of if
  // there are any SWA windows open.
  bool force_as_system_notification = false;
  NotificationPtr notification;
  switch (event.histogram_value) {
    case FILE_MANAGER_PRIVATE_ON_DRIVE_SYNC_ERROR:
      notification = MakeDriveSyncErrorNotification(event);
      break;

    case FILE_MANAGER_PRIVATE_ON_DRIVE_CONFIRM_DIALOG:
      notification = MakeDriveConfirmDialogNotification(event);
      force_as_system_notification = true;
      break;

    case FILE_MANAGER_PRIVATE_ON_BULK_PIN_PROGRESS:
      notification = MakeBulkPinningErrorNotification(event);
      force_as_system_notification = true;
      break;

    default:
      VLOG(1) << "Ignored Event {name: " << event.event_name
              << ", histogram_value: " << event.histogram_value
              << ", args: " << event.event_args << "}";
      return;
  }

  if (!notification) {
    return;
  }

  // Check if we need to remove any progress notification when there
  // are active SWA windows.
  if (!force_as_system_notification && DoFilesSwaWindowsExist()) {
    GetNotificationDisplayService()->Close(NotificationHandler::Type::TRANSIENT,
                                           notification->id());
    return;
  }

  GetNotificationDisplayService()->Display(NotificationHandler::Type::TRANSIENT,
                                           *notification, nullptr);
}

void SystemNotificationManager::HandleIOTaskProgress(
    const ProgressStatus& status) {
  std::string id = GetNotificationId(status.task_id);

  // If there are any SWA windows open, remove the IOTask progress from system
  // notifications.
  if (!status.show_notification || DoFilesSwaWindowsExist()) {
    Dismiss(id);
    return;
  }

  // If there's a warning or security error, show a data protection
  // notification.
  if (status.HasWarning() || status.HasPolicyError()) {
    policy::FilesPolicyNotificationManager* manager =
        policy::FilesPolicyNotificationManagerFactory::GetForBrowserContext(
            profile_);
    if (!manager) {
      LOG(ERROR) << "No FilesPolicyNotificationManager instantiated,"
                    "can't show policy dialog for task_id "
                 << status.task_id;
      return;
    }
    Dismiss(id);
    manager->ShowFilesPolicyNotification(id, status);
    return;
  }

  // If the task is currently in the scanning state, show a data protection
  // progress notification.
  if (status.IsScanning()) {
    Dismiss(id);
    NotificationPtr notification =
        MakeDataProtectionPolicyProgressNotification(id, status);
    GetNotificationDisplayService()->Display(
        NotificationHandler::Type::TRANSIENT, *notification,
        /*metadata=*/nullptr);
    return;
  }

  // If the IOTask state has completed, remove the IOTask progress from system
  // notifications.
  if (status.IsCompleted()) {
    Dismiss(id);
    return;
  }

  // From here state is kQueued, kInProgress, or kPaused.
  const bool paused = status.IsPaused();

  std::u16string title;
  std::u16string message;
  if (!paused) {
    title = app_name_;
    message = GetIOTaskMessage(profile_, status);
  } else {
    title = GetIOTaskMessage(profile_, status);
    int message_id = IDS_FILE_BROWSER_CONFLICT_DIALOG_MESSAGE;
    if (status.pause_params.conflict_params.has_value() &&
        status.pause_params.conflict_params->conflict_is_directory) {
      message_id = IDS_FILE_BROWSER_CONFLICT_DIALOG_FOLDER_MESSAGE;
    }
    auto& item_name = status.pause_params.conflict_params->conflict_name;
    message = GetStringFUTF16(message_id, UTF8ToUTF16(item_name));
  }

  int progress = 0;
  if (status.total_bytes > 0) {
    progress = status.bytes_transferred * 100.0 / status.total_bytes;
  }

  NotificationPtr notification = CreateIOTaskProgressNotification(
      status.task_id, id, title, message, paused, progress);

  GetNotificationDisplayService()->Display(NotificationHandler::Type::TRANSIENT,
                                           *notification,
                                           /*metadata=*/nullptr);
}

constexpr char kRemovableNotificationId[] = "swa-removable-device-id";

void SystemNotificationManager::HandleRemovableNotificationClick(
    const std::string& path,
    const std::vector<DeviceNotificationUserActionUmaType>&
        uma_types_for_buttons,
    std::optional<int> button_index) {
  if (button_index) {
    if (button_index.value() == 0) {
      base::FilePath volume_root(path);
      platform_util::ShowItemInFolder(profile_, volume_root);
    } else {
      chrome::SettingsWindowManager::GetInstance()->ShowOSSettings(
          profile_, chromeos::settings::mojom::kExternalStorageSubpagePath);
    }
    if (base::checked_cast<size_t>(button_index.value()) <
        uma_types_for_buttons.size()) {
      RecordDeviceNotificationUserActionMetric(
          uma_types_for_buttons.at(button_index.value()));
    }
  }

  GetNotificationDisplayService()->Close(NotificationHandler::Type::TRANSIENT,
                                         kRemovableNotificationId);
}

void SystemNotificationManager::HandleDataProtectionPolicyNotificationClick(
    RepeatingClosure proceed_callback,
    RepeatingClosure cancel_callback,
    std::optional<int> button_index) {
  if (!button_index.has_value()) {
    return;
  }

  if (button_index.value() == 0) {
    proceed_callback.Run();
  }

  if (button_index.value() == 1 && cancel_callback) {
    cancel_callback.Run();
  }
}

NotificationPtr SystemNotificationManager::MakeMountErrorNotification(
    MountCompletedEvent& event,
    const Volume& volume) {
  const auto it = mount_status_.find(volume.storage_device_path().value());
  if (it == mount_status_.end()) {
    return nullptr;
  }

  const std::u16string title =
      GetStringUTF16(IDS_REMOVABLE_DEVICE_DETECTION_TITLE);
  std::u16string message;
  std::vector<ButtonInfo> buttons;
  std::vector<DeviceNotificationUserActionUmaType> uma_types_for_buttons;
  switch (it->second) {
    // We have either an unsupported or unknown filesystem on the mount.
    case MOUNT_STATUS_ONLY_PARENT_ERROR:
    case MOUNT_STATUS_CHILD_ERROR:
      if (event.status == fmp::MountError::kUnsupportedFilesystem) {
        if (volume.drive_label().empty()) {
          message = GetStringUTF16(IDS_DEVICE_UNSUPPORTED_DEFAULT_MESSAGE);
        } else {
          message = GetStringFUTF16(IDS_DEVICE_UNSUPPORTED_MESSAGE,
                                    UTF8ToUTF16(volume.drive_label()));
        }
        RecordDeviceNotificationMetric(DeviceNotificationUmaType::DEVICE_FAIL);
      } else {
        if (volume.drive_label().empty()) {
          message = GetStringUTF16(IDS_DEVICE_UNKNOWN_DEFAULT_MESSAGE);
        } else {
          message = GetStringFUTF16(IDS_DEVICE_UNKNOWN_MESSAGE,
                                    UTF8ToUTF16(volume.drive_label()));
        }

        if (!volume.is_read_only()) {
          // Give a format device button on the notification.
          buttons.emplace_back(GetStringUTF16(IDS_DEVICE_UNKNOWN_BUTTON_LABEL));
          uma_types_for_buttons.push_back(
              DeviceNotificationUserActionUmaType::OPEN_MEDIA_DEVICE_FAIL);
          RecordDeviceNotificationMetric(
              DeviceNotificationUmaType::DEVICE_FAIL_UNKNOWN);
        } else {
          RecordDeviceNotificationMetric(
              DeviceNotificationUmaType::DEVICE_FAIL_UNKNOWN_READONLY);
        }
      }
      break;

    // We have a multi-partition device for which at least one mount
    // failed.
    case MOUNT_STATUS_MULTIPART_ERROR:
      if (volume.drive_label().empty()) {
        message =
            GetStringUTF16(IDS_MULTIPART_DEVICE_UNSUPPORTED_DEFAULT_MESSAGE);
      } else {
        message = GetStringFUTF16(IDS_MULTIPART_DEVICE_UNSUPPORTED_MESSAGE,
                                  UTF8ToUTF16(volume.drive_label()));
      }
      RecordDeviceNotificationMetric(DeviceNotificationUmaType::DEVICE_FAIL);
      break;

    case MOUNT_STATUS_NO_RESULT:
    case MOUNT_STATUS_SUCCESS:
    default:
      VLOG(1) << "Unhandled mount status " << it->second;
      return nullptr;
  }

  NotificationPtr notification = CreateSystemNotification(
      kDeviceFailNotificationId, title, message,
      MakeRefCounted<HandleNotificationClickDelegate>(BindRepeating(
          &SystemNotificationManager::HandleRemovableNotificationClick,
          weak_ptr_factory_.GetWeakPtr(), volume.mount_path().value(),
          uma_types_for_buttons)));

  DCHECK_EQ(buttons.size(), uma_types_for_buttons.size());
  notification->set_buttons(buttons);

  return notification;
}

SystemNotificationManagerMountStatus
SystemNotificationManager::UpdateDeviceMountStatus(MountCompletedEvent& event,
                                                   const Volume& volume) {
  SystemNotificationManagerMountStatus status = MOUNT_STATUS_NO_RESULT;
  const std::string& device_path = volume.storage_device_path().value();
  auto device_mount_status = mount_status_.find(device_path);
  if (device_mount_status == mount_status_.end()) {
    status = MOUNT_STATUS_NO_RESULT;
  } else {
    status = device_mount_status->second;
  }
  switch (status) {
    case MOUNT_STATUS_MULTIPART_ERROR:
      // Do nothing, status has already been detected.
      break;
    case MOUNT_STATUS_ONLY_PARENT_ERROR:
      if (!volume.is_parent()) {
        // Hide Device Fail notification.
        GetNotificationDisplayService()->Close(
            NotificationHandler::Type::TRANSIENT, kDeviceFailNotificationId);
      }
      [[fallthrough]];
    case MOUNT_STATUS_NO_RESULT:
      if (event.status == fmp::MountError::kSuccess) {
        status = MOUNT_STATUS_SUCCESS;
      } else if (event.volume_metadata.is_parent_device) {
        status = MOUNT_STATUS_ONLY_PARENT_ERROR;
      } else {
        status = MOUNT_STATUS_CHILD_ERROR;
      }
      break;
    case MOUNT_STATUS_SUCCESS:
    case MOUNT_STATUS_CHILD_ERROR:
      if (status == MOUNT_STATUS_SUCCESS &&
          event.status == fmp::MountError::kSuccess) {
        status = MOUNT_STATUS_SUCCESS;
      } else {
        // Multi partition device with at least one partition in error.
        status = MOUNT_STATUS_MULTIPART_ERROR;
      }
      break;
  }
  mount_status_[device_path] = status;

  return status;
}

NotificationPtr SystemNotificationManager::MakeRemovableNotification(
    MountCompletedEvent& event,
    const Volume& volume) {
  NotificationPtr notification;
  if (event.status == fmp::MountError::kSuccess) {
    bool show_settings_button = false;
    std::u16string title = GetStringUTF16(IDS_REMOVABLE_DEVICE_DETECTION_TITLE);
    std::u16string message;
    std::vector<DeviceNotificationUserActionUmaType> uma_types_for_buttons;
    if (volume.is_read_only() && !volume.is_read_only_removable_device()) {
      message = GetStringUTF16(
          IDS_REMOVABLE_DEVICE_NAVIGATION_MESSAGE_READONLY_POLICY);
      RecordDeviceNotificationMetric(
          DeviceNotificationUmaType::DEVICE_NAVIGATION_READONLY_POLICY);
      uma_types_for_buttons.push_back(
          DeviceNotificationUserActionUmaType::OPEN_MEDIA_DEVICE_NAVIGATION);
    } else {
      const PrefService* const service = profile_->GetPrefs();
      DCHECK(service);
      bool arc_enabled = service->GetBoolean(arc::prefs::kArcEnabled);
      bool arc_removable_media_access_enabled =
          service->GetBoolean(arc::prefs::kArcHasAccessToRemovableMedia);
      if (!arc_enabled) {
        message = GetStringUTF16(IDS_REMOVABLE_DEVICE_NAVIGATION_MESSAGE);
        RecordDeviceNotificationMetric(
            DeviceNotificationUmaType::DEVICE_NAVIGATION);
        uma_types_for_buttons.push_back(
            DeviceNotificationUserActionUmaType::OPEN_MEDIA_DEVICE_NAVIGATION);
      } else if (arc_removable_media_access_enabled) {
        message = base::StrCat(
            {GetStringUTF16(IDS_REMOVABLE_DEVICE_NAVIGATION_MESSAGE), u" ",
             GetStringUTF16(
                 IDS_REMOVABLE_DEVICE_PLAY_STORE_APPS_HAVE_ACCESS_MESSAGE)});
        show_settings_button = true;
        RecordDeviceNotificationMetric(
            DeviceNotificationUmaType::DEVICE_NAVIGATION_APPS_HAVE_ACCESS);
        uma_types_for_buttons.insert(uma_types_for_buttons.end(),
                                     {DeviceNotificationUserActionUmaType::
                                          OPEN_MEDIA_DEVICE_NAVIGATION_ARC,
                                      DeviceNotificationUserActionUmaType::
                                          OPEN_SETTINGS_FOR_ARC_STORAGE});
      } else {
        message = base::StrCat(
            {GetStringUTF16(IDS_REMOVABLE_DEVICE_NAVIGATION_MESSAGE), u" ",
             GetStringUTF16(
                 IDS_REMOVABLE_DEVICE_ALLOW_PLAY_STORE_ACCESS_MESSAGE)});
        show_settings_button = true;
        RecordDeviceNotificationMetric(
            DeviceNotificationUmaType::DEVICE_NAVIGATION_ALLOW_APP_ACCESS);
        uma_types_for_buttons.insert(uma_types_for_buttons.end(),
                                     {DeviceNotificationUserActionUmaType::
                                          OPEN_MEDIA_DEVICE_NAVIGATION_ARC,
                                      DeviceNotificationUserActionUmaType::
                                          OPEN_SETTINGS_FOR_ARC_STORAGE});
      }
    }

    notification = CreateSystemNotification(
        kRemovableNotificationId, title, message,
        MakeRefCounted<HandleNotificationClickDelegate>(BindRepeating(
            &SystemNotificationManager::HandleRemovableNotificationClick,
            weak_ptr_factory_.GetWeakPtr(), volume.mount_path().value(),
            uma_types_for_buttons)));
    std::vector<ButtonInfo> notification_buttons;
    notification_buttons.emplace_back(
        GetStringUTF16(IDS_REMOVABLE_DEVICE_NAVIGATION_BUTTON_LABEL));
    if (show_settings_button) {
      notification_buttons.emplace_back(
          GetStringUTF16(IDS_REMOVABLE_DEVICE_OPEN_SETTTINGS_BUTTON_LABEL));
    }
    DCHECK_EQ(notification_buttons.size(), uma_types_for_buttons.size());
    notification->set_buttons(notification_buttons);
  }
  if (volume.device_type() != ash::DeviceType::kUnknown &&
      !volume.storage_device_path().empty()) {
    if (UpdateDeviceMountStatus(event, volume) != MOUNT_STATUS_SUCCESS) {
      notification = MakeMountErrorNotification(event, volume);
    }
  }

  return notification;
}

NotificationPtr
SystemNotificationManager::MakeDataProtectionPolicyProgressNotification(
    const std::string& notification_id,
    const ProgressStatus& status) {
  std::u16string message =
      status.sources.size() > 1
          ? GetStringUTF16(IDS_FILE_BROWSER_SCANNING_LABEL_PLURAL)
          : GetStringUTF16(IDS_FILE_BROWSER_SCANNING_LABEL);
  int progress = status.sources_scanned * 100.0 / status.sources.size();
  return CreateIOTaskProgressNotification(status.task_id, notification_id,
                                          app_name_, message, /*paused=*/false,
                                          progress);
}

void SystemNotificationManager::ShowDataProtectionPolicyDialog(
    IOTaskId task_id,
    policy::FilesDialogType type) {
  policy::FilesPolicyNotificationManager* manager =
      policy::FilesPolicyNotificationManagerFactory::GetForBrowserContext(
          profile_);
  if (!manager) {
    LOG(ERROR) << "No FilesPolicyNotificationManager instantiated,"
                  "can't show policy dialog for task_id "
               << task_id;
    return;
  }
  manager->ShowDialog(task_id, type);
}

void SystemNotificationManager::CancelTask(IOTaskId task_id) {
  if (io_task_controller_) {
    io_task_controller_->Cancel(task_id);
  } else {
    LOG(ERROR) << "No TaskController, can't cancel task_id: " << task_id;
  }
}

void SystemNotificationManager::ResumeTask(IOTaskId task_id,
                                           policy::Policy policy) {
  if (io_task_controller_) {
    io_task::ResumeParams params;
    params.policy_params->type = policy;
    io_task_controller_->Resume(task_id, std::move(params));
  } else {
    LOG(ERROR) << "No TaskController, can't resume task_id: " << task_id;
  }
}

void SystemNotificationManager::HandleMountCompletedEvent(
    MountCompletedEvent& event,
    const Volume& volume) {
  NotificationPtr notification;

  switch (event.event_type) {
    case fmp::MountCompletedEventType::kMount:
      if (event.should_notify) {
        notification = MakeRemovableNotification(event, volume);
      }
      break;

    case fmp::MountCompletedEventType::kUnmount:
      GetNotificationDisplayService()->Close(
          NotificationHandler::Type::TRANSIENT, kRemovableNotificationId);

      if (volume.device_type() != ash::DeviceType::kUnknown &&
          !volume.storage_device_path().empty()) {
        UpdateDeviceMountStatus(event, volume);
      }
      break;

    case fmp::MountCompletedEventType::kNone:
    default:
      VLOG(1) << "Unexpected mount event "
              << base::to_underlying(event.event_type);
      break;
  }

  if (notification) {
    GetNotificationDisplayService()->Display(
        NotificationHandler::Type::TRANSIENT, *notification,
        /*metadata=*/nullptr);
  }
}

NotificationDisplayService*
SystemNotificationManager::GetNotificationDisplayService() {
  return NotificationDisplayServiceFactory::GetForProfile(profile_);
}

void SystemNotificationManager::SetDriveFSEventRouter(
    DriveFsEventRouter* drivefs_event_router) {
  drivefs_event_router_ = drivefs_event_router;
}

void SystemNotificationManager::SetIOTaskController(
    IOTaskController* io_task_controller) {
  io_task_controller_ = io_task_controller;
}

}  // namespace file_manager