// Copyright 2023 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/policy/dlp/files_policy_notification_manager.h"

#include <cstddef>
#include <memory>
#include <optional>
#include <string>

#include "base/check.h"
#include "base/check_is_test.h"
#include "base/containers/contains.h"
#include "base/files/file_path.h"
#include "base/functional/bind.h"
#include "base/functional/callback_forward.h"
#include "base/memory/scoped_refptr.h"
#include "base/notreached.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_util.h"
#include "base/types/optional_util.h"
#include "chrome/browser/ash/browser_delegate/browser_delegate.h"
#include "chrome/browser/ash/extensions/file_manager/system_notification_manager.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/url_util.h"
#include "chrome/browser/ash/file_manager/volume_manager.h"
#include "chrome/browser/ash/policy/dlp/dialogs/files_policy_dialog.h"
#include "chrome/browser/ash/policy/dlp/files_policy_string_util.h"
#include "chrome/browser/chromeos/policy/dlp/dialogs/policy_dialog_base.h"
#include "chrome/browser/chromeos/policy/dlp/dlp_confidential_file.h"
#include "chrome/browser/chromeos/policy/dlp/dlp_file_destination.h"
#include "chrome/browser/chromeos/policy/dlp/dlp_files_utils.h"
#include "chrome/browser/notifications/notification_display_service.h"
#include "chrome/browser/notifications/notification_display_service_factory.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/ui/ash/system_web_apps/system_web_app_ui_utils.h"
#include "chrome/browser/ui/browser_list.h"
#include "chrome/browser/ui/browser_window.h"
#include "chrome/common/chrome_features.h"
#include "components/enterprise/data_controls/core/browser/dlp_histogram_helper.h"
#include "components/strings/grit/components_strings.h"
#include "content/public/browser/browser_context.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/message_center/public/cpp/notification.h"
#include "ui/message_center/public/cpp/notification_delegate.h"

namespace policy {

namespace {
// How long to wait for a Files App to open before falling back to a system
// modal.
const base::TimeDelta kOpenFilesAppTimeout = base::Milliseconds(3000);

// Warning time out is 5 mins.
const base::TimeDelta kWarningTimeout = base::Minutes(5);

constexpr char kDlpFilesNotificationId[] = "dlp_files";

std::u16string GetNotificationTitle(NotificationType type,
                                    dlp::FileAction action,
                                    std::optional<size_t> file_count) {
  switch (type) {
    case NotificationType::kError:
      CHECK(file_count.has_value());
      return policy::files_string_util::GetBlockTitle(action,
                                                      file_count.value());
    case NotificationType::kWarning:
      return policy::files_string_util::GetWarnTitle(action);
  }
}

// Returns the message for notification of `type` and with `file_count`
// blocked/warned files. `first_file` is the name of the first restricted file
// and is only used for single file notifications. `reason` is the block reason
// of the first restricted file and is only used for single file block
// notifications.
std::u16string GetNotificationMessage(
    NotificationType type,
    size_t file_count,
    const std::u16string& first_file,
    std::optional<FilesPolicyDialog::BlockReason> reason) {
  switch (type) {
    case NotificationType::kError:
      CHECK(reason.has_value());
      return file_count > 1
                 ? l10n_util::GetStringUTF16(IDS_POLICY_DLP_FILES_BLOCK_MESSAGE)
                 : policy::files_string_util::GetBlockReasonMessage(
                       reason.value(), first_file);
    case NotificationType::kWarning:
      const std::u16string placeholder_value =
          file_count == 1 ? first_file : base::NumberToString16(file_count);
      return base::ReplaceStringPlaceholders(
          l10n_util::GetPluralStringFUTF16(IDS_POLICY_DLP_FILES_WARN_MESSAGE,
                                           file_count),
          placeholder_value,
          /*offset=*/nullptr);
  }
}

std::u16string GetOkButton(NotificationType type,
                           dlp::FileAction action,
                           size_t file_count,
                           bool always_show_review) {
  // Multiple files or custom dialog settings - both warnings and errors have a
  // Review button.
  if (file_count > 1 || always_show_review) {
    return l10n_util::GetStringUTF16(IDS_POLICY_DLP_FILES_REVIEW_BUTTON);
  }
  // Single file and no admin defined custom dialog settings - button text
  // depends on the type.
  switch (type) {
    case NotificationType::kError:
      return l10n_util::GetStringUTF16(IDS_LEARN_MORE);
    case NotificationType::kWarning:
      return policy::files_string_util::GetContinueAnywayButton(action);
  }
}

std::u16string GetCancelButton(NotificationType type) {
  switch (type) {
    case NotificationType::kError:
      return l10n_util::GetStringUTF16(IDS_POLICY_DLP_FILES_DISMISS_BUTTON);
    case NotificationType::kWarning:
      return l10n_util::GetStringUTF16(IDS_POLICY_DLP_WARN_CANCEL_BUTTON);
  }
}

std::u16string GetTimeoutNotificationTitle(dlp::FileAction action) {
  switch (action) {
    case dlp::FileAction::kDownload:
      return l10n_util::GetStringUTF16(
          IDS_POLICY_DLP_FILES_DOWNLOAD_TIMEOUT_TITLE);
    case dlp::FileAction::kTransfer:
    case dlp::FileAction::kUnknown:
      // kUnknown is used for internal checks - treat as kTransfer.
      return l10n_util::GetStringUTF16(
          IDS_POLICY_DLP_FILES_TRANSFER_TIMEOUT_TITLE);
    case dlp::FileAction::kUpload:
      return l10n_util::GetStringUTF16(
          IDS_POLICY_DLP_FILES_UPLOAD_TIMEOUT_TITLE);
    case dlp::FileAction::kCopy:
      return l10n_util::GetStringUTF16(IDS_POLICY_DLP_FILES_COPY_TIMEOUT_TITLE);
    case dlp::FileAction::kMove:
      return l10n_util::GetStringUTF16(IDS_POLICY_DLP_FILES_MOVE_TIMEOUT_TITLE);
    case dlp::FileAction::kOpen:
    case dlp::FileAction::kShare:
      return l10n_util::GetStringUTF16(IDS_POLICY_DLP_FILES_OPEN_TIMEOUT_TITLE);
  }
}

std::u16string GetTimeoutNotificationMessage(dlp::FileAction action) {
  switch (action) {
    case dlp::FileAction::kDownload:
      return l10n_util::GetStringUTF16(
          IDS_POLICY_DLP_FILES_DOWNLOAD_TIMEOUT_MESSAGE);
    case dlp::FileAction::kTransfer:
    case dlp::FileAction::kUnknown:
      // kUnknown is used for internal checks - treat as kTransfer.
      return l10n_util::GetStringUTF16(
          IDS_POLICY_DLP_FILES_TRANSFER_TIMEOUT_MESSAGE);
    case dlp::FileAction::kUpload:
      return l10n_util::GetStringUTF16(
          IDS_POLICY_DLP_FILES_UPLOAD_TIMEOUT_MESSAGE);
    case dlp::FileAction::kCopy:
      return l10n_util::GetStringUTF16(
          IDS_POLICY_DLP_FILES_COPY_TIMEOUT_MESSAGE);
    case dlp::FileAction::kMove:
      return l10n_util::GetStringUTF16(
          IDS_POLICY_DLP_FILES_MOVE_TIMEOUT_MESSAGE);
    case dlp::FileAction::kOpen:
    case dlp::FileAction::kShare:
      return l10n_util::GetStringUTF16(
          IDS_POLICY_DLP_FILES_OPEN_TIMEOUT_MESSAGE);
  }
}

// Dismisses the notification with `notification_id`.
void Dismiss(content::BrowserContext* context,
             const std::string& notification_id) {
  auto* profile = Profile::FromBrowserContext(context);
  DCHECK(profile);
  NotificationDisplayServiceFactory::GetForProfile(profile)->Close(
      NotificationHandler::Type::TRANSIENT, notification_id);
}

file_manager::io_task::IOTaskController* GetIOTaskController(
    content::BrowserContext* context) {
  DCHECK(context);
  file_manager::VolumeManager* const volume_manager =
      file_manager::VolumeManager::Get(Profile::FromBrowserContext(context));
  if (!volume_manager) {
    LOG(ERROR) << "FilesPolicyNotificationManager failed to find "
                  "file_manager::VolumeManager";
    return nullptr;
  }
  return volume_manager->io_task_controller();
}

// Computes and returns a new notification ID by appending `count` to the
// prefix.
std::string GetNotificationId(size_t count) {
  return kDlpFilesNotificationId + std::string("_") +
         base::NumberToString(count);
}

// Returns whether custom dialog settings have been defined for at least one
// block reason.
bool HasCustomDialogSettings(
    const std::map<FilesPolicyDialog::BlockReason, FilesPolicyDialog::Info>&
        dialog_info_map) {
  for (const auto& [_, dialog_info] : dialog_info_map) {
    if (dialog_info.HasCustomDetails()) {
      return true;
    }
  }
  return false;
}

// Notification click handler implementation for files policy notifications.
// The handler ensures that we only handle the button click once. This is
// required because some of the parameters are move-only types and wouldn't be
// valid on the second invocation.
class PolicyNotificationClickHandler
    : public message_center::NotificationDelegate {
 public:
  explicit PolicyNotificationClickHandler(
      base::OnceCallback<void(std::optional<int>)> callback)
      : callback_(std::move(callback)) {}

  void Close(bool by_user) override {
    // Treat any close reason as the user clicking the Cancel button.
    Click(NotificationButton::CANCEL, /*reply=*/std::nullopt);
  }

  // message_center::NotificationDelegate overrides:
  void Click(const std::optional<int>& button_index,
             const std::optional<std::u16string>& reply) override {
    if (!button_index.has_value()) {
      // Ignore clicks on the notification, but not on the buttons.
      return;
    }

    // The callback might have already been invoked earlier, so check first.
    if (callback_) {
      std::move(callback_).Run(button_index);
    }
  }

 private:
  ~PolicyNotificationClickHandler() override = default;

  base::OnceCallback<void(std::optional<int>)> callback_;
};

}  // namespace

FilesPolicyNotificationManager::FilesPolicyNotificationManager(
    content::BrowserContext* context)
    : context_(context),
      task_runner_(base::SequencedTaskRunner::GetCurrentDefault()) {
  DCHECK(context);

  auto* io_task_controller = GetIOTaskController(context_);
  if (!io_task_controller) {
    LOG(ERROR) << "FilesPolicyNotificationManager failed to find "
                  "file_manager::io_task::IOTaskController";
    return;
  }
  io_task_controller->AddObserver(this);
}

FilesPolicyNotificationManager::~FilesPolicyNotificationManager() = default;

void FilesPolicyNotificationManager::Shutdown() {
  file_manager::VolumeManager* const volume_manager =
      file_manager::VolumeManager::Get(Profile::FromBrowserContext(context_));
  if (volume_manager) {
    auto* io_task_controller = volume_manager->io_task_controller();
    if (io_task_controller) {
      io_task_controller->RemoveObserver(this);
    }
  }
}

void FilesPolicyNotificationManager::ShowDlpBlockedFiles(
    std::optional<file_manager::io_task::IOTaskId> task_id,
    std::vector<base::FilePath> blocked_files,
    dlp::FileAction action) {
  data_controls::DlpHistogramEnumeration(
      data_controls::dlp::kFileActionBlockedUMA, action);
  data_controls::DlpCountHistogram10000(
      data_controls::dlp::kFilesBlockedCountUMA, blocked_files.size());

  // If `task_id` has value, the corresponding IOTask should be updated
  // accordingly.
  if (task_id.has_value()) {
    // Sometimes DLP checks are done before FilesPolicyNotificationManager is
    // lazily created, so the task is not tracked and the blocked files won't
    // be added. On the other hand, the IO task may be aborted/canceled
    // already so the info saved may be not needed anymore.
    if (!HasIOTask(task_id.value())) {
      AddIOTask(task_id.value(), action);
    }
    io_tasks_.at(task_id.value())
        .SetBlockedFiles(
            FilesPolicyDialog::BlockReason::kDlp,
            FilesPolicyDialog::Info::Error(FilesPolicyDialog::BlockReason::kDlp,
                                           blocked_files));
  } else {
    ShowDlpBlockNotification(std::move(blocked_files), action);
  }
}

void FilesPolicyNotificationManager::SetConnectorsBlockedFiles(
    file_manager::io_task::IOTaskId task_id,
    dlp::FileAction action,
    FilesPolicyDialog::BlockReason reason,
    FilesPolicyDialog::Info dialog_info) {
  // Sometimes EC checks are done before FilesPolicyNotificationManager is
  // lazily created, so the task is not tracked and the blocked files won't
  // be added. On the other hand, the IOTask may be aborted/canceled already so
  // the info saved may be not needed anymore.
  if (!HasIOTask(task_id)) {
    AddIOTask(task_id, action);
  }
  io_tasks_.at(task_id).SetBlockedFiles(reason, std::move(dialog_info));
}

void FilesPolicyNotificationManager::ShowDlpWarning(
    WarningWithJustificationCallback callback,
    std::optional<file_manager::io_task::IOTaskId> task_id,
    std::vector<base::FilePath> warning_files,
    const DlpFileDestination& destination,
    dlp::FileAction action) {
  data_controls::DlpHistogramEnumeration(
      data_controls::dlp::kFileActionWarnedUMA, action);
  data_controls::DlpCountHistogram10000(
      data_controls::dlp::kFilesWarnedCountUMA, warning_files.size());

  // If `task_id` has value, the corresponding IOTask should be paused.
  if (task_id.has_value()) {
    PauseIOTask(task_id.value(), std::move(callback), action, Policy::kDlp,
                FilesPolicyDialog::Info::Warn(
                    FilesPolicyDialog::BlockReason::kDlp, warning_files));
  } else {
    ShowDlpWarningNotification(std::move(callback), std::move(warning_files),
                               destination, action);
  }
}

void FilesPolicyNotificationManager::ShowConnectorsWarning(
    WarningWithJustificationCallback callback,
    file_manager::io_task::IOTaskId task_id,
    dlp::FileAction action,
    FilesPolicyDialog::Info dialog_info) {
  PauseIOTask(task_id, std::move(callback), action,
              Policy::kEnterpriseConnectors, std::move(dialog_info));
}

void FilesPolicyNotificationManager::ShowFilesPolicyNotification(
    const std::string& notification_id,
    const file_manager::io_task::ProgressStatus& status) {
  const file_manager::io_task::IOTaskId id(status.task_id);
  const dlp::FileAction action =
      status.type == file_manager::io_task::OperationType::kCopy
          ? dlp::FileAction::kCopy
          : dlp::FileAction::kMove;
  if (status.HasPolicyError() &&
      status.policy_error->type ==
          file_manager::io_task::PolicyErrorType::kDlpWarningTimeout) {
    ShowDlpWarningTimeoutNotification(action, notification_id);
    return;
  }
  // Only show the notification if we have either warning or blocked files.
  if (HasWarning(id) || HasBlockedFiles(id)) {
    ShowFilesPolicyNotification(notification_id, status.task_id);
  }
}

void FilesPolicyNotificationManager::ShowDialog(
    file_manager::io_task::IOTaskId task_id,
    FilesDialogType type) {
  auto* profile = Profile::FromBrowserContext(context_);
  DCHECK(profile);

  // Get the last active Files app window.
  ash::BrowserDelegate* browser = FindSystemWebAppBrowser(
      profile, ash::SystemWebAppType::FILE_MANAGER, ash::BrowserType::kApp);
  gfx::NativeWindow modal_parent =
      browser ? browser->GetNativeWindow() : nullptr;
  if (modal_parent) {
    ShowDialogForIOTask(task_id, type, modal_parent);
    return;
  }

  // No window found, so open a new one. This should notify us through
  // OnBrowserSetLastActive() to show the dialog.
  LaunchFilesApp(std::make_unique<DialogInfo>(
      base::BindOnce(&FilesPolicyNotificationManager::ShowDialogForIOTask,
                     weak_factory_.GetWeakPtr(), task_id, type),
      task_id,
      base::BindOnce(&FilesPolicyNotificationManager::OnIOTaskAppLaunchTimedOut,
                     weak_factory_.GetWeakPtr(), task_id)));
}

void FilesPolicyNotificationManager::ShowDlpWarningTimeoutNotification(
    dlp::FileAction action,
    std::optional<std::string> notification_id) {
  if (!notification_id.has_value()) {
    notification_id = GetNotificationId(notification_count_++);
  }
  // The notification should stay visible until dismissed.
  message_center::RichNotificationData optional_fields;
  optional_fields.never_timeout = true;
  auto notification = file_manager::CreateSystemNotification(
      notification_id.value(), GetTimeoutNotificationTitle(action),
      GetTimeoutNotificationMessage(action),
      base::MakeRefCounted<message_center::HandleNotificationClickDelegate>(
          base::BindRepeating(&Dismiss, context_, notification_id.value())),
      optional_fields);
  notification->set_buttons(
      {message_center::ButtonInfo(GetCancelButton(NotificationType::kError))});
  auto* profile = Profile::FromBrowserContext(context_);
  DCHECK(profile);
  NotificationDisplayServiceFactory::GetForProfile(profile)->Display(
      NotificationHandler::Type::TRANSIENT, *notification,
      /*metadata=*/nullptr);
}

bool FilesPolicyNotificationManager::HasIOTask(
    file_manager::io_task::IOTaskId task_id) const {
  return base::Contains(io_tasks_, task_id);
}

void FilesPolicyNotificationManager::OnIOTaskResumed(
    file_manager::io_task::IOTaskId task_id) {
  if (base::Contains(io_tasks_warning_timers_, task_id)) {
    io_tasks_warning_timers_.erase(task_id);
  }

  if (!HasIOTask(task_id)) {
    // Task is already completed or timed out.
    return;
  }

  if (!HasWarning(task_id)) {
    // Warning callback is already run.
    return;
  }

  auto* warning_info = io_tasks_.at(task_id).GetWarningInfo();
  std::move(warning_info->warning_callback)
      .Run(/*user_justification=*/warning_info->user_justification,
           /*should_proceed=*/true);
  io_tasks_.at(task_id).ResetWarningInfo();
}

void FilesPolicyNotificationManager::ShowBlockedNotifications() {
  for (const auto& task : io_tasks_) {
    if (HasBlockedFiles(task.first)) {
      ShowFilesPolicyNotification(file_manager::GetNotificationId(task.first),
                                  task.first);
    }
  }
}

void FilesPolicyNotificationManager::OnErrorItemDismissed(
    file_manager::io_task::IOTaskId task_id) {
  io_tasks_.erase(task_id);
}

std::map<FilesPolicyDialog::BlockReason, FilesPolicyDialog::Info>
FilesPolicyNotificationManager::GetIOTaskDialogInfoMapForTesting(
    file_manager::io_task::IOTaskId task_id) const {
  if (!HasIOTask(task_id)) {
    return {};
  }
  return io_tasks_.at(task_id).block_info_map();
}

bool FilesPolicyNotificationManager::HasWarningTimerForTesting(
    file_manager::io_task::IOTaskId task_id) const {
  return base::Contains(io_tasks_warning_timers_, task_id);
}

void FilesPolicyNotificationManager::HandleDlpWarningNotificationClick(
    std::string notification_id,
    std::optional<int> button_index) {
  if (!button_index.has_value()) {
    return;
  }

  Dismiss(context_, notification_id);

  CHECK(HasWarning(notification_id));
  auto* warning_info = non_io_tasks_.at(notification_id).GetWarningInfo();
  CHECK(!warning_info->warning_callback.is_null());

  switch (button_index.value()) {
    case NotificationButton::CANCEL:
      std::move(warning_info->warning_callback)
          .Run(/*user_justification=*/std::nullopt, /*should_proceed=*/false);
      non_io_tasks_.erase(notification_id);
      non_io_tasks_warning_timers_.erase(notification_id);
      break;

    case NotificationButton::OK:
      CHECK(warning_info->dialog_info.GetFiles().size() >= 1);

      if (warning_info->dialog_info.GetFiles().size() == 1 &&
          !warning_info->dialog_info.HasCustomDetails()) {
        // Action anyway.
        std::move(warning_info->warning_callback)
            .Run(/*user_justification=*/std::nullopt, /*should_proceed=*/true);
        non_io_tasks_.erase(notification_id);
        non_io_tasks_warning_timers_.erase(notification_id);
      } else {
        // Review
        // Always open the Files app. This should notify us through
        // OnBrowserSetLastActive() to show the dialog.
        LaunchFilesApp(std::make_unique<DialogInfo>(
            base::BindOnce(
                &FilesPolicyNotificationManager::ShowDialogForNonIOTask,
                weak_factory_.GetWeakPtr(), notification_id,
                FilesDialogType::kWarning),
            notification_id,
            base::BindOnce(
                &FilesPolicyNotificationManager::OnNonIOTaskAppLaunchTimedOut,
                weak_factory_.GetWeakPtr(), notification_id)));
      }
      break;
    default:
      NOTREACHED();
  }
}

void FilesPolicyNotificationManager::HandleDlpErrorNotificationClick(
    std::string notification_id,
    std::vector<base::FilePath> files,
    dlp::FileAction action,
    std::optional<int> button_index) {
  if (!button_index.has_value()) {
    return;
  }

  Dismiss(context_, notification_id);

  auto dialog_info = FilesPolicyDialog::Info::Error(
      FilesPolicyDialog::BlockReason::kDlp, files);
  bool always_show_review = dialog_info.HasCustomDetails();

  switch (button_index.value()) {
    case NotificationButton::CANCEL:
      // Nothing more to do.
      break;
    case NotificationButton::OK:
      DCHECK(files.size() >= 1);

      if (files.size() == 1 && !always_show_review) {
        // Learn more.
        dlp::OpenLearnMore();
      } else {
        // Review.
        FileTaskInfo info(action);
        info.SetBlockedFiles(FilesPolicyDialog::BlockReason::kDlp,
                             std::move(dialog_info));
        non_io_tasks_.emplace(notification_id, std::move(info));
        // Always open the Files app. This should notify us through
        // OnBrowserSetLastActive() to show the dialog.
        LaunchFilesApp(std::make_unique<DialogInfo>(
            base::BindOnce(
                &FilesPolicyNotificationManager::ShowDialogForNonIOTask,
                weak_factory_.GetWeakPtr(), notification_id,
                FilesDialogType::kError),
            notification_id,
            base::BindOnce(
                &FilesPolicyNotificationManager::OnNonIOTaskAppLaunchTimedOut,
                weak_factory_.GetWeakPtr(), notification_id)));
      }
      break;
    default:
      NOTREACHED();
  }
}

FilesPolicyNotificationManager::WarningInfo::WarningInfo(
    Policy warning_reason,
    WarningWithJustificationCallback warning_callback,
    WarningWithJustificationCallback dialog_callback,
    FilesPolicyDialog::Info dialog_info)
    : warning_reason(warning_reason),
      warning_callback(std::move(warning_callback)),
      dialog_callback(std::move(dialog_callback)),
      dialog_info(std::move(dialog_info)) {}

FilesPolicyNotificationManager::WarningInfo::WarningInfo(WarningInfo&& other)
    : warning_reason(other.warning_reason),
      warning_callback(std::move(other.warning_callback)),
      dialog_callback(std::move(other.dialog_callback)),
      dialog_info(std::move(other.dialog_info)) {}

FilesPolicyNotificationManager::WarningInfo::~WarningInfo() = default;

FilesPolicyNotificationManager::FileTaskInfo::FileTaskInfo(
    dlp::FileAction action)
    : action_(action) {}

FilesPolicyNotificationManager::FileTaskInfo::FileTaskInfo(
    FileTaskInfo&& other) {
  if (other.warning_info_.has_value()) {
    warning_info_.emplace(std::move(other.warning_info_.value()));
  }
  block_info_map_ = std::move(other.block_info_map_);
  action_ = other.action_;
  widget_ = other.widget_;
  if (widget_) {
    widget_observation_.Observe(widget_);
  }
}

FilesPolicyNotificationManager::FileTaskInfo::~FileTaskInfo() = default;

void FilesPolicyNotificationManager::FileTaskInfo::AddWidget(
    views::Widget* widget) {
  if (!widget) {
    CHECK_IS_TEST();
    return;
  }
  widget_ = widget;
  widget_observation_.Observe(widget);
}

void FilesPolicyNotificationManager::FileTaskInfo::CloseWidget() {
  if (!widget_) {
    return;
  }
  widget_observation_.Reset();
  widget_->Close();
  widget_ = nullptr;
}

void FilesPolicyNotificationManager::FileTaskInfo::SetWarningInfo(
    WarningInfo warning_info) {
  warning_info_.emplace(std::move(warning_info));
}

void FilesPolicyNotificationManager::FileTaskInfo::ResetWarningInfo() {
  warning_info_.reset();
}

FilesPolicyNotificationManager::WarningInfo*
FilesPolicyNotificationManager::FileTaskInfo::GetWarningInfo() {
  return base::OptionalToPtr(warning_info_);
}

bool FilesPolicyNotificationManager::FileTaskInfo::HasWarningInfo() const {
  return warning_info_.has_value();
}

void FilesPolicyNotificationManager::FileTaskInfo::SetBlockedFiles(
    FilesPolicyDialog::BlockReason reason,
    FilesPolicyDialog::Info dialog_info) {
  if (dialog_info.GetFiles().empty()) {
    return;
  }
  auto it = block_info_map_.find(reason);
  if (it == block_info_map_.end()) {
    block_info_map_.insert({reason, std::move(dialog_info)});
  } else {
    it->second = std::move(dialog_info);
  }
}

size_t FilesPolicyNotificationManager::FileTaskInfo::GetBlockedFilesSize()
    const {
  size_t size = 0;
  for (const auto& [_, dialog_info] : block_info_map_) {
    size += dialog_info.GetFiles().size();
  }
  return size;
}

void FilesPolicyNotificationManager::FileTaskInfo::OnWidgetDestroying(
    views::Widget* widget) {
  widget_ = nullptr;
  widget_observation_.Reset();
}

FilesPolicyNotificationManager::DialogInfo::DialogInfo(
    ShowDialogCallback dialog_callback,
    file_manager::io_task::IOTaskId task_id,
    base::OnceClosure timeout_callback)
    : task_id(task_id),
      notification_id(std::nullopt),
      dialog_callback(std::move(dialog_callback)),
      timeout_callback(std::move(timeout_callback)) {}

FilesPolicyNotificationManager::DialogInfo::DialogInfo(
    ShowDialogCallback dialog_callback,
    std::string notification_id,
    base::OnceClosure timeout_callback)
    : task_id(std::nullopt),
      notification_id(notification_id),
      dialog_callback(std::move(dialog_callback)),
      timeout_callback(std::move(timeout_callback)) {}

FilesPolicyNotificationManager::DialogInfo::~DialogInfo() = default;

void FilesPolicyNotificationManager::ShowFilesPolicyNotification(
    const std::string& notification_id,
    file_manager::io_task::IOTaskId task_id) {
  if (!HasWarning(task_id) && !HasBlockedFiles(task_id)) {
    return;
  }

  const dlp::FileAction action = io_tasks_.at(task_id).action();
  auto callback =
      HasWarning(task_id)
          ? base::BindRepeating(&FilesPolicyNotificationManager::
                                    HandleFilesPolicyWarningNotificationClick,
                                weak_factory_.GetWeakPtr(), task_id,
                                notification_id)
          : base::BindRepeating(&FilesPolicyNotificationManager::
                                    HandleFilesPolicyErrorNotificationClick,
                                weak_factory_.GetWeakPtr(), task_id,
                                notification_id);
  // The notification should stay visible until dismissed.
  message_center::RichNotificationData optional_fields;
  optional_fields.never_timeout = true;
  const NotificationType type = HasWarning(task_id) ? NotificationType::kWarning
                                                    : NotificationType::kError;
  size_t file_count;
  std::u16string file_name;
  std::optional<FilesPolicyDialog::BlockReason> reason;
  FileTaskInfo& task_info = io_tasks_.at(task_id);
  bool always_show_review;
  if (HasWarning(task_id)) {
    CHECK(!task_info.GetWarningInfo()->dialog_info.GetFiles().empty());
    file_count = task_info.GetWarningInfo()->dialog_info.GetFiles().size();
    file_name =
        task_info.GetWarningInfo()->dialog_info.GetFiles().begin()->title;
    always_show_review =
        task_info.GetWarningInfo()->dialog_info.HasCustomDetails();
  } else {
    CHECK(HasBlockedFiles(task_id));
    file_count = task_info.GetBlockedFilesSize();
    file_name =
        task_info.block_info_map().begin()->second.GetFiles().front().title;
    reason = task_info.block_info_map().begin()->first;
    always_show_review = HasCustomDialogSettings(task_info.block_info_map());
  }
  auto notification = file_manager::CreateSystemNotification(
      notification_id, GetNotificationTitle(type, action, file_count),
      GetNotificationMessage(type, file_count, file_name, reason),
      base::MakeRefCounted<message_center::HandleNotificationClickDelegate>(
          std::move(callback)),
      optional_fields);
  notification->set_buttons(
      {message_center::ButtonInfo(GetCancelButton(type)),
       message_center::ButtonInfo(
           GetOkButton(type, action, file_count, always_show_review))});
  auto* profile = Profile::FromBrowserContext(context_);
  DCHECK(profile);
  NotificationDisplayServiceFactory::GetForProfile(profile)->Display(
      NotificationHandler::Type::TRANSIENT, *notification,
      /*metadata=*/nullptr);
}

void FilesPolicyNotificationManager::HandleFilesPolicyWarningNotificationClick(
    file_manager::io_task::IOTaskId task_id,
    std::string notification_id,
    std::optional<int> button_index) {
  if (!button_index.has_value()) {
    return;
  }
  if (!HasIOTask(task_id)) {
    // Task already completed.
    return;
  }
  if (!HasWarning(task_id)) {
    LOG(WARNING) << "Warning notification clicked but no warning info found";
    return;
  }
  Dismiss(context_, notification_id);

  switch (button_index.value()) {
    case NotificationButton::CANCEL:
      Cancel(task_id);
      break;
    case NotificationButton::OK:
      if (io_tasks_.at(task_id)
                  .GetWarningInfo()
                  ->dialog_info.GetFiles()
                  .size() == 1 &&
          !io_tasks_.at(task_id)
               .GetWarningInfo()
               ->dialog_info.HasCustomDetails()) {
        // Single file, no custom dialog settings - proceed.
        Resume(task_id);
      } else {
        // Multiple files or custom dialog settings - review.
        ShowDialog(task_id, FilesDialogType::kWarning);
      }
      break;
  }
}

void FilesPolicyNotificationManager::HandleFilesPolicyErrorNotificationClick(
    file_manager::io_task::IOTaskId task_id,
    std::string notification_id,
    std::optional<int> button_index) {
  if (!button_index.has_value()) {
    return;
  }
  if (!HasIOTask(task_id)) {
    // Task already completed.
    return;
  }
  if (!HasBlockedFiles(task_id)) {
    LOG(WARNING) << "Error notification clicked but no blocked files found";
    return;
  }

  Dismiss(context_, notification_id);

  switch (button_index.value()) {
    case NotificationButton::CANCEL:
      OnErrorItemDismissed(task_id);
      return;
    case NotificationButton::OK:
      if (io_tasks_.at(task_id).GetBlockedFilesSize() == 1 &&
          !io_tasks_.at(task_id)
               .block_info_map()
               .begin()
               ->second.HasCustomDetails()) {
        // Single file, no custom dialog settings - open help page.
        // Note that this can only be DLP, since when custom learn more URL is
        // available, currently only for EC, we show the review button.
        dlp::OpenLearnMore(GURL(dlp::kDlpLearnMoreUrl));
        // Only delete if we don't need to show the dialog.
        OnErrorItemDismissed(task_id);
      } else {
        // Multiple files or custom dialog settings - review.
        ShowDialog(task_id, FilesDialogType::kError);
      }
      return;
    default:
      NOTREACHED();
  }
}

void FilesPolicyNotificationManager::ShowDialogForIOTask(
    file_manager::io_task::IOTaskId task_id,
    FilesDialogType type,
    gfx::NativeWindow modal_parent) {
  if (!HasIOTask(task_id)) {
    // Task already completed or timed out.
    return;
  }

  ShowFilesPolicyDialog(std::ref(io_tasks_.at(task_id)), type, modal_parent);
  if (type == FilesDialogType::kError) {
    io_tasks_.erase(task_id);
  }
}

void FilesPolicyNotificationManager::ShowDialogForNonIOTask(
    std::string notification_id,
    FilesDialogType type,
    gfx::NativeWindow modal_parent) {
  if (!HasNonIOTask(notification_id)) {
    // Task already completed or timed out.
    return;
  }
  ShowFilesPolicyDialog(std::ref(non_io_tasks_.at(notification_id)), type,
                        modal_parent);

  if (type == FilesDialogType::kError) {
    non_io_tasks_.erase(notification_id);
  }
}

void FilesPolicyNotificationManager::ShowFilesPolicyDialog(
    FileTaskInfo& info,
    FilesDialogType type,
    gfx::NativeWindow modal_parent) {
  switch (type) {
    case FilesDialogType::kUnknown:
      LOG(WARNING) << "Unknown FilesDialogType passed";
      return;

    case FilesDialogType::kError:
      if (info.block_info_map().empty() || info.widget()) {
        return;
      }
      info.AddWidget(FilesPolicyDialog::CreateErrorDialog(
          info.block_info_map(), info.action(), modal_parent));
      return;

    case FilesDialogType::kWarning:
      if (!info.GetWarningInfo() || info.widget()) {
        return;
      }
      WarningInfo* warning_info = info.GetWarningInfo();
      CHECK(!warning_info->warning_callback.is_null());
      info.AddWidget(FilesPolicyDialog::CreateWarnDialog(
          std::move(warning_info->dialog_callback), info.action(), modal_parent,
          std::move(warning_info->dialog_info),
          /*destination=*/std::nullopt));
      return;
  }
}

void FilesPolicyNotificationManager::AddIOTask(
    file_manager::io_task::IOTaskId task_id,
    dlp::FileAction action) {
  io_tasks_.emplace(std::move(task_id), FileTaskInfo(action));
}

void FilesPolicyNotificationManager::LaunchFilesApp(
    std::unique_ptr<DialogInfo> info) {
  // Start observing the browser list only if the queue is empty.
  if (pending_dialogs_.empty()) {
    BrowserList::AddObserver(this);
  }
  // Start timer.
  info->timeout_timer.SetTaskRunner(task_runner_);
  info->timeout_timer.Start(FROM_HERE, kOpenFilesAppTimeout,
                            std::move(info->timeout_callback));

  pending_dialogs_.emplace(std::move(info));

  ui::SelectFileDialog::FileTypeInfo file_type_info;
  file_type_info.allowed_paths =
      ui::SelectFileDialog::FileTypeInfo::ANY_PATH_OR_URL;
  GURL files_swa_url = file_manager::util::GetFileManagerMainPageUrlWithParams(
      ui::SelectFileDialog::SELECT_NONE,
      /*title=*/{},
      /*current_directory_url=*/{},
      /*selection_url=*/{},
      /*target_name=*/{}, &file_type_info,
      /*file_type_index=*/0,
      /*search_query=*/{},
      /*show_android_picker_apps=*/false,
      /*volume_filter=*/{});
  ash::SystemAppLaunchParams params;
  params.url = files_swa_url;
  ash::LaunchSystemWebAppAsync(Profile::FromBrowserContext(context_),
                               ash::SystemWebAppType::FILE_MANAGER, params);
}

void FilesPolicyNotificationManager::OnBrowserAdded(Browser* browser) {
  if (!ash::IsBrowserForSystemWebApp(browser,
                                     ash::SystemWebAppType::FILE_MANAGER)) {
    LOG(WARNING) << "Browser did not match Files app";
    return;
  }

  // Files app successfully opened.
  data_controls::DlpBooleanHistogram(
      data_controls::dlp::kFilesAppOpenTimedOutUMA, /*value=*/false);
  ShowPendingDialog(browser->window()->GetNativeWindow());
}

void FilesPolicyNotificationManager::SetTaskRunnerForTesting(
    scoped_refptr<base::SequencedTaskRunner> task_runner) {
  task_runner_ = task_runner;
}

void FilesPolicyNotificationManager::OnIOTaskStatus(
    const file_manager::io_task::ProgressStatus& status) {
  // Observe only Copy, Move, and RestoreToDestination tasks.
  if (status.type != file_manager::io_task::OperationType::kCopy &&
      status.type != file_manager::io_task::OperationType::kMove &&
      status.type !=
          file_manager::io_task::OperationType::kRestoreToDestination) {
    return;
  }
  // RestoreToDestination have an underlying Move task, so we show the same UI
  // as for Move.
  dlp::FileAction action =
      status.type == file_manager::io_task::OperationType::kCopy
          ? dlp::FileAction::kCopy
          : dlp::FileAction::kMove;

  if (!HasIOTask(status.task_id) &&
      status.state == file_manager::io_task::State::kQueued) {
    AddIOTask(status.task_id, action);
    return;
  }

  if (HasIOTask(status.task_id) && status.IsCompleted()) {
    io_tasks_warning_timers_.erase(status.task_id);
    // If task is cancelled or completed with error and has a warning, run the
    // warning callback to cancel the warning.
    if ((status.state == file_manager::io_task::State::kCancelled ||
         status.state == file_manager::io_task::State::kError) &&
        HasWarning(status.task_id)) {
      CHECK(!io_tasks_.at(status.task_id)
                 .GetWarningInfo()
                 ->warning_callback.is_null());
      std::move(io_tasks_.at(status.task_id).GetWarningInfo()->warning_callback)
          .Run(/*user_justification=*/std::nullopt, /*should_proceed=*/false);
      io_tasks_.at(status.task_id).ResetWarningInfo();
    }
    // Remove only if the IOTask doesn't have any blocked file.
    if (!HasBlockedFiles(status.task_id)) {
      io_tasks_.erase(status.task_id);
    }
  }
}

bool FilesPolicyNotificationManager::HasBlockedFiles(
    file_manager::io_task::IOTaskId task_id) const {
  return HasIOTask(task_id) && !io_tasks_.at(task_id).block_info_map().empty();
}

bool FilesPolicyNotificationManager::HasWarning(
    file_manager::io_task::IOTaskId task_id) const {
  return HasIOTask(task_id) && io_tasks_.at(task_id).HasWarningInfo();
}

bool FilesPolicyNotificationManager::HasNonIOTask(
    const std::string& notification_id) const {
  return base::Contains(non_io_tasks_, notification_id);
}

bool FilesPolicyNotificationManager::HasBlockedFiles(
    const std::string& notification_id) const {
  return HasNonIOTask(notification_id) &&
         !non_io_tasks_.at(notification_id).block_info_map().empty();
}

bool FilesPolicyNotificationManager::HasWarning(
    const std::string& notification_id) const {
  return HasNonIOTask(notification_id) &&
         non_io_tasks_.at(notification_id).HasWarningInfo();
}

void FilesPolicyNotificationManager::OnIOTaskWarningDialogClicked(
    file_manager::io_task::IOTaskId task_id,
    Policy warning_reason,
    std::optional<std::u16string> user_justification,
    bool should_proceed) {
  if (!HasIOTask(task_id) || !HasWarning(task_id)) {
    // Task probably timed out.
    return;
  }
  if (should_proceed) {
    io_tasks_.at(task_id).GetWarningInfo()->user_justification =
        user_justification;
    Resume(task_id);
  } else {
    Cancel(task_id);
  }
}

void FilesPolicyNotificationManager::OnNonIOTaskWarningDialogClicked(
    const std::string& notification_id,
    std::optional<std::u16string> user_justification,
    bool should_proceed) {
  if (!HasWarning(notification_id)) {
    // Task probably timed out.
    return;
  }
  std::move(
      non_io_tasks_.at(notification_id).GetWarningInfo()->warning_callback)
      .Run(user_justification, should_proceed);
  non_io_tasks_.erase(notification_id);
}

void FilesPolicyNotificationManager::OnDlpLearnMoreButtonClicked(
    const std::string& notification_id,
    std::optional<int> button_index) {
  if (!button_index || button_index.value() != 0) {
    return;
  }

  dlp::OpenLearnMore();

  Dismiss(context_, notification_id);
}

void FilesPolicyNotificationManager::Resume(
    file_manager::io_task::IOTaskId task_id) {
  io_tasks_warning_timers_.erase(task_id);
  if (!HasIOTask(task_id) || !HasWarning(task_id)) {
    return;
  }
  auto* io_task_controller = GetIOTaskController(context_);
  if (!io_task_controller) {
    LOG(ERROR) << "FilesPolicyNotificationManager failed to find "
                  "file_manager::io_task::IOTaskController";
    return;
  }
  file_manager::io_task::ResumeParams params;
  params.policy_params = file_manager::io_task::PolicyResumeParams(
      io_tasks_.at(task_id).GetWarningInfo()->warning_reason);
  io_task_controller->Resume(task_id, std::move(params));
}

void FilesPolicyNotificationManager::Cancel(
    file_manager::io_task::IOTaskId task_id) {
  io_tasks_warning_timers_.erase(task_id);
  if (!HasIOTask(task_id) || !HasWarning(task_id)) {
    return;
  }
  auto* io_task_controller = GetIOTaskController(context_);
  if (!io_task_controller) {
    LOG(ERROR) << "FilesPolicyNotificationManager failed to find "
                  "file_manager::io_task::IOTaskController";
    return;
  }
  io_task_controller->Cancel(task_id);
}

void FilesPolicyNotificationManager::ShowDlpBlockNotification(
    std::vector<base::FilePath> blocked_files,
    dlp::FileAction action) {
  const std::string notification_id = GetNotificationId(notification_count_++);
  std::unique_ptr<message_center::Notification> notification;

  if (base::FeatureList::IsEnabled(features::kNewFilesPolicyUX)) {
    // The notification should stay visible until actioned upon.
    message_center::RichNotificationData optional_fields;
    optional_fields.never_timeout = true;
    notification = file_manager::CreateSystemNotification(
        notification_id,
        GetNotificationTitle(NotificationType::kError, action,
                             blocked_files.size()),
        GetNotificationMessage(
            NotificationType::kError, blocked_files.size(),
            blocked_files.begin()->BaseName().LossyDisplayName(),
            FilesPolicyDialog::BlockReason::kDlp),
        base::MakeRefCounted<PolicyNotificationClickHandler>(base::BindOnce(
            &FilesPolicyNotificationManager::HandleDlpErrorNotificationClick,
            weak_factory_.GetWeakPtr(), notification_id, blocked_files,
            action)),
        optional_fields);
    notification->set_buttons(
        {message_center::ButtonInfo(GetCancelButton(NotificationType::kError)),
         message_center::ButtonInfo(
             GetOkButton(NotificationType::kError, action, blocked_files.size(),
                         /*always_show_review=*/false))});
  } else {
    std::u16string title;
    std::u16string message;
    switch (action) {
      case dlp::FileAction::kDownload:
        title = l10n_util::GetStringUTF16(
            IDS_POLICY_DLP_FILES_DOWNLOAD_BLOCK_TITLE);
        // ignore `blocked_files.size()` for downloads.
        message = l10n_util::GetStringUTF16(
            IDS_POLICY_DLP_FILES_DOWNLOAD_BLOCK_MESSAGE);
        break;
      case dlp::FileAction::kUpload:
        title =
            l10n_util::GetStringUTF16(IDS_POLICY_DLP_FILES_UPLOAD_BLOCK_TITLE);
        message = l10n_util::GetPluralStringFUTF16(
            IDS_POLICY_DLP_FILES_UPLOAD_BLOCK_MESSAGE, blocked_files.size());
        break;
      case dlp::FileAction::kOpen:
      case dlp::FileAction::kShare:
        title =
            l10n_util::GetStringUTF16(IDS_POLICY_DLP_FILES_OPEN_BLOCK_TITLE);
        message = l10n_util::GetPluralStringFUTF16(
            IDS_POLICY_DLP_FILES_OPEN_BLOCK_MESSAGE, blocked_files.size());
        break;
      case dlp::FileAction::kCopy:
      case dlp::FileAction::kMove:
      case dlp::FileAction::kTransfer:
      case dlp::FileAction::kUnknown:
        // TODO(b/269609831): Show correct notification here.
        return;
    }
    notification = file_manager::CreateSystemNotification(
        notification_id, title, message,
        base::MakeRefCounted<message_center::HandleNotificationClickDelegate>(
            base::BindRepeating(
                &FilesPolicyNotificationManager::OnDlpLearnMoreButtonClicked,
                weak_factory_.GetWeakPtr(), notification_id)));
    notification->set_buttons({message_center::ButtonInfo(
        l10n_util::GetStringUTF16(IDS_LEARN_MORE))});
  }

  auto* profile = Profile::FromBrowserContext(context_);
  DCHECK(profile);
  NotificationDisplayServiceFactory::GetForProfile(profile)->Display(
      NotificationHandler::Type::TRANSIENT, *notification,
      /*metadata=*/nullptr);
}

void FilesPolicyNotificationManager::ShowDlpWarningNotification(
    WarningWithJustificationCallback callback,
    std::vector<base::FilePath> warning_files,
    const DlpFileDestination& destination,
    dlp::FileAction action) {
  if (base::FeatureList::IsEnabled(features::kNewFilesPolicyUX)) {
    const std::string& notification_id =
        GetNotificationId(notification_count_++);
    // Store the task info.
    FileTaskInfo info(action);
    info.SetWarningInfo(
        {Policy::kDlp, std::move(callback),
         base::BindOnce(
             &FilesPolicyNotificationManager::OnNonIOTaskWarningDialogClicked,
             weak_factory_.GetWeakPtr(), notification_id),
         FilesPolicyDialog::Info::Warn(FilesPolicyDialog::BlockReason::kDlp,
                                       warning_files)});
    non_io_tasks_.emplace(notification_id, std::move(info));

    std::vector<message_center::ButtonInfo> buttons = {
        message_center::ButtonInfo(GetCancelButton(NotificationType::kWarning)),
        message_center::ButtonInfo(GetOkButton(NotificationType::kWarning,
                                               action, warning_files.size(),
                                               /*always_show_review=*/false))};
    // The notification should stay visible until actioned upon.
    message_center::RichNotificationData optional_fields;
    optional_fields.never_timeout = true;
    auto notification = file_manager::CreateSystemNotification(
        notification_id,
        GetNotificationTitle(NotificationType::kWarning, action,
                             /*file_count=*/std::nullopt),
        GetNotificationMessage(
            NotificationType::kWarning, warning_files.size(),
            warning_files.begin()->BaseName().LossyDisplayName(), std::nullopt),
        base::MakeRefCounted<PolicyNotificationClickHandler>(base::BindOnce(
            &FilesPolicyNotificationManager::HandleDlpWarningNotificationClick,
            weak_factory_.GetWeakPtr(), notification_id)));
    notification->set_buttons(std::move(buttons));

    auto* profile = Profile::FromBrowserContext(context_);
    DCHECK(profile);
    NotificationDisplayServiceFactory::GetForProfile(profile)->Display(
        NotificationHandler::Type::TRANSIENT, *notification,
        /*metadata=*/nullptr);

    // Start warning timer.
    non_io_tasks_warning_timers_[notification_id] =
        std::make_unique<base::OneShotTimer>();
    non_io_tasks_warning_timers_[notification_id]->SetTaskRunner(task_runner_);
    non_io_tasks_warning_timers_[notification_id]->Start(
        FROM_HERE, kWarningTimeout,
        base::BindOnce(
            &FilesPolicyNotificationManager::OnNonIOTaskWarningTimedOut,
            weak_factory_.GetWeakPtr(), notification_id));
  } else {
    FilesPolicyDialog::CreateWarnDialog(
        std::move(callback), action, /*modal_parent=*/nullptr,
        FilesPolicyDialog::Info::Warn(FilesPolicyDialog::BlockReason::kDlp,
                                      warning_files),
        destination);
  }
}

void FilesPolicyNotificationManager::PauseIOTask(
    file_manager::io_task::IOTaskId task_id,
    WarningWithJustificationCallback callback,
    dlp::FileAction action,
    Policy warning_reason,
    FilesPolicyDialog::Info dialog_info) {
  auto* io_task_controller = GetIOTaskController(context_);
  if (!io_task_controller) {
    // Proceed because the IO task can't be paused.
    std::move(callback).Run(/*user_justification=*/std::nullopt,
                            /*should_proceed=*/true);
    return;
  }
  // Sometimes DLP checks are done before FilesPolicyNotificationManager is
  // lazily created, so the task is not tracked and the pausing won't happen. On
  // the other hand, the IO task may be aborted/canceled already so the info
  // saved may be not needed anymore.
  if (!HasIOTask(task_id)) {
    AddIOTask(task_id, action);
  }

  io_tasks_.at(task_id).SetWarningInfo(
      {warning_reason, std::move(callback),
       base::BindOnce(
           &FilesPolicyNotificationManager::OnIOTaskWarningDialogClicked,
           weak_factory_.GetWeakPtr(), task_id, warning_reason),
       std::move(dialog_info)});

  file_manager::io_task::PauseParams pause_params;
  pause_params.policy_params = file_manager::io_task::PolicyPauseParams(
      warning_reason,
      io_tasks_.at(task_id).GetWarningInfo()->dialog_info.GetFiles().size(),
      io_tasks_.at(task_id)
          .GetWarningInfo()
          ->dialog_info.GetFiles()
          .begin()
          ->file_path.BaseName()
          .value(),
      io_tasks_.at(task_id).GetWarningInfo()->dialog_info.HasCustomDetails());
  io_task_controller->Pause(task_id, std::move(pause_params));
  // Start warning timer.
  io_tasks_warning_timers_[task_id] = std::make_unique<base::OneShotTimer>();
  io_tasks_warning_timers_[task_id]->SetTaskRunner(task_runner_);
  io_tasks_warning_timers_[task_id]->Start(
      FROM_HERE, kWarningTimeout,
      base::BindOnce(&FilesPolicyNotificationManager::OnIOTaskWarningTimedOut,
                     weak_factory_.GetWeakPtr(), task_id));
}

void FilesPolicyNotificationManager::OnIOTaskAppLaunchTimedOut(
    file_manager::io_task::IOTaskId task_id) {
  if (pending_dialogs_.empty()) {
    return;
  }
  DCHECK(pending_dialogs_.front()->task_id == task_id);
  // Stop waiting for the Files App and fallback to system modal.
  data_controls::DlpBooleanHistogram(
      data_controls::dlp::kFilesAppOpenTimedOutUMA, /*value=*/true);
  ShowPendingDialog(/*modal_parent=*/nullptr);
}

void FilesPolicyNotificationManager::OnNonIOTaskAppLaunchTimedOut(
    std::string notification_id) {
  // If the notification id doesn't match the front element, we already showed
  // the dialog for this notification before timing out.
  if (pending_dialogs_.empty()) {
    return;
  }
  DCHECK(pending_dialogs_.front()->notification_id == notification_id);
  // Stop waiting for the Files App and fallback to system modal.
  data_controls::DlpBooleanHistogram(
      data_controls::dlp::kFilesAppOpenTimedOutUMA, /*value=*/true);
  ShowPendingDialog(/*modal_parent=*/nullptr);
}

void FilesPolicyNotificationManager::ShowPendingDialog(
    gfx::NativeWindow modal_parent) {
  if (pending_dialogs_.empty()) {
    return;
  }
  // Pop the dialog. This also stops the timer if it hasn't fired already.
  CHECK(pending_dialogs_.front()->dialog_callback);
  std::move(pending_dialogs_.front()->dialog_callback).Run(modal_parent);
  pending_dialogs_.pop();
  // If this was the last dialog, stop observing the browser list.
  if (pending_dialogs_.empty()) {
    BrowserList::RemoveObserver(this);
  }
}

void FilesPolicyNotificationManager::OnIOTaskWarningTimedOut(
    const file_manager::io_task::IOTaskId& task_id) {
  // Remove the timer.
  io_tasks_warning_timers_.erase(task_id);
  if (!HasIOTask(task_id) || !HasWarning(task_id)) {
    return;
  }

  // Close the warning dialog if there's any.
  io_tasks_.at(task_id).CloseWidget();

  data_controls::DlpHistogramEnumeration(
      data_controls::dlp::kFileActionWarnTimedOutUMA,
      io_tasks_.at(task_id).action());

  // Abort the IOtask. No need to run the warning callback here as it will be
  // called in OnIOTaskStatus when there's an update sent that the task
  // completed with error.
  auto* io_task_controller = GetIOTaskController(context_);
  io_task_controller->CompleteWithError(
      task_id, file_manager::io_task::PolicyError(
                   file_manager::io_task::PolicyErrorType::kDlpWarningTimeout));
}

void FilesPolicyNotificationManager::OnNonIOTaskWarningTimedOut(
    const std::string& notification_id) {
  // Remove the timer.
  non_io_tasks_warning_timers_.erase(notification_id);
  // Dismiss the notification if it's still shown.
  Dismiss(context_, notification_id);
  if (!HasWarning(notification_id)) {
    return;
  }

  // Close the warning dialog if there's any.
  non_io_tasks_.at(notification_id).CloseWidget();

  data_controls::DlpHistogramEnumeration(
      data_controls::dlp::kFileActionWarnTimedOutUMA,
      non_io_tasks_.at(notification_id).action());

  // Run the warning callback with false.
  std::move(
      non_io_tasks_.at(notification_id).GetWarningInfo()->warning_callback)
      .Run(/*user_justification=*/std::nullopt, /*should_proceed=*/false);

  ShowDlpWarningTimeoutNotification(non_io_tasks_.at(notification_id).action());

  non_io_tasks_.erase(notification_id);
}

}  // namespace policy