// 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/file_manager/office_file_tasks.h"

#include <algorithm>
#include <initializer_list>
#include <string_view>

#include "base/metrics/histogram_macros.h"
#include "base/no_destructor.h"
#include "base/notreached.h"
#include "base/strings/string_util.h"
#include "base/types/cxx23_to_underlying.h"
#include "chrome/browser/apps/app_service/app_service_proxy.h"
#include "chrome/browser/apps/app_service/app_service_proxy_factory.h"
#include "chrome/browser/ash/drive/drive_integration_service.h"
#include "chrome/browser/ash/drive/drive_integration_service_factory.h"
#include "chrome/browser/ash/drive/file_system_util.h"
#include "chrome/browser/ash/file_manager/file_tasks.h"
#include "chrome/browser/ash/file_manager/virtual_file_tasks.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/ui/webui/ash/cloud_upload/cloud_open_metrics.h"
#include "chrome/browser/ui/webui/ash/cloud_upload/cloud_upload_dialog.h"
#include "chrome/browser/ui/webui/ash/cloud_upload/cloud_upload_util.h"
#include "chrome/browser/ui/webui/ash/office_fallback/office_fallback_ui.h"
#include "chrome/common/extensions/api/file_manager_private.h"
#include "chrome/common/pref_names.h"
#include "chromeos/ash/components/file_manager/app_id.h"
#include "components/pref_registry/pref_registry_syncable.h"
#include "components/prefs/pref_service.h"
#include "components/services/app_service/public/cpp/types_util.h"
#include "content/public/browser/network_service_instance.h"
#include "extensions/common/constants.h"

namespace file_manager::file_tasks {

namespace {

// The map with pairs Office file extensions with their corresponding
// `OfficeOpenExtensions` enum.
constexpr auto kExtensionToOfficeOpenExtensionsEnum =
    base::MakeFixedFlatMap<std::string_view, OfficeOpenExtensions>(
        {{".doc", OfficeOpenExtensions::kDoc},
         {".docm", OfficeOpenExtensions::kDocm},
         {".docx", OfficeOpenExtensions::kDocx},
         {".dotm", OfficeOpenExtensions::kDotm},
         {".dotx", OfficeOpenExtensions::kDotx},
         {".odp", OfficeOpenExtensions::kOdp},
         {".ods", OfficeOpenExtensions::kOds},
         {".odt", OfficeOpenExtensions::kOdt},
         {".pot", OfficeOpenExtensions::kPot},
         {".potm", OfficeOpenExtensions::kPotm},
         {".potx", OfficeOpenExtensions::kPotx},
         {".ppam", OfficeOpenExtensions::kPpam},
         {".pps", OfficeOpenExtensions::kPps},
         {".ppsm", OfficeOpenExtensions::kPpsm},
         {".ppsx", OfficeOpenExtensions::kPpsx},
         {".ppt", OfficeOpenExtensions::kPpt},
         {".pptm", OfficeOpenExtensions::kPptm},
         {".pptx", OfficeOpenExtensions::kPptx},
         {".xls", OfficeOpenExtensions::kXls},
         {".xlsb", OfficeOpenExtensions::kXlsb},
         {".xlsm", OfficeOpenExtensions::kXlsm},
         {".xlsx", OfficeOpenExtensions::kXlsx}});

OfficeOpenExtensions GetOfficeOpenExtension(const storage::FileSystemURL& url) {
  const std::string extension = base::ToLowerASCII(url.path().FinalExtension());
  auto itr = kExtensionToOfficeOpenExtensionsEnum.find(extension);
  if (itr != kExtensionToOfficeOpenExtensionsEnum.end()) {
    return itr->second;
  }
  return OfficeOpenExtensions::kOther;
}

std::optional<ash::office_fallback::FallbackReason>
DriveAvailabilityToFallbackReason(
    drive::util::DriveAvailability drive_availability) {
  switch (drive_availability) {
    case drive::util::DriveAvailability::
        kNotAvailableWhenDisableDrivePreferenceSet:
      return ash::office_fallback::FallbackReason::kDisableDrivePreferenceSet;
    case drive::util::DriveAvailability::kNotAvailableForAccountType:
      return ash::office_fallback::FallbackReason::kDriveDisabledForAccountType;
    case drive::util::DriveAvailability::
        kNotAvailableForUninitialisedLoginState:
    case drive::util::DriveAvailability::kNotAvailableInIncognito:
    case drive::util::DriveAvailability::kNotAvailableForTestImage:
      return ash::office_fallback::FallbackReason::kDriveDisabled;
    case drive::util::DriveAvailability::kAvailable:
      return std::nullopt;
  }
}

std::optional<ash::office_fallback::FallbackReason>
DriveConnectionStatusToFallbackReason(
    drive::util::ConnectionStatus drive_connection_status) {
  switch (drive_connection_status) {
    case drive::util::ConnectionStatus::kNoService:
      return ash::office_fallback::FallbackReason::kNoDriveService;
    case drive::util::ConnectionStatus::kNoNetwork:
      return ash::office_fallback::FallbackReason::kOffline;
    case drive::util::ConnectionStatus::kNotReady:
      return ash::office_fallback::FallbackReason::kDriveAuthenticationNotReady;
    case drive::util::ConnectionStatus::kMetered:
      return ash::office_fallback::FallbackReason::kMeteredConnection;
    case drive::util::ConnectionStatus::kConnected:
      return std::nullopt;
  }
}

bool AnyFileNeedsUploadToDrive(
    Profile* profile,
    const std::vector<storage::FileSystemURL>& file_urls) {
  return !std::ranges::all_of(file_urls, [profile](const auto& url) {
    return ash::cloud_upload::PathIsOnDriveFS(profile, url.path());
  });
}

}  // namespace

void RegisterOfficeProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
  registry->RegisterBooleanPref(prefs::kOfficeFilesAlwaysMoveToDrive, false);
  registry->RegisterBooleanPref(prefs::kOfficeFilesAlwaysMoveToOneDrive, false);
  registry->RegisterBooleanPref(prefs::kOfficeMoveConfirmationShownForDrive,
                                false);
  registry->RegisterBooleanPref(prefs::kOfficeMoveConfirmationShownForOneDrive,
                                false);
  registry->RegisterBooleanPref(
      prefs::kOfficeMoveConfirmationShownForLocalToDrive, false);
  registry->RegisterBooleanPref(
      prefs::kOfficeMoveConfirmationShownForLocalToOneDrive, false);
  registry->RegisterBooleanPref(
      prefs::kOfficeMoveConfirmationShownForCloudToDrive, false);
  registry->RegisterBooleanPref(
      prefs::kOfficeMoveConfirmationShownForCloudToOneDrive, false);
  registry->RegisterTimePref(prefs::kOfficeFileMovedToOneDrive, base::Time());
  registry->RegisterTimePref(prefs::kOfficeFileMovedToGoogleDrive,
                             base::Time());
}

void RecordOfficeOpenExtensionDriveMetric(
    const storage::FileSystemURL& file_url) {
  UMA_HISTOGRAM_ENUMERATION(
      file_manager::file_tasks::kOfficeOpenExtensionDriveMetricName,
      GetOfficeOpenExtension(file_url));
}

void RecordOfficeOpenExtensionOneDriveMetric(
    const storage::FileSystemURL& file_url) {
  UMA_HISTOGRAM_ENUMERATION(
      file_manager::file_tasks::kOfficeOpenExtensionOneDriveMetricName,
      GetOfficeOpenExtension(file_url));
}

bool ExecuteWebDriveOfficeTask(
    Profile* profile,
    const TaskDescriptor& task,
    const std::vector<storage::FileSystemURL>& file_urls,
    std::unique_ptr<ash::cloud_upload::CloudOpenMetrics> cloud_open_metrics) {
  const drive::util::DriveAvailability drive_availability =
      drive::util::CheckDriveEnabledAndDriveAvailabilityForProfile(profile);
  std::optional<ash::office_fallback::FallbackReason> fallback_reason_opt =
      DriveAvailabilityToFallbackReason(drive_availability);
  if (fallback_reason_opt) {
    ash::office_fallback::FallbackReason fallback_reason =
        fallback_reason_opt.value();
    return GetUserFallbackChoice(
        profile, task, file_urls, fallback_reason,
        base::BindOnce(&OnDialogChoiceReceived, profile, task, file_urls,
                       fallback_reason, std::move(cloud_open_metrics)));
  }

  const drive::util::ConnectionStatus drive_connection_status =
      drive::util::GetDriveConnectionStatus(profile);
  fallback_reason_opt =
      DriveConnectionStatusToFallbackReason(drive_connection_status);
  if (fallback_reason_opt &&
      (fallback_reason_opt !=
           ash::office_fallback::FallbackReason::kMeteredConnection ||
       AnyFileNeedsUploadToDrive(profile, file_urls))) {
    ash::office_fallback::FallbackReason fallback_reason =
        fallback_reason_opt.value();
    return GetUserFallbackChoice(
        profile, task, file_urls, fallback_reason,
        base::BindOnce(&OnDialogChoiceReceived, profile, task, file_urls,
                       fallback_reason, std::move(cloud_open_metrics)));
  }

  drive::DriveIntegrationService* integration_service =
      drive::DriveIntegrationServiceFactory::FindForProfile(profile);
  if (!integration_service || !integration_service->IsMounted() ||
      !integration_service->GetDriveFsInterface()) {
    ash::office_fallback::FallbackReason fallback_reason =
        ash::office_fallback::FallbackReason::kDriveFsInterfaceError;
    return GetUserFallbackChoice(
        profile, task, file_urls, fallback_reason,
        base::BindOnce(&OnDialogChoiceReceived, profile, task, file_urls,
                       fallback_reason, std::move(cloud_open_metrics)));
  }

  return ash::cloud_upload::CloudOpenTask::Execute(
      profile, file_urls, task, ash::cloud_upload::CloudProvider::kGoogleDrive,
      std::move(cloud_open_metrics));
}

bool ExecuteOpenInOfficeTask(
    Profile* profile,
    const TaskDescriptor& task,
    const std::vector<storage::FileSystemURL>& file_urls,
    std::unique_ptr<ash::cloud_upload::CloudOpenMetrics> cloud_open_metrics) {
  if (content::GetNetworkConnectionTracker()->IsOffline()) {
    ash::office_fallback::FallbackReason fallback_reason =
        ash::office_fallback::FallbackReason::kOffline;
    return GetUserFallbackChoice(
        profile, task, file_urls, fallback_reason,
        base::BindOnce(&OnDialogChoiceReceived, profile, task, file_urls,
                       fallback_reason, std::move(cloud_open_metrics)));
  }

  return ash::cloud_upload::CloudOpenTask::Execute(
      profile, file_urls, task, ash::cloud_upload::CloudProvider::kOneDrive,
      std::move(cloud_open_metrics));
}

void LaunchQuickOffice(Profile* profile,
                       const std::vector<storage::FileSystemURL>& file_urls) {
  const TaskDescriptor quick_office_task(
      extension_misc::kQuickOfficeComponentExtensionId, TASK_TYPE_FILE_HANDLER,
      kActionIdQuickOffice);

  ExecuteFileTask(
      profile, quick_office_task, file_urls,
      base::BindOnce(
          [](extensions::api::file_manager_private::TaskResult result,
             std::string error_message) {
            if (!error_message.empty()) {
              LOG(ERROR) << "Fallback to QuickOffice for opening office file "
                            "with error message: "
                         << error_message
                         << " and result: " << base::to_underlying(result);
            }
          }));

  return;
}

void LogOneDriveMetricsAfterFallback(
    ash::office_fallback::FallbackReason fallback_reason,
    ash::cloud_upload::OfficeTaskResult task_result,
    std::unique_ptr<ash::cloud_upload::CloudOpenMetrics> cloud_open_metrics) {
  switch (fallback_reason) {
    case ash::office_fallback::FallbackReason::kOffline:
      cloud_open_metrics->LogOneDriveOpenError(
          ash::cloud_upload::OfficeOneDriveOpenErrors::kOffline);
      break;
    case ash::office_fallback::FallbackReason::
        kAndroidOneDriveUnsupportedLocation:
      cloud_open_metrics->LogOneDriveOpenError(
          ash::cloud_upload::OfficeOneDriveOpenErrors::
              kAndroidOneDriveUnsupportedLocation);
      break;
    case ash::office_fallback::FallbackReason::kDriveDisabled:
    case ash::office_fallback::FallbackReason::kNoDriveService:
    case ash::office_fallback::FallbackReason::kDriveAuthenticationNotReady:
    case ash::office_fallback::FallbackReason::kDriveFsInterfaceError:
    case ash::office_fallback::FallbackReason::kMeteredConnection:
    case ash::office_fallback::FallbackReason::kDisableDrivePreferenceSet:
    case ash::office_fallback::FallbackReason::kDriveDisabledForAccountType:
    case ash::office_fallback::FallbackReason::kWaitingForUpload:
      NOTREACHED();
  }
  cloud_open_metrics->LogTaskResult(task_result);
}

void LogGoogleDriveMetricsAfterFallback(
    ash::office_fallback::FallbackReason fallback_reason,
    ash::cloud_upload::OfficeTaskResult task_result,
    std::unique_ptr<ash::cloud_upload::CloudOpenMetrics> cloud_open_metrics) {
  switch (fallback_reason) {
    case ash::office_fallback::FallbackReason::kOffline:
      cloud_open_metrics->LogGoogleDriveOpenError(
          ash::cloud_upload::OfficeDriveOpenErrors::kOffline);
      break;
    case ash::office_fallback::FallbackReason::kDriveDisabled:
      cloud_open_metrics->LogGoogleDriveOpenError(
          ash::cloud_upload::OfficeDriveOpenErrors::kDriveDisabled);
      break;
    case ash::office_fallback::FallbackReason::kNoDriveService:
      cloud_open_metrics->LogGoogleDriveOpenError(
          ash::cloud_upload::OfficeDriveOpenErrors::kNoDriveService);
      break;
    case ash::office_fallback::FallbackReason::kDriveAuthenticationNotReady:
      cloud_open_metrics->LogGoogleDriveOpenError(
          ash::cloud_upload::OfficeDriveOpenErrors::
              kDriveAuthenticationNotReady);
      break;
    case ash::office_fallback::FallbackReason::kDriveFsInterfaceError:
      cloud_open_metrics->LogGoogleDriveOpenError(
          ash::cloud_upload::OfficeDriveOpenErrors::kDriveFsInterface);
      break;
    case ash::office_fallback::FallbackReason::kMeteredConnection:
      cloud_open_metrics->LogGoogleDriveOpenError(
          ash::cloud_upload::OfficeDriveOpenErrors::kMeteredConnection);
      break;
    case ash::office_fallback::FallbackReason::kDisableDrivePreferenceSet:
      cloud_open_metrics->LogGoogleDriveOpenError(
          ash::cloud_upload::OfficeDriveOpenErrors::kDisableDrivePreferenceSet);
      break;
    case ash::office_fallback::FallbackReason::kDriveDisabledForAccountType:
      cloud_open_metrics->LogGoogleDriveOpenError(
          ash::cloud_upload::OfficeDriveOpenErrors::
              kDriveDisabledForAccountType);
      break;
    case ash::office_fallback::FallbackReason::kWaitingForUpload:
    case ash::office_fallback::FallbackReason::
        kAndroidOneDriveUnsupportedLocation:
      NOTREACHED();
  }
  cloud_open_metrics->LogTaskResult(task_result);
}

void OnDialogChoiceReceived(
    Profile* profile,
    const TaskDescriptor& task,
    const std::vector<storage::FileSystemURL>& file_urls,
    ash::office_fallback::FallbackReason fallback_reason,
    std::unique_ptr<ash::cloud_upload::CloudOpenMetrics> cloud_open_metrics,
    std::optional<const std::string> choice) {
  if (!choice.has_value()) {
    // The user's choice was unable to be retrieved.
    if (IsWebDriveOfficeTask(task)) {
      LogGoogleDriveMetricsAfterFallback(
          fallback_reason,
          ash::cloud_upload::OfficeTaskResult::kCannotGetFallbackChoice,
          std::move(cloud_open_metrics));
    } else if (IsOpenInOfficeTask(task)) {
      LogOneDriveMetricsAfterFallback(
          fallback_reason,
          ash::cloud_upload::OfficeTaskResult::kCannotGetFallbackChoice,
          std::move(cloud_open_metrics));
    }
    return;
  }

  if (choice.value() == ash::office_fallback::kDialogChoiceQuickOffice) {
    if (IsWebDriveOfficeTask(task)) {
      LogGoogleDriveMetricsAfterFallback(
          fallback_reason,
          ash::cloud_upload::OfficeTaskResult::kFallbackQuickOffice,
          std::move(cloud_open_metrics));
    } else if (IsOpenInOfficeTask(task)) {
      LogOneDriveMetricsAfterFallback(
          fallback_reason,
          ash::cloud_upload::OfficeTaskResult::kFallbackQuickOffice,
          std::move(cloud_open_metrics));
    }
    LaunchQuickOffice(profile, file_urls);
  } else if (choice.value() == ash::office_fallback::kDialogChoiceTryAgain) {
    // When retrying, the original open result is thrown away, so that
    // (likely the same) result codes from repeated retries are not counted.
    // Only the last open result is recorded: when the user either selects
    // QO or cancels.
    if (IsWebDriveOfficeTask(task)) {
      ExecuteWebDriveOfficeTask(profile, task, file_urls,
                                std::move(cloud_open_metrics));
    } else if (IsOpenInOfficeTask(task)) {
      ExecuteOpenInOfficeTask(profile, task, file_urls,
                              std::move(cloud_open_metrics));
    }
  } else if (choice.value() == ash::office_fallback::kDialogChoiceCancel) {
    if (IsWebDriveOfficeTask(task)) {
      LogGoogleDriveMetricsAfterFallback(
          fallback_reason,
          ash::cloud_upload::OfficeTaskResult::kCancelledAtFallback,
          std::move(cloud_open_metrics));
    } else if (IsOpenInOfficeTask(task)) {
      LogOneDriveMetricsAfterFallback(
          fallback_reason,
          ash::cloud_upload::OfficeTaskResult::kCancelledAtFallback,
          std::move(cloud_open_metrics));
    }
  } else if (choice.value() == ash::office_fallback::kDialogChoiceOk) {
    if (IsWebDriveOfficeTask(task)) {
      LogGoogleDriveMetricsAfterFallback(
          fallback_reason, ash::cloud_upload::OfficeTaskResult::kOkAtFallback,
          std::move(cloud_open_metrics));
    } else if (IsOpenInOfficeTask(task)) {
      LogOneDriveMetricsAfterFallback(
          fallback_reason, ash::cloud_upload::OfficeTaskResult::kOkAtFallback,
          std::move(cloud_open_metrics));
    }
  } else if (!choice.value().empty()) {
    LOG(ERROR) << "Unhandled response: " << choice.value();
  } else {
    // Always map an empty user response to a Cancel user response.
    // This can occur when the user logs out of the session. However,
    // since there could be other unknown causes, leave a log.
    LOG(ERROR) << "Empty user response";
    if (IsWebDriveOfficeTask(task)) {
      LogGoogleDriveMetricsAfterFallback(
          fallback_reason,
          ash::cloud_upload::OfficeTaskResult::kCancelledAtFallback,
          std::move(cloud_open_metrics));
    } else if (IsOpenInOfficeTask(task)) {
      LogOneDriveMetricsAfterFallback(
          fallback_reason,
          ash::cloud_upload::OfficeTaskResult::kCancelledAtFallback,
          std::move(cloud_open_metrics));
    }
  }
}

bool GetUserFallbackChoice(
    Profile* profile,
    const TaskDescriptor& task,
    const std::vector<storage::FileSystemURL>& file_urls,
    ash::office_fallback::FallbackReason fallback_reason,
    ash::office_fallback::DialogChoiceCallback callback) {
  // TODO(b/242685536) Add support for multi-file
  // selection so the OfficeFallbackDialog can display multiple file names and
  // `OnDialogChoiceReceived()` can open multiple files.
  std::vector<storage::FileSystemURL> first_url{file_urls.front()};

  // If QuickOffice is not installed, don't launch dialog.
  if (!IsQuickOfficeInstalled(profile)) {
    LOG(ERROR) << "Cannot fallback to QuickOffice when it is not installed";
    std::move(callback).Run(std::nullopt);
    return false;
  }

  std::string task_title;
  VirtualTask* virtual_task = FindVirtualTask(task);
  if (virtual_task) {
    task_title = virtual_task->title();
  }

  return ash::office_fallback::OfficeFallbackDialog::Show(
      first_url, fallback_reason, task_title, std::move(callback));
}

bool IsWebDriveOfficeTask(const TaskDescriptor& task) {
  const std::string action_id = ParseFilesAppActionId(task.action_id);
  bool is_web_drive_office_action_id =
      action_id == kActionIdWebDriveOfficeWord ||
      action_id == kActionIdWebDriveOfficeExcel ||
      action_id == kActionIdWebDriveOfficePowerPoint;
  return IsVirtualTask(task) && is_web_drive_office_action_id;
}

bool IsOpenInOfficeTask(const TaskDescriptor& task) {
  const std::string action_id = ParseFilesAppActionId(task.action_id);
  return IsVirtualTask(task) && action_id == kActionIdOpenInOffice;
}

bool IsQuickOfficeInstalled(Profile* profile) {
  apps::AppServiceProxy* proxy =
      apps::AppServiceProxyFactory::GetForProfile(profile);
  if (!proxy) {
    return false;
  }
  // The AppRegistryCache will contain the QuickOffice extension on Ash.
  bool installed = false;
  proxy->AppRegistryCache().ForOneApp(
      extension_misc::kQuickOfficeComponentExtensionId,
      [&installed](const apps::AppUpdate& update) {
        installed = apps_util::IsInstalled(update.Readiness());
      });
  return installed;
}

bool IsOfficeFile(const base::FilePath& path) {
  std::vector<std::set<std::string>> groups = {WordGroupExtensions(),
                                               ExcelGroupExtensions(),
                                               PowerPointGroupExtensions()};

  for (const std::set<std::string>& group : groups) {
    for (const std::string& extension : group) {
      if (path.MatchesExtension(extension)) {
        return true;
      }
    }
  }
  return false;
}

bool IsOfficeFileMimeType(const std::string& mime_type) {
  std::vector<std::set<std::string>> groups = {
      WordGroupMimeTypes(), ExcelGroupMimeTypes(), PowerPointGroupMimeTypes()};

  for (const std::set<std::string>& group : groups) {
    for (const std::string& office_mime_type : group) {
      if (mime_type == office_mime_type) {
        return true;
      }
    }
  }
  return false;
}

std::set<std::string> WordGroupExtensions() {
  static const base::NoDestructor<std::set<std::string>> extensions(
      std::initializer_list<std::string>({".doc", ".docx"}));
  return *extensions;
}

std::set<std::string> WordGroupMimeTypes() {
  static const base::NoDestructor<std::set<std::string>> mime_types(
      std::initializer_list<std::string>(
          {"application/msword",
           "application/"
           "vnd.openxmlformats-officedocument.wordprocessingml.document"}));
  return *mime_types;
}

bool HasExplicitDefaultFileHandler(Profile* profile,
                                   const std::string& extension) {
  std::string lower_extension = base::ToLowerASCII(extension);
  const base::Value::Dict& extension_task_prefs =
      profile->GetPrefs()->GetDict(prefs::kDefaultTasksBySuffix);
  return extension_task_prefs.contains(lower_extension);
}

void SetWordFileHandler(Profile* profile,
                        const TaskDescriptor& task,
                        bool replace_existing) {
  UpdateDefaultTask(profile, task, WordGroupExtensions(), WordGroupMimeTypes(),
                    replace_existing);
}

void SetWordFileHandlerToFilesSWA(Profile* profile,
                                  const std::string& action_id,
                                  bool replace_existing) {
  TaskDescriptor task(kFileManagerSwaAppId, TaskType::TASK_TYPE_WEB_APP,
                      ToSwaActionId(action_id));
  SetWordFileHandler(profile, task, replace_existing);
}

std::set<std::string> ExcelGroupExtensions() {
  static const base::NoDestructor<std::set<std::string>> extensions(
      std::initializer_list<std::string>({".xls", ".xlsm", ".xlsx"}));
  return *extensions;
}

std::set<std::string> ExcelGroupMimeTypes() {
  static const base::NoDestructor<std::set<std::string>> mime_types(
      std::initializer_list<std::string>(
          {"application/vnd.ms-excel",
           "application/vnd.ms-excel.sheet.macroEnabled.12",
           "application/"
           "vnd.openxmlformats-officedocument.spreadsheetml.sheet"}));
  return *mime_types;
}

void SetExcelFileHandler(Profile* profile,
                         const TaskDescriptor& task,
                         bool replace_existing) {
  UpdateDefaultTask(profile, task, ExcelGroupExtensions(),
                    ExcelGroupMimeTypes(), replace_existing);
}

void SetExcelFileHandlerToFilesSWA(Profile* profile,
                                   const std::string& action_id,
                                   bool replace_existing) {
  TaskDescriptor task(kFileManagerSwaAppId, TaskType::TASK_TYPE_WEB_APP,
                      ToSwaActionId(action_id));
  SetExcelFileHandler(profile, task, replace_existing);
}

std::set<std::string> PowerPointGroupExtensions() {
  static const base::NoDestructor<std::set<std::string>> extensions(
      std::initializer_list<std::string>({".ppt", ".pptx"}));
  return *extensions;
}

std::set<std::string> PowerPointGroupMimeTypes() {
  static const base::NoDestructor<std::set<std::string>> mime_types(
      std::initializer_list<std::string>(
          {"application/vnd.ms-powerpoint",
           "application/"
           "vnd.openxmlformats-officedocument.presentationml.presentation"}));
  return *mime_types;
}

void SetPowerPointFileHandler(Profile* profile,
                              const TaskDescriptor& task,
                              bool replace_existing) {
  UpdateDefaultTask(profile, task, PowerPointGroupExtensions(),
                    PowerPointGroupMimeTypes(), replace_existing);
}

void SetPowerPointFileHandlerToFilesSWA(Profile* profile,
                                        const std::string& action_id,
                                        bool replace_existing) {
  TaskDescriptor task(kFileManagerSwaAppId, TaskType::TASK_TYPE_WEB_APP,
                      ToSwaActionId(action_id));
  SetPowerPointFileHandler(profile, task, replace_existing);
}
void SetAlwaysMoveOfficeFilesToDrive(Profile* profile, bool always_move) {
  profile->GetPrefs()->SetBoolean(prefs::kOfficeFilesAlwaysMoveToDrive,
                                  always_move);
}

bool GetAlwaysMoveOfficeFilesToDrive(Profile* profile) {
  return profile->GetPrefs()->GetBoolean(prefs::kOfficeFilesAlwaysMoveToDrive);
}

void SetAlwaysMoveOfficeFilesToOneDrive(Profile* profile, bool always_move) {
  profile->GetPrefs()->SetBoolean(prefs::kOfficeFilesAlwaysMoveToOneDrive,
                                  always_move);
}

bool GetAlwaysMoveOfficeFilesToOneDrive(Profile* profile) {
  return profile->GetPrefs()->GetBoolean(
      prefs::kOfficeFilesAlwaysMoveToOneDrive);
}

void SetOfficeMoveConfirmationShownForDrive(Profile* profile, bool complete) {
  profile->GetPrefs()->SetBoolean(prefs::kOfficeMoveConfirmationShownForDrive,
                                  complete);
}

bool GetOfficeMoveConfirmationShownForDrive(Profile* profile) {
  return profile->GetPrefs()->GetBoolean(
      prefs::kOfficeMoveConfirmationShownForDrive);
}

void SetOfficeMoveConfirmationShownForOneDrive(Profile* profile,
                                               bool complete) {
  profile->GetPrefs()->SetBoolean(
      prefs::kOfficeMoveConfirmationShownForOneDrive, complete);
}

bool GetOfficeMoveConfirmationShownForOneDrive(Profile* profile) {
  return profile->GetPrefs()->GetBoolean(
      prefs::kOfficeMoveConfirmationShownForOneDrive);
}

void SetOfficeMoveConfirmationShownForLocalToDrive(Profile* profile,
                                                   bool shown) {
  profile->GetPrefs()->SetBoolean(
      prefs::kOfficeMoveConfirmationShownForLocalToDrive, shown);
}

bool GetOfficeMoveConfirmationShownForLocalToDrive(Profile* profile) {
  return profile->GetPrefs()->GetBoolean(
      prefs::kOfficeMoveConfirmationShownForLocalToDrive);
}

void SetOfficeMoveConfirmationShownForLocalToOneDrive(Profile* profile,
                                                      bool shown) {
  profile->GetPrefs()->SetBoolean(
      prefs::kOfficeMoveConfirmationShownForLocalToOneDrive, shown);
}

bool GetOfficeMoveConfirmationShownForLocalToOneDrive(Profile* profile) {
  return profile->GetPrefs()->GetBoolean(
      prefs::kOfficeMoveConfirmationShownForLocalToOneDrive);
}

void SetOfficeMoveConfirmationShownForCloudToDrive(Profile* profile,
                                                   bool shown) {
  profile->GetPrefs()->SetBoolean(
      prefs::kOfficeMoveConfirmationShownForCloudToDrive, shown);
}

bool GetOfficeMoveConfirmationShownForCloudToDrive(Profile* profile) {
  return profile->GetPrefs()->GetBoolean(
      prefs::kOfficeMoveConfirmationShownForCloudToDrive);
}

void SetOfficeMoveConfirmationShownForCloudToOneDrive(Profile* profile,
                                                      bool shown) {
  profile->GetPrefs()->SetBoolean(
      prefs::kOfficeMoveConfirmationShownForCloudToOneDrive, shown);
}

bool GetOfficeMoveConfirmationShownForCloudToOneDrive(Profile* profile) {
  return profile->GetPrefs()->GetBoolean(
      prefs::kOfficeMoveConfirmationShownForCloudToOneDrive);
}

void SetOfficeFileMovedToOneDrive(Profile* profile, base::Time moved) {
  profile->GetPrefs()->SetTime(prefs::kOfficeFileMovedToOneDrive, moved);
}

void SetOfficeFileMovedToGoogleDrive(Profile* profile, base::Time moved) {
  profile->GetPrefs()->SetTime(prefs::kOfficeFileMovedToGoogleDrive, moved);
}

void RemoveFilesSWAWordFileHandler(Profile* profile,
                                   const std::string& action_id) {
  TaskDescriptor task(kFileManagerSwaAppId, TaskType::TASK_TYPE_WEB_APP,
                      ToSwaActionId(action_id));
  RemoveDefaultTask(profile, task, WordGroupExtensions(), WordGroupMimeTypes());
}

void RemoveFilesSWAExcelFileHandler(Profile* profile,
                                    const std::string& action_id) {
  TaskDescriptor task(kFileManagerSwaAppId, TaskType::TASK_TYPE_WEB_APP,
                      ToSwaActionId(action_id));
  RemoveDefaultTask(profile, task, ExcelGroupExtensions(),
                    ExcelGroupMimeTypes());
}

void RemoveFilesSWAPowerPointFileHandler(Profile* profile,
                                         const std::string& action_id) {
  TaskDescriptor task(kFileManagerSwaAppId, TaskType::TASK_TYPE_WEB_APP,
                      ToSwaActionId(action_id));
  RemoveDefaultTask(profile, task, PowerPointGroupExtensions(),
                    PowerPointGroupMimeTypes());
}

}  // namespace file_manager::file_tasks