// Copyright 2018 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/web_applications/preinstalled_web_app_manager.h"

#include <iterator>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <utility>
#include <variant>
#include <vector>

#include "base/auto_reset.h"
#include "base/containers/contains.h"
#include "base/feature_list.h"
#include "base/files/file_enumerator.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/functional/bind.h"
#include "base/functional/callback.h"
#include "base/functional/concurrent_closures.h"
#include "base/json/json_file_value_serializer.h"
#include "base/json/json_reader.h"
#include "base/memory/scoped_refptr.h"
#include "base/metrics/histogram_functions.h"
#include "base/observer_list.h"
#include "base/scoped_observation.h"
#include "base/strings/strcat.h"
#include "base/strings/utf_string_conversions.h"
#include "base/task/sequenced_task_runner.h"
#include "base/task/thread_pool.h"
#include "base/threading/scoped_blocking_call.h"
#include "build/build_config.h"
// TODO(crbug.com/40251079): Remove or at least isolate circular dependencies on
// app service by moving this code to //c/b/web_applications/adjustments, or
// flip entire dependency so web_applications depends on app_service.
#include "chrome/browser/apps/app_service/app_service_proxy.h"  // nogncheck
#include "chrome/browser/apps/app_service/app_service_proxy_factory.h"  // nogncheck
#include "chrome/browser/apps/user_type_filter.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/web_applications/callback_utils.h"
#include "chrome/browser/web_applications/extension_status_utils.h"
#include "chrome/browser/web_applications/externally_managed_app_manager.h"
#include "chrome/browser/web_applications/file_utils_wrapper.h"
#include "chrome/browser/web_applications/preinstalled_app_install_features.h"
#include "chrome/browser/web_applications/preinstalled_web_app_config_utils.h"
#include "chrome/browser/web_applications/preinstalled_web_app_utils.h"
#include "chrome/browser/web_applications/preinstalled_web_apps/preinstalled_web_apps.h"
#include "chrome/browser/web_applications/user_uninstalled_preinstalled_web_app_prefs.h"
#include "chrome/browser/web_applications/web_app.h"
#include "chrome/browser/web_applications/web_app_helpers.h"
#include "chrome/browser/web_applications/web_app_install_utils.h"
#include "chrome/browser/web_applications/web_app_management_type.h"
#include "chrome/browser/web_applications/web_app_provider.h"
#include "chrome/browser/web_applications/web_app_registrar.h"
#include "chrome/browser/web_applications/web_app_ui_manager.h"
#include "chrome/browser/web_applications/web_app_utils.h"
#include "chrome/common/chrome_features.h"
#include "chrome/common/pref_names.h"
#include "components/ntp_tiles/most_visited_sites.h"
#include "components/pref_registry/pref_registry_syncable.h"
#include "components/prefs/pref_service.h"
#include "components/services/app_service/public/cpp/app_registry_cache.h"
#include "components/services/app_service/public/cpp/types_util.h"
#include "components/version_info/version_info.h"
#include "components/webapps/browser/install_result_code.h"
#include "components/webapps/common/constants.h"
#include "content/public/browser/browser_thread.h"
#include "extensions/common/constants.h"
#include "ui/events/devices/device_data_manager.h"
#include "ui/events/devices/input_device_event_observer.h"
#include "ui/events/devices/touchscreen_device.h"
#include "url/gurl.h"

#if BUILDFLAG(IS_CHROMEOS)
// TODO(http://b/333583704): Revert CL which added this include after migration.
#include "ash/constants/ash_switches.h"
#include "ash/constants/web_app_id_constants.h"
#include "chrome/browser/ash/profiles/profile_helper.h"
#include "chromeos/ash/components/report/utils/time_utils.h"
#include "chromeos/ash/experiences/arc/arc_util.h"
#endif  // BUILDFLAG(IS_CHROMEOS)

namespace web_app {

namespace {

bool g_skip_startup_for_testing_ = false;
bool g_bypass_awaiting_dependencies_for_testing_ = false;
bool g_bypass_offline_manifest_requirement_for_testing_ = false;
bool g_override_previous_user_uninstall_for_testing_ = false;
const base::Value::List* g_configs_for_testing = nullptr;
FileUtilsWrapper* g_file_utils_for_testing = nullptr;

const char kHistogramMigrationDisabledReason[] =
    "WebApp.Preinstalled.DisabledReason";

// These values are reported to UMA, do not modify them.
enum class DisabledReason {
  kNotDisabled = 0,
  kUninstallPreinstalledAppsNotEnabled = 1,
  kUninstallUserTypeNotAllowed = 2,
  kUninstallGatedFeatureNotEnabled = 3,
  kIgnoreGatedFeatureNotEnabled = 4,
  kIgnoreArcAvailable = 5,
  kIgnoreTabletFormFactor = 6,
  kIgnoreNotNewUser = 7,
  kIgnoreNotPreviouslyPreinstalled = 8,
  kUninstallReplacingAppBlockedByPolicy = 9,
  kUninstallReplacingAppForceInstalled = 10,
  kInstallReplacingAppStillInstalled = 11,
  kUninstallDefaultAppAndAppsToReplaceUninstalled = 12,
  kIgnoreReplacingAppUninstalledByUser = 13,
  kIgnoreStylusRequired = 14,
  kInstallOverridePreviousUserUninstall = 15,
  kIgnoreStylusRequiredNoDeviceData = 16,
  kIgnorePreviouslyUninstalledByUser = 17,
  kMaxValue = kIgnorePreviouslyUninstalledByUser
};

struct LoadedConfig {
  base::Value contents;
  base::FilePath file;
};

struct LoadedConfigs {
  std::vector<LoadedConfig> configs;
  std::vector<std::string> errors;
};

std::optional<bool> HasStylusEnabledTouchscreen() {
  return DeviceHasStylusEnabledTouchscreen();
}

LoadedConfigs LoadConfigsBlocking(
    const std::vector<base::FilePath>& config_dirs) {
  base::ScopedBlockingCall scoped_blocking_call(FROM_HERE,
                                                base::BlockingType::MAY_BLOCK);

  LoadedConfigs result;
  base::FilePath::StringType extension(FILE_PATH_LITERAL(".json"));

  for (const auto& config_dir : config_dirs) {
    base::FileEnumerator json_files(config_dir,
                                    false,  // Recursive.
                                    base::FileEnumerator::FILES);
    for (base::FilePath file = json_files.Next(); !file.empty();
         file = json_files.Next()) {
      if (!file.MatchesExtension(extension)) {
        continue;
      }

      JSONFileValueDeserializer deserializer(file);
      std::string error_msg;
      std::unique_ptr<base::Value> app_config =
          deserializer.Deserialize(nullptr, &error_msg);
      if (!app_config) {
        result.errors.push_back(base::StrCat(
            {file.AsUTF8Unsafe(), " was not valid JSON: ", error_msg}));
        VLOG(1) << result.errors.back();
        continue;
      }
      result.configs.push_back(
          {.contents = std::move(*app_config), .file = file});
    }
  }
  return result;
}

struct ParsedConfigs {
  std::vector<ExternalInstallOptions> options_list;
  std::vector<std::string> errors;
};

ParsedConfigs ParseConfigsBlocking(LoadedConfigs loaded_configs) {
  ParsedConfigs result;
  result.errors = std::move(loaded_configs.errors);

  scoped_refptr<FileUtilsWrapper> file_utils =
      g_file_utils_for_testing ? base::WrapRefCounted(g_file_utils_for_testing)
                               : base::MakeRefCounted<FileUtilsWrapper>();

  for (const LoadedConfig& loaded_config : loaded_configs.configs) {
    OptionsOrError parse_result =
        ParseConfig(*file_utils, loaded_config.file.DirName(),
                    loaded_config.file, loaded_config.contents);
    if (ExternalInstallOptions* options =
            std::get_if<ExternalInstallOptions>(&parse_result)) {
      result.options_list.push_back(std::move(*options));
    } else {
      result.errors.push_back(std::move(std::get<std::string>(parse_result)));
      VLOG(1) << result.errors.back();
    }
  }

  return result;
}

struct SynchronizeDecision {
  enum {
    // Ensures the web app preinstall gets removed.
    kUninstall,

    // Ensures the web app gets preinstalled.
    kInstall,

    // Leaves the web app preinstall state alone.
    // Prefer kIgnore over kUninstall in most cases of disabling a config as
    // uninstalling can have permanent consequences for users when bugs are hit.
    // See crbug.com/1393284 and crbug.com/1363004 for past incidents.
    kIgnore,
  } type;
  // TODO(crbug.com/40253925): Rename DisabledReason to
  // SynchronizeDecisionReason since it applies to every install decision.
  DisabledReason reason;
  std::string log;
};

SynchronizeDecision GetSynchronizeDecision(
    const ExternalInstallOptions& options,
    Profile* profile,
    WebAppRegistrar* registrar,
    bool preinstalled_apps_enabled_in_prefs,
    bool is_new_user,
    const std::string& user_type,
    size_t& corrupt_user_uninstall_prefs_count) {
  DCHECK(registrar);

  // This function encodes the exceptions to the standard preinstalled web app
  // configs; situations in which the preinstall should be removed, added or be
  // left untouched.
  //
  // The priority of these decisions is ordered:
  // kUninstall > kInstall > kIgnore > kInstall (default).

  /////////////////////////
  // kUninstall conditions.
  /////////////////////////

  if (!preinstalled_apps_enabled_in_prefs) {
    return {
        .type = SynchronizeDecision::kUninstall,
        .reason = DisabledReason::kUninstallPreinstalledAppsNotEnabled,
        .log = base::StrCat({options.install_url.spec(),
                             " uninstall by preinstalled_apps pref setting."})};
  }

  // Remove if not applicable to current user type.
  DCHECK_GT(options.user_type_allowlist.size(), 0u);
  if (!base::Contains(options.user_type_allowlist, user_type)) {
    return {.type = SynchronizeDecision::kUninstall,
            .reason = DisabledReason::kUninstallUserTypeNotAllowed,
            .log = base::StrCat({options.install_url.spec(),
                                 " uninstall for user type: ", user_type})};
  }

  // Remove if gated on a disabled feature.
  if (options.gate_on_feature &&
      !IsPreinstalledAppInstallFeatureEnabled(*options.gate_on_feature)) {
    return {.type = SynchronizeDecision::kUninstall,
            .reason = DisabledReason::kUninstallGatedFeatureNotEnabled,
            .log = base::StrCat({options.install_url.spec(),
                                 " uninstall because feature is disabled: ",
                                 *options.gate_on_feature})};
  }

  // Remove if any apps to replace are blocked or force installed by admin
  // policy.
  for (const webapps::AppId& app_id : options.uninstall_and_replace) {
    if (extensions::IsExtensionBlockedByPolicy(profile, app_id)) {
      return {.type = SynchronizeDecision::kUninstall,
              .reason = DisabledReason::kUninstallReplacingAppBlockedByPolicy,
              .log = base::StrCat({options.install_url.spec(),
                                   " uninstall due to admin policy blocking "
                                   "replacement Extension."})};
    }
    std::u16string reason;
    if (extensions::IsExtensionForceInstalled(profile, app_id, &reason)) {
      return {
          .type = SynchronizeDecision::kUninstall,
          .reason = DisabledReason::kUninstallReplacingAppForceInstalled,
          .log = base::StrCat(
              {options.install_url.spec(),
               " uninstall due to admin policy force installing replacement "
               "Extension: ",
               base::UTF16ToUTF8(reason)})};
    }
  }
#if !BUILDFLAG(IS_CHROMEOS)
  // Remove if it's a default app and the apps to replace are not installed and
  // default extension apps are not performing new installation.
  if (options.gate_on_feature && !options.uninstall_and_replace.empty() &&
      !extensions::DidPreinstalledAppsPerformNewInstallation(profile)) {
    for (const webapps::AppId& app_id : options.uninstall_and_replace) {
      // First time migration and the app to replace is uninstalled as it passed
      // the last code block. Save the information that the app was
      // uninstalled by user.
      if (!WasMigrationRun(profile, *options.gate_on_feature)) {
        if (extensions::IsPreinstalledAppId(app_id)) {
          MarkPreinstalledAppAsUninstalled(profile, app_id);
          return {.type = SynchronizeDecision::kUninstall,
                  .reason = DisabledReason::
                      kUninstallDefaultAppAndAppsToReplaceUninstalled,
                  .log = base::StrCat(
                      {options.install_url.spec(),
                       "uninstall because its default app and apps to replace ",
                       "were uninstalled."})};
        }
      } else {
        // Not first time migration, can't determine if the app to replace is
        // uninstalled by user as the migration is already run, use the pref
        // saved in first migration.
        if (WasPreinstalledAppUninstalled(profile, app_id)) {
          return {.type = SynchronizeDecision::kUninstall,
                  .reason = DisabledReason::
                      kUninstallDefaultAppAndAppsToReplaceUninstalled,
                  .log = base::StrCat(
                      {options.install_url.spec(),
                       "uninstall because its default app and apps to replace "
                       "were uninstalled."})};
        }
      }
    }
  }
#endif  // !BUILDFLAG(IS_CHROMEOS)

  ///////////////////////
  // kInstall conditions.
  ///////////////////////

  bool was_previously_uninstalled_by_user =
      UserUninstalledPreinstalledWebAppPrefs(profile->GetPrefs())
          .LookUpAppIdByInstallUrl(options.install_url)
          .has_value();
  if (options.override_previous_user_uninstall &&
      was_previously_uninstalled_by_user) {
    return {
        .type = SynchronizeDecision::kInstall,
        .reason = DisabledReason::kInstallOverridePreviousUserUninstall,
        .log = base::StrCat({options.install_url.spec(),
                             " install overrides previous user uninstall."})};
  }

  // Ensure install if any apps to replace are installed as installation
  // includes uninstall_and_replace-ing the specified apps.
  for (const webapps::AppId& app_id : options.uninstall_and_replace) {
    if (extensions::IsExtensionInstalled(profile, app_id)) {
      return {
          .type = SynchronizeDecision::kInstall,
          .reason = DisabledReason::kInstallReplacingAppStillInstalled,
          .log = base::StrCat({options.install_url.spec(),
                               " install to replace existing Chrome app."})};
    }
  }

  //////////////////////
  // kIgnore conditions.
  //////////////////////

  if (was_previously_uninstalled_by_user) {
    return {.type = SynchronizeDecision::kIgnore,
            .reason = DisabledReason::kIgnorePreviouslyUninstalledByUser,
            .log = base::StrCat(
                {options.install_url.spec(),
                 " ignore because previously uninstalled by user"})};
  }

  // This option means to ignore if the feature flag is not enabled and leave
  // any existing installations alone.
  if (options.gate_on_feature_or_installed &&
      !IsPreinstalledAppInstallFeatureEnabled(
          *options.gate_on_feature_or_installed)) {
    return {.type = SynchronizeDecision::kIgnore,
            .reason = DisabledReason::kIgnoreGatedFeatureNotEnabled,
            .log = base::StrCat(
                {options.install_url.spec(), " ignore because the feature ",
                 *options.gate_on_feature_or_installed, " is disabled"})};
  }

#if BUILDFLAG(IS_CHROMEOS)
  if (options.disable_if_arc_supported && arc::IsArcAvailable()) {
    return {.type = SynchronizeDecision::kIgnore,
            .reason = DisabledReason::kIgnoreArcAvailable,
            .log = base::StrCat({options.install_url.spec(),
                                 " ignore because ARC is available."})};
  }

  if (options.disable_if_tablet_form_factor &&
      ash::switches::IsTabletFormFactor()) {
    return {.type = SynchronizeDecision::kIgnore,
            .reason = DisabledReason::kIgnoreTabletFormFactor,
            .log = base::StrCat({options.install_url.spec(),
                                 " ignore because device is tablet."})};
  }
#endif  // BUILDFLAG(IS_CHROMEOS)

  if (options.only_for_new_users && !is_new_user) {
    return {.type = SynchronizeDecision::kIgnore,
            .reason = DisabledReason::kIgnoreNotNewUser,
            .log = base::StrCat({options.install_url.spec(),
                                 " ignore because user is not new."})};
  }

  // This option means to ignore installations of the config, it came from a
  // time before SynchronizeDecision::kIgnore was added and so is worded
  // differently.
  if (options.only_if_previously_preinstalled) {
    return {.type = SynchronizeDecision::kIgnore,
            .reason = DisabledReason::kIgnoreNotPreviouslyPreinstalled,
            .log = base::StrCat(
                {options.install_url.spec(),
                 " ignore by config (only_if_previously_preinstalled)."})};
  }

  // Ignore if any apps to replace were previously uninstalled.
  for (const webapps::AppId& app_id : options.uninstall_and_replace) {
    if (extensions::IsExternalExtensionUninstalled(profile, app_id)) {
      return {.type = SynchronizeDecision::kIgnore,
              .reason = DisabledReason::kIgnoreReplacingAppUninstalledByUser,
              .log = base::StrCat(
                  {options.install_url.spec(),
                   " ignore because apps to replace were uninstalled."})};
    }
  }

  // Only install if device has a built-in touch screen with stylus support.
  if (options.disable_if_touchscreen_with_stylus_not_supported) {
    std::optional<bool> has_stylus = HasStylusEnabledTouchscreen();

    if (!has_stylus.has_value()) {
      return {.type = SynchronizeDecision::kIgnore,
              .reason = DisabledReason::kIgnoreStylusRequiredNoDeviceData,
              .log = base::StrCat(
                  {options.install_url.spec(),
                   " ignore because touchscreen device information is "
                   "unavailable"})};
    }

    if (!has_stylus.value()) {
      return {.type = SynchronizeDecision::kIgnore,
              .reason = DisabledReason::kIgnoreStylusRequired,
              .log = base::StrCat(
                  {options.install_url.spec(),
                   " ignore because the device does not have a built-in "
                   "touchscreen with stylus support."})};
    }
  }

  ////////////////////
  // Default scenario.
  ////////////////////

  return {
      .type = SynchronizeDecision::kInstall,
      .reason = DisabledReason::kNotDisabled,
      .log = base::StrCat({options.install_url.spec(), " regular install"})};
}

bool IsReinstallPastMilestoneNeededSinceLastSync(
    const PrefService& prefs,
    int force_reinstall_for_milestone) {
  std::string last_preinstall_synchronize_milestone =
      prefs.GetString(prefs::kWebAppsLastPreinstallSynchronizeVersion);

  return IsReinstallPastMilestoneNeeded(last_preinstall_synchronize_milestone,
                                        version_info::GetMajorVersionNumber(),
                                        force_reinstall_for_milestone);
}

bool ShouldForceReinstall(const ExternalInstallOptions& options,
                          const PrefService& prefs,
                          const WebAppRegistrar& registrar) {
  if (options.force_reinstall_for_milestone &&
      IsReinstallPastMilestoneNeededSinceLastSync(
          prefs, options.force_reinstall_for_milestone.value())) {
    return true;
  }

  // TODO(crbug.com/40261748): Add metrics for this event.
  const WebApp* app = registrar.LookUpAppByInstallSourceInstallUrl(
      WebAppManagement::Type::kDefault, options.install_url);
  if (app && LooksLikePlaceholder(*app)) {
    return true;
  }

  return false;
}

#if BUILDFLAG(IS_CHROMEOS)
// Modifies ExternalInstallOptions to be force_reinstall = true if they are
// already installed but their uninstall_and_replace apps are also installed,
// this is to re-trigger the migration logic that happens at the end of
// installation. May not do anything depending on feature flags and platform.
void MaybeForceInstallForRemigration(
    std::vector<ExternalInstallOptions>* options_list,
    Profile* profile,
    const WebAppRegistrar& registrar) {
  bool always_migrate_calculator = base::FeatureList::IsEnabled(
      features::kPreinstalledWebAppAlwaysMigrateCalculator);
  bool always_migrate =
      base::FeatureList::IsEnabled(features::kPreinstalledWebAppAlwaysMigrate);
  if (!always_migrate_calculator && !always_migrate) {
    return;
  }

  // Record Calculator remigration metrics.
  bool calculator_web_app_installed =
      registrar.IsInstalledByDefaultManagement(ash::kCalculatorAppId);
  bool calculator_chrome_app_installed = extensions::IsExtensionInstalled(
      profile, extension_misc::kCalculatorAppId);
  base::UmaHistogramBoolean(
      "WebApp.Preinstalled.CalculatorForceMigration.WebAppInstalled",
      calculator_web_app_installed);
  base::UmaHistogramBoolean(
      "WebApp.Preinstalled.CalculatorForceMigration."
      "ChromeAppAndWebAppInstalled",
      calculator_chrome_app_installed && calculator_web_app_installed);
  base::UmaHistogramBoolean(
      "WebApp.Preinstalled.CalculatorForceMigration.ChromeAppNoWebAppInstalled",
      calculator_chrome_app_installed && !calculator_web_app_installed);

  bool any_migration_needed = false;
  bool calculator_migration_needed = false;
  for (ExternalInstallOptions& options : *options_list) {
    // Ignore preinstalled apps that aren't currently installed.
    if (!registrar.LookUpAppByInstallSourceInstallUrl(
            WebAppManagement::Type::kDefault, options.install_url)) {
      continue;
    }

    // Force migration if corresponding Chrome app is installed, according to
    // feature flags.
    for (const std::string& app_id : options.uninstall_and_replace) {
      bool migration_needed = false;
      if (extensions::IsExtensionInstalled(profile, app_id)) {
        if (always_migrate_calculator &&
            app_id == extension_misc::kCalculatorAppId) {
          calculator_migration_needed = true;
          migration_needed = true;
        }

        if (always_migrate) {
          migration_needed = true;
        }
      }

      if (migration_needed) {
        any_migration_needed = true;
        options.force_reinstall = true;
        break;
      }
    }
  }

  base::UmaHistogramBoolean("WebApp.Preinstalled.ChromeAppMigrationNeeded",
                            any_migration_needed);
  base::UmaHistogramBoolean(
      "WebApp.Preinstalled.CalculatorForceMigration.MigrationTriggered",
      calculator_migration_needed);
}
#endif  // BUILDFLAG(IS_CHROMEOS)

}  // namespace

class PreinstalledWebAppManager::DeviceDataInitializedEvent
    : public ui::InputDeviceEventObserver {
 public:
  DeviceDataInitializedEvent() = default;
  DeviceDataInitializedEvent(const DeviceDataInitializedEvent&) = delete;
  DeviceDataInitializedEvent& operator=(const DeviceDataInitializedEvent&) =
      delete;

  // Posts a `task` to be run once ui::DeviceDataManager has complete device
  // lists. If device lists are already complete, or DeviceDataManager is not
  // available, the task will be posted immediately.
  void Post(base::OnceClosure task);

 private:
  // ui::InputDeviceEventObserver:
  void OnDeviceListsComplete() override;

  // Task to run once ui::DeviceDataManager initialization is complete.
  base::OnceClosure initialized_task_;

  base::ScopedObservation<ui::DeviceDataManager, ui::InputDeviceEventObserver>
      device_data_observation_{this};
};

void PreinstalledWebAppManager::DeviceDataInitializedEvent::Post(
    base::OnceClosure task) {
  // DeviceDataManager does not exist on all platforms, but on platforms where
  // it exists, it's always created early in startup, so HasInstance() is a
  // reliable indicator of availability. However, loading device information is
  // asynchronous and may not have completed by this point.
  if (!ui::DeviceDataManager::HasInstance() ||
      ui::DeviceDataManager::GetInstance()->AreDeviceListsComplete()) {
    base::SequencedTaskRunner::GetCurrentDefault()->PostTask(FROM_HERE,
                                                             std::move(task));
  } else {
    DCHECK(!device_data_observation_.IsObserving());
    device_data_observation_.Observe(ui::DeviceDataManager::GetInstance());
    initialized_task_ = std::move(task);
  }
}

void PreinstalledWebAppManager::DeviceDataInitializedEvent::
    OnDeviceListsComplete() {
  std::move(initialized_task_).Run();
  device_data_observation_.Reset();
}

const char* PreinstalledWebAppManager::kHistogramEnabledCount =
    "WebApp.Preinstalled.EnabledCount";
const char* PreinstalledWebAppManager::kHistogramDisabledCount =
    "WebApp.Preinstalled.DisabledCount";
const char* PreinstalledWebAppManager::kHistogramConfigErrorCount =
    "WebApp.Preinstalled.ConfigErrorCount";
const char*
    PreinstalledWebAppManager::kHistogramCorruptUserUninstallPrefsCount =
        "WebApp.Preinstalled.CorruptUserUninstallPrefsCount";
const char* PreinstalledWebAppManager::kHistogramInstallResult =
    "Webapp.InstallResult.Default";
const char* PreinstalledWebAppManager::kHistogramInstallCount =
    "WebApp.Preinstalled.InstallCount";
const char* PreinstalledWebAppManager::kHistogramUninstallTotalCount =
    "WebApp.Preinstalled.UninstallTotalCount";
const char* PreinstalledWebAppManager::kHistogramUninstallSourceRemovedCount =
    "WebApp.Preinstalled.UninstallSourceRemovedCount";
const char* PreinstalledWebAppManager::kHistogramUninstallAppRemovedCount =
    "WebApp.Preinstalled.UninstallAppRemovedCount";
const char* PreinstalledWebAppManager::kHistogramUninstallAndReplaceCount =
    "WebApp.Preinstalled.UninstallAndReplaceCount";
const char*
    PreinstalledWebAppManager::kHistogramAppToReplaceStillInstalledCount =
        "WebApp.Preinstalled.AppToReplaceStillInstalledCount";
const char* PreinstalledWebAppManager::
    kHistogramAppToReplaceStillDefaultInstalledCount =
        "WebApp.Preinstalled.AppToReplaceStillDefaultInstalledCount";
const char* PreinstalledWebAppManager::
    kHistogramAppToReplaceStillInstalledInShelfCount =
        "WebApp.Preinstalled.AppToReplaceStillInstalledInShelfCount";

void PreinstalledWebAppManager::RegisterProfilePrefs(
    user_prefs::PrefRegistrySyncable* registry) {
  registry->RegisterStringPref(prefs::kWebAppsLastPreinstallSynchronizeVersion,
                               "");
  registry->RegisterListPref(webapps::kWebAppsMigratedPreinstalledApps);
  registry->RegisterListPref(prefs::kWebAppsDidMigrateDefaultChromeApps);
  registry->RegisterListPref(prefs::kWebAppsUninstalledDefaultChromeApps);
}

// static
base::AutoReset<bool> PreinstalledWebAppManager::SkipStartupForTesting() {
  return {&g_skip_startup_for_testing_, true};
}

// static
base::AutoReset<bool>
PreinstalledWebAppManager::BypassAwaitingDependenciesForTesting() {
  return {&g_bypass_awaiting_dependencies_for_testing_, true};
}

// static
base::AutoReset<bool>
PreinstalledWebAppManager::BypassOfflineManifestRequirementForTesting() {
  return {&g_bypass_offline_manifest_requirement_for_testing_, true};
}

// static
base::AutoReset<bool>
PreinstalledWebAppManager::OverridePreviousUserUninstallConfigForTesting() {
  return {&g_override_previous_user_uninstall_for_testing_, true};
}

// static
base::AutoReset<const base::Value::List*>
PreinstalledWebAppManager::SetConfigsForTesting(
    const base::Value::List* configs) {
  return {&g_configs_for_testing, configs, nullptr};
}

// static
base::AutoReset<FileUtilsWrapper*>
PreinstalledWebAppManager::SetFileUtilsForTesting(
    FileUtilsWrapper* file_utils) {
  return {&g_file_utils_for_testing, file_utils, nullptr};
}

PreinstalledWebAppManager::PreinstalledWebAppManager(Profile* profile)
    : profile_(profile),
      device_data_initialized_event_(
          std::make_unique<DeviceDataInitializedEvent>()) {
  if (base::FeatureList::IsEnabled(features::kRecordWebAppDebugInfo)) {
    debug_info_ = std::make_unique<DebugInfo>();
  }
}

PreinstalledWebAppManager::~PreinstalledWebAppManager() {
  for (auto& observer : observers_) {
    observer.OnDestroyed();
  }
}

void PreinstalledWebAppManager::SetProvider(base::PassKey<WebAppProvider>,
                                            WebAppProvider& provider) {
  provider_ = &provider;
}

void PreinstalledWebAppManager::Start(base::OnceClosure on_done) {
  DCHECK(provider_);
  if (g_skip_startup_for_testing_ || skip_startup_for_testing_) {  // IN-TEST
    std::move(on_done).Run();                                      // IN-TEST
    return;                                                        // IN-TEST
  }

  LoadAndSynchronize(
      base::BindOnce(&PreinstalledWebAppManager::OnStartUpTaskCompleted,
                     weak_ptr_factory_.GetWeakPtr())
          .Then(std::move(on_done)));
}

void PreinstalledWebAppManager::LoadForTesting(ConsumeInstallOptions callback) {
  Load(std::move(callback));
}

void PreinstalledWebAppManager::AddObserver(
    PreinstalledWebAppManager::Observer* observer) {
  observers_.AddObserver(observer);
}

void PreinstalledWebAppManager::RemoveObserver(
    PreinstalledWebAppManager::Observer* observer) {
  observers_.RemoveObserver(observer);
}

void PreinstalledWebAppManager::SetSkipStartupSynchronizeForTesting(  // IN-TEST
    bool skip_startup) {
  skip_startup_for_testing_ = skip_startup;  // IN-TEST
}

void PreinstalledWebAppManager::LoadAndSynchronizeForTesting(
    SynchronizeCallback callback) {
  LoadAndSynchronize(std::move(callback));
}

void PreinstalledWebAppManager::LoadAndSynchronize(
    SynchronizeCallback callback) {
  base::OnceClosure load_and_synchronize = base::BindOnce(
      &PreinstalledWebAppManager::Load, weak_ptr_factory_.GetWeakPtr(),
      base::BindOnce(&PreinstalledWebAppManager::Synchronize,
                     weak_ptr_factory_.GetWeakPtr(), std::move(callback)));

  if (g_bypass_awaiting_dependencies_for_testing_) {
    std::move(load_and_synchronize).Run();
    return;
  }

  base::ConcurrentClosures concurrent;
  device_data_initialized_event_->Post(concurrent.CreateClosure());
  // Make sure ExtensionSystem is ready to know if default apps new installation
  // will be performed.
  extensions::OnExtensionSystemReady(profile_, concurrent.CreateClosure());
  std::move(concurrent).Done(std::move(load_and_synchronize));
}

void PreinstalledWebAppManager::Load(ConsumeInstallOptions callback) {
  bool preinstalling_enabled =
      base::FeatureList::IsEnabled(features::kPreinstalledWebAppInstallation);

  if (!preinstalling_enabled) {
    std::move(callback).Run({});
    return;
  }

  auto weak_ptr = weak_ptr_factory_.GetWeakPtr();
  RunChainedCallbacks(
      base::BindOnce(&PreinstalledWebAppManager::LoadDeviceInfo, weak_ptr),
      base::BindOnce(&PreinstalledWebAppManager::CacheDeviceInfo, weak_ptr),
      base::BindOnce(&PreinstalledWebAppManager::LoadConfigs, weak_ptr),
      base::BindOnce(&PreinstalledWebAppManager::ParseConfigs, weak_ptr),
      base::BindOnce(&PreinstalledWebAppManager::PostProcessConfigs, weak_ptr),
      std::move(callback));
}

// TODO(http://b/333583704): Revert CL which added this method after migration.
void PreinstalledWebAppManager::LoadDeviceInfo(ConsumeDeviceInfo callback) {
#if BUILDFLAG(IS_CHROMEOS)
  // This needs to be consistent with echo_private_api to avoid inconsistency
  // between promo offering and eligibility.
  DeviceInfo device_info;
  device_info.oobe_timestamp = ash::report::utils::GetFirstActiveWeek();
  std::move(callback).Run(device_info);
#else  // BUILDFLAG(IS_CHROMEOS)
  std::move(callback).Run(DeviceInfo());
#endif
}

// TODO(http://b/333583704): Revert CL which added this method after migration.
void PreinstalledWebAppManager::CacheDeviceInfo(
    CacheDeviceInfoCallback callback,
    DeviceInfo device_info) {
  device_info_ = std::move(device_info);
  std::move(callback).Run();
}

void PreinstalledWebAppManager::LoadConfigs(ConsumeLoadedConfigs callback) {
  if (g_configs_for_testing) {
    LoadedConfigs loaded_configs;
    for (const base::Value& config : *g_configs_for_testing) {
      auto file = base::FilePath(FILE_PATH_LITERAL("test.json"));
      if (test::GetPreinstalledWebAppConfigDirForTesting()) {  //  IN-TEST
        file = test::GetPreinstalledWebAppConfigDirForTesting()->Append(
            file);  // IN-TEST
      }

      loaded_configs.configs.push_back(
          {.contents = config.Clone(), .file = file});
    }
    std::move(callback).Run(std::move(loaded_configs));
    return;
  }

  if (PreinstalledWebAppsDisabled()) {
    std::move(callback).Run({});
    return;
  }

  base::FilePath config_dir = GetPreinstalledWebAppConfigDir(profile_);
  if (config_dir.empty()) {
    std::move(callback).Run({});
    return;
  }

  std::vector<base::FilePath> config_dirs = {config_dir};
  base::FilePath extra_config_dir =
      GetPreinstalledWebAppExtraConfigDir(profile_);
  if (!extra_config_dir.empty()) {
    config_dirs.push_back(extra_config_dir);
  }

  base::ThreadPool::PostTaskAndReplyWithResult(
      FROM_HERE,
      {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
       base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN},
      base::BindOnce(&LoadConfigsBlocking, std::move(config_dirs)),
      std::move(callback));
}

void PreinstalledWebAppManager::ParseConfigs(ConsumeParsedConfigs callback,
                                             LoadedConfigs loaded_configs) {
  base::ThreadPool::PostTaskAndReplyWithResult(
      FROM_HERE,
      {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
       base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN},
      base::BindOnce(&ParseConfigsBlocking, std::move(loaded_configs)),
      std::move(callback));
}

void PreinstalledWebAppManager::PostProcessConfigs(
    ConsumeInstallOptions callback,
    ParsedConfigs parsed_configs) {
  // Add hard coded configs.
  for (ExternalInstallOptions& options :
       GetPreinstalledWebApps(*profile_, device_info_)) {
    parsed_configs.options_list.push_back(std::move(options));
  }

  // Allow tests to bypass kDisableDefaultApps with an allow list.
  if (GetPreinstallUrlAllowListForTesting().has_value()) {
    std::erase_if(
        parsed_configs.options_list, [](const ExternalInstallOptions& options) {
          return !GetPreinstallUrlAllowListForTesting().value().contains(
              options.install_url);
        });
  }

  // Set common install options.
  for (ExternalInstallOptions& options : parsed_configs.options_list) {
    DCHECK_EQ(options.install_source, ExternalInstallSource::kExternalDefault);

    options.require_manifest = true;

#if BUILDFLAG(IS_CHROMEOS)
    // On Chrome OS the "quick launch bar" is the shelf pinned apps.
    // This is configured in `GetDefaultPinnedAppsForFormFactor()` instead of
    // here to ensure a specific order is deployed.
    options.add_to_quick_launch_bar = false;
#else   // BUILDFLAG(IS_CHROMEOS)
    if (!g_bypass_offline_manifest_requirement_for_testing_) {
      // Non-Chrome OS platforms are not permitted to fetch the web app install
      // URLs during start up.
      DCHECK(options.app_info_factory);
      options.only_use_app_info_factory = true;
    }

    // Preinstalled web apps should not have OS shortcuts of any kind outside of
    // Chrome OS.
    options.add_to_applications_menu = false;
    options.add_to_search = false;
    options.add_to_management = false;
    options.add_to_desktop = false;
    options.add_to_quick_launch_bar = false;
    options.install_without_os_integration = true;
#endif  // BUILDFLAG(IS_CHROMEOS)

    if (g_override_previous_user_uninstall_for_testing_) {
      options.override_previous_user_uninstall = true;
    }
  }

  // TODO(crbug.com/40747215): Move this constant into some shared constants.h
  // file.
  bool preinstalled_apps_enabled_in_prefs =
      profile_->GetPrefs()->GetString(prefs::kPreinstalledApps) == "install";
  bool is_new_user = IsNewUser();
  std::string user_type = apps::DetermineUserType(profile_);
  size_t disabled_count = 0;
  size_t corrupt_user_uninstall_prefs_count = 0;
  std::erase_if(
      parsed_configs.options_list, [&](const ExternalInstallOptions& options) {
        SynchronizeDecision install_decision = GetSynchronizeDecision(
            options, profile_, &provider_->registrar_unsafe(),
            preinstalled_apps_enabled_in_prefs, is_new_user, user_type,
            corrupt_user_uninstall_prefs_count);
        base::UmaHistogramEnumeration(kHistogramMigrationDisabledReason,
                                      install_decision.reason);

        switch (install_decision.type) {
          case SynchronizeDecision::kUninstall:
            VLOG(1) << install_decision.log;
            ++disabled_count;
            if (debug_info_) {
              debug_info_->uninstall_configs.emplace_back(
                  options, std::move(install_decision.log));
            }
            return true;

          case SynchronizeDecision::kInstall:
            if (debug_info_) {
              debug_info_->install_configs.emplace_back(
                  options, std::move(install_decision.log));
            }
            return false;

          case SynchronizeDecision::kIgnore:
            if (debug_info_) {
              debug_info_->ignore_configs.emplace_back(
                  options, std::move(install_decision.log));
            }
            // These configs get passed to SynchronizeInstalledApps() which has
            // no concept of kIgnore, only ensuring installation or
            // uninstallation based on presence/absence of the config. In order
            // for the config to be ignored (as in no installation or
            // uninstallation taking place) the config presence needs to match
            // whether the install_source + install_url is already present in
            // the installed web apps.
            return !provider_->registrar_unsafe()
                        .LookUpAppByInstallSourceInstallUrl(
                            WebAppManagement::Type::kDefault,
                            options.install_url);
        }
      });

  if (debug_info_) {
    debug_info_->parse_errors = parsed_configs.errors;
  }

  for (ExternalInstallOptions& options : parsed_configs.options_list) {
    if (ShouldForceReinstall(options, *profile_->GetPrefs(),
                             provider_->registrar_unsafe())) {
      options.force_reinstall = true;
    }
  }

#if BUILDFLAG(IS_CHROMEOS)
  MaybeForceInstallForRemigration(&parsed_configs.options_list, profile_.get(),
                                  provider_->registrar_unsafe());
#endif

  base::UmaHistogramCounts100(kHistogramEnabledCount,
                              parsed_configs.options_list.size());
  base::UmaHistogramCounts100(kHistogramDisabledCount, disabled_count);
  base::UmaHistogramCounts100(kHistogramConfigErrorCount,
                              parsed_configs.errors.size());
  base::UmaHistogramCounts100(kHistogramCorruptUserUninstallPrefsCount,
                              corrupt_user_uninstall_prefs_count);

  std::move(callback).Run(parsed_configs.options_list);
}

void PreinstalledWebAppManager::Synchronize(
    ExternallyManagedAppManager::SynchronizeCallback callback,
    std::vector<ExternalInstallOptions> desired_apps_install_options) {
  DCHECK(provider_);

  std::set<InstallUrl> desired_preferred_apps_for_supported_links;
  std::map<InstallUrl, std::vector<webapps::AppId>> desired_uninstalls;
  for (const auto& entry : desired_apps_install_options) {
    if (entry.is_preferred_app_for_supported_links) {
      desired_preferred_apps_for_supported_links.insert(entry.install_url);
    }
    if (!entry.uninstall_and_replace.empty()) {
      desired_uninstalls.emplace(entry.install_url,
                                 entry.uninstall_and_replace);
    }
  }

  provider_->externally_managed_app_manager().SynchronizeInstalledApps(
      std::move(desired_apps_install_options),
      ExternalInstallSource::kExternalDefault,
      base::BindOnce(&PreinstalledWebAppManager::OnExternalWebAppsSynchronized,
                     weak_ptr_factory_.GetWeakPtr(), std::move(callback),
                     std::move(desired_preferred_apps_for_supported_links),
                     std::move(desired_uninstalls)));
}

void PreinstalledWebAppManager::OnExternalWebAppsSynchronized(
    ExternallyManagedAppManager::SynchronizeCallback callback,
    std::set<InstallUrl> desired_preferred_apps_for_supported_links,
    std::map<InstallUrl, std::vector<webapps::AppId>> desired_uninstalls,
    std::map<InstallUrl, ExternallyManagedAppManager::InstallResult>
        install_results,
    std::map<InstallUrl, webapps::UninstallResultCode> uninstall_results) {
  // Note that we are storing the Chrome version (milestone number) instead of a
  // "has synchronised" bool in order to do version update specific logic.
  profile_->GetPrefs()->SetString(
      prefs::kWebAppsLastPreinstallSynchronizeVersion,
      version_info::GetMajorVersionNumber());

  DCHECK(
      apps::AppServiceProxyFactory::IsAppServiceAvailableForProfile(profile_));
  auto* proxy = apps::AppServiceProxyFactory::GetForProfile(profile_);

  size_t uninstall_and_replace_count = 0;
  size_t app_to_replace_still_installed_count = 0;
  size_t app_to_replace_still_default_installed_count = 0;
  size_t app_to_replace_still_installed_in_shelf_count = 0;

  for (const auto& [url, result] : install_results) {
    base::UmaHistogramEnumeration(kHistogramInstallResult, result.code);
    if (result.did_uninstall_and_replace) {
      ++uninstall_and_replace_count;
    }

    if (!IsSuccess(result.code)) {
      continue;
    }

    DCHECK(result.app_id.has_value());

    // Do not set as the preferred app for supported links if the app is
    // already installed as the user may have already updated their preference.
    if (result.code != webapps::InstallResultCode::kSuccessAlreadyInstalled &&
        desired_preferred_apps_for_supported_links.contains(url)) {
      proxy->SetSupportedLinksPreference(*result.app_id);
    }

    auto iter = desired_uninstalls.find(url);
    if (iter == desired_uninstalls.end()) {
      continue;
    }

    for (const webapps::AppId& replace_id : iter->second) {
      // We mark the app as migrated to a web app as long as the
      // installation was successful, even if the previous app was not
      // installed. This ensures we properly re-install apps if the
      // migration feature is rolled back.
      MarkAppAsMigratedToWebApp(profile_, replace_id, /*was_migrated=*/true);

      // Track whether the app to replace is still present. This is
      // possibly due to getting reinstalled by the user or by Chrome app
      // sync. See https://crbug.com/1266234 for context.
      if (proxy &&
          result.code == webapps::InstallResultCode::kSuccessAlreadyInstalled) {
        bool is_installed = false;
        proxy->AppRegistryCache().ForOneApp(
            replace_id, [&is_installed](const apps::AppUpdate& app) {
              is_installed = apps_util::IsInstalled(app.Readiness());
            });

        if (!is_installed) {
          continue;
        }

        ++app_to_replace_still_installed_count;

        if (extensions::IsExtensionDefaultInstalled(profile_, replace_id)) {
          ++app_to_replace_still_default_installed_count;
        }

        if (provider_->ui_manager().CanAddAppToQuickLaunchBar()) {
          if (provider_->ui_manager().IsAppInQuickLaunchBar(
                  result.app_id.value())) {
            ++app_to_replace_still_installed_in_shelf_count;
          }
        }
      }
    }
  }

  size_t uninstall_source_removed_count = 0;
  size_t uninstall_app_removed_count = 0;

  for (const auto& [url, result] : uninstall_results) {
    if (result == webapps::UninstallResultCode::kInstallSourceRemoved) {
      ++uninstall_source_removed_count;
    } else if (result == webapps::UninstallResultCode::kAppRemoved) {
      ++uninstall_app_removed_count;
    }
  }

  base::UmaHistogramCounts100(kHistogramInstallCount, install_results.size());
  base::UmaHistogramCounts100(kHistogramUninstallTotalCount,
                              uninstall_results.size());
  base::UmaHistogramCounts100(kHistogramUninstallSourceRemovedCount,
                              uninstall_source_removed_count);
  base::UmaHistogramCounts100(kHistogramUninstallAppRemovedCount,
                              uninstall_app_removed_count);
  base::UmaHistogramCounts100(kHistogramUninstallAndReplaceCount,
                              uninstall_and_replace_count);

  base::UmaHistogramCounts100(kHistogramAppToReplaceStillInstalledCount,
                              app_to_replace_still_installed_count);
  base::UmaHistogramCounts100(kHistogramAppToReplaceStillDefaultInstalledCount,
                              app_to_replace_still_default_installed_count);
  base::UmaHistogramCounts100(kHistogramAppToReplaceStillInstalledInShelfCount,
                              app_to_replace_still_installed_in_shelf_count);

  SetMigrationRun(profile_, "MigrateDefaultChromeAppToWebAppsGSuite", true);
  SetMigrationRun(profile_, "MigrateDefaultChromeAppToWebAppsNonGSuite", true);
  if (uninstall_and_replace_count > 0) {
    for (auto& observer : observers_) {
      observer.OnMigrationRun();
    }
  }

  if (callback) {
    std::move(callback).Run(std::move(install_results),
                            std::move(uninstall_results));
  }
}

void PreinstalledWebAppManager::OnStartUpTaskCompleted(
    std::map<InstallUrl, ExternallyManagedAppManager::InstallResult>
        install_results,
    std::map<InstallUrl, webapps::UninstallResultCode> uninstall_results) {
  if (debug_info_) {
    debug_info_->is_start_up_task_complete = true;
    debug_info_->install_results = std::move(install_results);
    debug_info_->uninstall_results = std::move(uninstall_results);
  }
}

bool PreinstalledWebAppManager::IsNewUser() {
  PrefService* prefs = profile_->GetPrefs();
  return prefs->GetString(prefs::kWebAppsLastPreinstallSynchronizeVersion)
      .empty();
}

PreinstalledWebAppManager::DebugInfo::DebugInfo() = default;

PreinstalledWebAppManager::DebugInfo::~DebugInfo() = default;

}  //  namespace web_app