// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chrome/browser/ui/webui/ash/cloud_upload/cloud_upload_notification_manager.h"

#include "ash/public/cpp/notification_utils.h"
#include "ash/resources/vector_icons/vector_icons.h"
#include "base/check.h"
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/i18n/message_formatter.h"
#include "base/memory/scoped_refptr.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/utf_string_conversions.h"
#include "base/time/time.h"
#include "chrome/browser/ash/file_manager/path_util.h"
#include "chrome/browser/notifications/notification_display_service_factory.h"
#include "chrome/browser/platform_util.h"
#include "chrome/browser/ui/webui/ash/cloud_upload/cloud_upload_util.h"
#include "chrome/grit/generated_resources.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/chromeos/strings/grit/ui_chromeos_strings.h"
#include "ui/message_center/public/cpp/notification_delegate.h"

namespace ash::cloud_upload {
namespace {

// The minimum amount of time for which the "in progress" state should be
// displayed.
const base::TimeDelta kMinInProgressTime = base::Seconds(5);

// Time for which the "Complete" notification should display.
const base::TimeDelta kCompleteNotificationTime = base::Seconds(5);

// If no other class instance holds a reference to the notification manager, the
// notification manager goes out of scope.
void OnNotificationManagerDone(
    scoped_refptr<CloudUploadNotificationManager> notification_manager) {}

}  // namespace

CloudUploadNotificationManager::CloudUploadNotificationManager(
    Profile* profile,
    const std::string& cloud_provider_name,
    const std::string& target_app_name,
    int num_files,
    UploadType upload_type)
    : profile_(profile),
      cloud_provider_name_(cloud_provider_name),
      target_app_name_(target_app_name),
      num_files_(num_files),
      upload_type_(upload_type) {
  // Generate a unique ID for the cloud upload notifications.
  notification_id_ =
      "cloud-upload-" +
      base::NumberToString(
          ++CloudUploadNotificationManager::notification_manager_counter_);

  // Set the system notification source display name to "Files".
  display_source_ =
      l10n_util::GetStringUTF16(IDS_ASH_MESSAGE_CENTER_SYSTEM_APP_NAME_FILES);

  // Keep the new `CloudUploadNotificationManager` instance alive at least until
  // `OnNotificationManagerDone` executes.
  callback_ =
      base::BindOnce(&OnNotificationManagerDone, base::WrapRefCounted(this));
}

CloudUploadNotificationManager::~CloudUploadNotificationManager() {
  // Make sure open notifications are dismissed before the notification manager
  // goes out of scope.
  CloseNotification();
}

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

std::unique_ptr<message_center::Notification>
CloudUploadNotificationManager::CreateUploadProgressNotification() {
  bool is_copy_operation = upload_type_ == UploadType::kCopy;
  // TODO(b/242685536) Use "files" for multi-files when support for
  // multi-files is added.
  std::u16string title = base::i18n::MessageFormatter::FormatWithNumberedArgs(
      l10n_util::GetStringUTF16(is_copy_operation
                                    ? IDS_OFFICE_NOTIFICATION_COPYING_FILES
                                    : IDS_OFFICE_NOTIFICATION_MOVING_FILES),
      num_files_, cloud_provider_name_);
  std::u16string message = base::i18n::MessageFormatter::FormatWithNumberedArgs(
      l10n_util::GetStringUTF16(IDS_OFFICE_NOTIFICATION_FILES_WILL_OPEN),
      num_files_, target_app_name_);

  auto notification = ash::CreateSystemNotificationPtr(
      /*type=*/message_center::NOTIFICATION_TYPE_PROGRESS,
      /*id=*/notification_id_, title,
      // TODO(b/272601262) Display or delete this message.
      /*message=*/{}, /*display_source=*/display_source_,
      /*origin_url=*/GURL(), /*notifier_id=*/message_center::NotifierId(),
      /*optional_fields=*/{},
      /*delegate=*/
      base::MakeRefCounted<message_center::HandleNotificationClickDelegate>(
          base::BindRepeating(
              &CloudUploadNotificationManager::HandleProgressNotificationClick,
              weak_ptr_factory_.GetWeakPtr())),
      /*small_image=*/ash::kFolderIcon,
      /*warning_level=*/message_center::SystemNotificationWarningLevel::NORMAL);

  // For a progress notification the message parameter won't be displayed in the
  // notification. Therefore, its value is passed to progress_status which will
  // be displayed.
  notification->set_progress_status(message);

  // Add "Cancel" button if upload still cancellable.
  if (CanCancel() && cancel_callback_) {
    std::vector<message_center::ButtonInfo> notification_buttons = {
        message_center::ButtonInfo(
            l10n_util::GetStringUTF16(IDS_FILE_BROWSER_CANCEL_LABEL))};
    notification->set_buttons(notification_buttons);
  }

  return notification;
}

std::unique_ptr<message_center::Notification>
CloudUploadNotificationManager::CreateUploadCompleteNotification() {
  bool is_copy_operation = upload_type_ == UploadType::kCopy;
  // TODO(b/242685536) Use "files" for multi-files when support for multi-files
  // is added.
  std::u16string title = base::i18n::MessageFormatter::FormatWithNumberedArgs(
      l10n_util::GetStringUTF16(is_copy_operation
                                    ? IDS_OFFICE_NOTIFICATION_FILES_COPIED
                                    : IDS_OFFICE_NOTIFICATION_FILES_MOVED),
      num_files_, cloud_provider_name_);
  std::u16string message =
      l10n_util::GetStringFUTF16(IDS_OFFICE_NOTIFICATION_FILES_OPENING,
                                 base::UTF8ToUTF16(target_app_name_));
  auto notification = ash::CreateSystemNotificationPtr(
      /*type=*/message_center::NOTIFICATION_TYPE_SIMPLE,
      /*id=*/notification_id_, title, message,
      /*display_source=*/display_source_,
      /*origin_url=*/GURL(), /*notifier_id=*/message_center::NotifierId(),
      /*optional_fields=*/{},
      /*delegate=*/
      base::MakeRefCounted<message_center::HandleNotificationClickDelegate>(
          base::BindRepeating(
              &CloudUploadNotificationManager::HandleCompleteNotificationClick,
              weak_ptr_factory_.GetWeakPtr())),
      /*small_image=*/ash::kFolderIcon,
      /*warning_level=*/
      message_center::SystemNotificationWarningLevel::NORMAL);

  DCHECK(!destination_path_.empty());
  if (!destination_path_.empty()) {
    //  Add "Show in folder" button.
    std::u16string button_title = l10n_util::GetStringUTF16(
        IDS_OFFICE_NOTIFICATION_SHOW_IN_FOLDER_BUTTON);
    std::vector<message_center::ButtonInfo> notification_buttons = {
        message_center::ButtonInfo(button_title)};
    notification->set_buttons(notification_buttons);
  }
  return notification;
}

std::unique_ptr<message_center::Notification>
CloudUploadNotificationManager::CreateUploadErrorNotification(
    std::string message) {
  bool is_copy_operation = upload_type_ == UploadType::kCopy;
  std::u16string title = base::i18n::MessageFormatter::FormatWithNumberedArgs(
      l10n_util::GetStringUTF16(is_copy_operation
                                    ? IDS_OFFICE_UPLOAD_ERROR_CANT_COPY_FILES
                                    : IDS_OFFICE_UPLOAD_ERROR_CANT_MOVE_FILES),
      num_files_, cloud_provider_name_);
  std::vector<message_center::ButtonInfo> notification_buttons;

  auto notification = ash::CreateSystemNotificationPtr(
      /*type=*/message_center::NOTIFICATION_TYPE_SIMPLE,
      /*id=*/notification_id_, title, base::UTF8ToUTF16(message),
      /*display_source=*/display_source_,
      /*origin_url=*/GURL(), /*notifier_id=*/message_center::NotifierId(),
      /*optional_fields=*/{},
      /*delegate=*/
      base::MakeRefCounted<message_center::HandleNotificationClickDelegate>(
          base::BindRepeating(
              &CloudUploadNotificationManager::HandleErrorNotificationClick,
              weak_ptr_factory_.GetWeakPtr())),
      /*small_image=*/ash::kFolderIcon,
      /*warning_level=*/
      message_center::SystemNotificationWarningLevel::WARNING);

  //  Add "Sign in" button if this is a reauthentication error.
  if (message == GetReauthenticationRequiredMessage()) {
    std::u16string button_title =
        l10n_util::GetStringUTF16(IDS_OFFICE_NOTIFICATION_SIGN_IN_BUTTON);
    notification_buttons.emplace_back(button_title);
  }

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

void CloudUploadNotificationManager::ShowUploadProgress(int progress) {
  progress_ = progress;
  std::unique_ptr<message_center::Notification> notification =
      CreateUploadProgressNotification();
  notification->set_progress(progress_);
  // Set never_timeout with the highest priority, SYSTEM_PRIORITY, so that the
  // notification never times out.
  notification->set_never_timeout(true);
  notification->SetSystemPriority();
  GetNotificationDisplayService()->Display(NotificationHandler::Type::TRANSIENT,
                                           *notification,
                                           /*metadata=*/nullptr);

  // Make sure we display the "in progress" state for a minimum amount of time.
  if (state_ == State::kUninitialized) {
    state_ = State::kInProgress;
    in_progress_timer_.Start(
        FROM_HERE, kMinInProgressTime,
        base::BindOnce(
            &CloudUploadNotificationManager::OnMinInProgressTimeReached,
            weak_ptr_factory_.GetWeakPtr()));
  }
}

void CloudUploadNotificationManager::ShowCompleteNotification() {
  DCHECK_EQ(state_, State::kComplete);
  std::unique_ptr<message_center::Notification> notification =
      CreateUploadCompleteNotification();
  // Set never_timeout with the highest priority, SYSTEM_PRIORITY, so that the
  // notification never times out.
  notification->set_never_timeout(true);
  notification->SetSystemPriority();
  // Close the progress notification before displaying the completed
  // notification.
  GetNotificationDisplayService()->Close(NotificationHandler::Type::TRANSIENT,
                                         notification_id_);
  GetNotificationDisplayService()->Display(NotificationHandler::Type::TRANSIENT,
                                           *notification,
                                           /*metadata=*/nullptr);

  // Start the timer to automatically dismiss the "Complete" notification if
  // "Show in folder" button not clicked.
  complete_notification_timer_.Start(
      FROM_HERE, kCompleteNotificationTime,
      base::BindOnce(&CloudUploadNotificationManager::CloseNotification,
                     weak_ptr_factory_.GetWeakPtr()));
}

void CloudUploadNotificationManager::MarkUploadComplete() {
  // Check if the "in progress" timeout has happened yet or not.
  if (state_ == State::kInProgress) {
    state_ = State::kWaitingForInProgressTimeout;
    // Re-show progress notification without the "Cancel" button as the upload
    // has now finished.
    ShowUploadProgress(progress_);
  } else if (state_ == State::kUninitialized ||
             state_ == State::kInProgressTimedOut) {
    // If the complete notification is shown before any progress notifications,
    // we don't run the kMinInProgressTime timeout.
    state_ = State::kComplete;
    ShowCompleteNotification();
  }
}

void CloudUploadNotificationManager::ShowUploadError(
    const std::string& message) {
  std::unique_ptr<message_center::Notification> notification =
      CreateUploadErrorNotification(message);
  // Set never_timeout with the highest priority, SYSTEM_PRIORITY, so that the
  // notification never times out.
  notification->set_never_timeout(true);
  notification->SetSystemPriority();
  GetNotificationDisplayService()->Display(NotificationHandler::Type::TRANSIENT,
                                           *notification,
                                           /*metadata=*/nullptr);
}

void CloudUploadNotificationManager::CloseNotification() {
  GetNotificationDisplayService()->Close(NotificationHandler::Type::TRANSIENT,
                                         notification_id_);
  in_progress_timer_.Stop();
  complete_notification_timer_.Stop();
  if (callback_) {
    std::move(callback_).Run();
  }
}

void CloudUploadNotificationManager::OnMinInProgressTimeReached() {
  if (state_ == State::kInProgress) {
    state_ = State::kInProgressTimedOut;
  } else if (state_ == State::kWaitingForInProgressTimeout) {
    state_ = State::kComplete;
    ShowCompleteNotification();
  }
}

void CloudUploadNotificationManager::HandleProgressNotificationClick(
    std::optional<int> button_index) {
  // If the "Cancel" button was pressed, rather than a click to somewhere
  // else in the notification.
  if (button_index && cancel_callback_ && CanCancel()) {
    // Cancel upload.
    std::move(cancel_callback_).Run();
  }

  CloseNotification();
}

void CloudUploadNotificationManager::HandleErrorNotificationClick(
    std::optional<int> button_index) {
  // If the "Sign in" button was pressed, rather than a click to somewhere
  // else in the notification.
  if (button_index) {
    // Request an ODFS mount which will trigger reauthentication.
    RequestODFSMount(profile_, base::DoNothing());
  }

  CloseNotification();
}

void CloudUploadNotificationManager::HandleCompleteNotificationClick(
    std::optional<int> button_index) {
  if (callback_for_testing_) {
    std::move(callback_for_testing_).Run(destination_path_);
  } else if (button_index) {
    // Show In Folder if button was pressed, rather than a click to somewhere
    // else in the notification.
    platform_util::ShowItemInFolder(profile_, destination_path_);
  }

  CloseNotification();
}

bool CloudUploadNotificationManager::CanCancel() {
  return state_ == State::kUninitialized || state_ == State::kInProgress ||
         state_ == State::kInProgressTimedOut;
}

}  // namespace ash::cloud_upload