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

#include "chrome/browser/chromeos/app_mode/chrome_kiosk_app_installer.h"

#include <algorithm>
#include <iterator>
#include <memory>
#include <string>
#include <string_view>
#include <utility>
#include <vector>

#include "base/check.h"
#include "base/check_deref.h"
#include "base/check_op.h"
#include "base/containers/flat_set.h"
#include "base/functional/bind.h"
#include "base/metrics/histogram_functions.h"
#include "base/strings/string_util.h"
#include "base/syslog_logging.h"
#include "chrome/browser/chromeos/app_mode/chrome_kiosk_external_loader_broker.h"
#include "chrome/browser/chromeos/app_mode/startup_app_launcher_update_checker.h"
#include "chrome/browser/extensions/forced_extensions/install_stage_tracker.h"
#include "chrome/browser/extensions/install_tracker_factory.h"
#include "chrome/browser/profiles/profile.h"
#include "content/public/browser/browser_context.h"
#include "extensions/browser/extension_registrar.h"
#include "extensions/browser/extension_system.h"
#include "extensions/browser/pending_extension_manager.h"
#include "extensions/common/extension.h"
#include "extensions/common/extension_id.h"
#include "extensions/common/file_util.h"
#include "extensions/common/manifest_handlers/kiosk_mode_info.h"
#include "extensions/common/manifest_handlers/shared_module_info.h"

namespace chromeos {

namespace {

const std::string_view kChromeKioskExtensionUpdateErrorHistogram =
    "Kiosk.ChromeApp.ExtensionUpdateError";

const std::string_view kChromeKioskExtensionHasUpdateDurationHistogram =
    "Kiosk.ChromeApp.ExtensionUpdateDuration.HasUpdate";

const std::string_view kChromeKioskExtensionNoUpdateDurationHistogram =
    "Kiosk.ChromeApp.ExtensionUpdateDuration.NoUpdate";

// Returns true if the app with `id` is pending an install or update.
bool IsExtensionInstallPending(content::BrowserContext& browser_context,
                               const std::string& id) {
  return extensions::PendingExtensionManager::Get(&browser_context)
      ->IsIdPending(id);
}

// Returns the `Extension` corresponding to `id` installed in `browser_context`,
// or null if the extension is not installed.
const extensions::Extension* FindInstalledExtension(
    content::BrowserContext& browser_context,
    const extensions::ExtensionId& id) {
  return extensions::ExtensionRegistry::Get(&browser_context)
      ->GetInstalledExtension(id);
}

// Returns true if the extension with `id` is installed in `browser_context`.
bool IsExtensionInstalled(content::BrowserContext& browser_context,
                          const extensions::ExtensionId& id) {
  return FindInstalledExtension(browser_context, id) != nullptr;
}

// Returns true if all extensions in `ids` are installed in `browser_context`.
bool AreExtensionsInstalled(content::BrowserContext& browser_context,
                            const std::vector<extensions::ExtensionId>& ids) {
  return std::ranges::all_of(ids.begin(), ids.end(),
                             [&browser_context](const auto& id) {
                               return IsExtensionInstalled(browser_context, id);
                             });
}

// Returns true if the secondary apps of `app` contain the given `id`.
bool SecondaryAppsContain(const extensions::Extension& app,
                          const extensions::ExtensionId& id) {
  if (auto* info = extensions::KioskModeInfo::Get(&app); info != nullptr) {
    auto it = std::ranges::find(info->secondary_apps, id,
                                [](const auto& app) { return app.id; });
    return it != info->secondary_apps.end();
  }

  return false;
}

// Returns the IDs of the secondary apps of `app`.
std::vector<extensions::ExtensionId> SecondaryAppIdsOf(
    const extensions::Extension& app) {
  std::vector<extensions::ExtensionId> result;
  if (auto* info = extensions::KioskModeInfo::Get(&app); info != nullptr) {
    std::ranges::transform(info->secondary_apps, std::back_inserter(result),
                           [](const auto& app) { return app.id; });
  }
  return result;
}

// Returns the subset of `app_ids` that is pending install or update.
std::vector<extensions::ExtensionId> CopyIdsPendingInstall(
    content::BrowserContext& browser_context,
    const std::vector<extensions::ExtensionId>& app_ids) {
  std::vector<extensions::ExtensionId> result;
  std::ranges::copy_if(app_ids, std::back_inserter(result),
                       [&browser_context](const auto& id) {
                         return IsExtensionInstallPending(browser_context, id);
                       });
  return result;
}

// Inserts the shared modules `extension` imports into the set of `ids` that are
// pending install.
void InsertPendingSharedModules(content::BrowserContext& browser_context,
                                base::flat_set<extensions::ExtensionId>& ids,
                                const extensions::Extension& extension) {
  const auto& imports = extensions::SharedModuleInfo::GetImports(&extension);
  for (const auto& import_info : imports) {
    if (IsExtensionInstallPending(browser_context, import_info.extension_id)) {
      ids.insert(import_info.extension_id);
    }
  }
}

}  // namespace

ChromeKioskAppInstaller::ChromeKioskAppInstaller(
    Profile* profile,
    const AppInstallParams& install_data)
    : profile_(CHECK_DEREF(profile)), primary_app_install_data_(install_data) {}

ChromeKioskAppInstaller::~ChromeKioskAppInstaller() = default;

void ChromeKioskAppInstaller::BeginInstall(InstallCallback callback) {
  DCHECK(!install_complete_);

  SYSLOG(INFO) << "BeginInstall primary app id: " << primary_app_id();

  on_ready_callback_ = std::move(callback);

  extensions::file_util::SetUseSafeInstallation(true);

  const auto* primary_app =
      FindInstalledExtension(profile_.get(), primary_app_id());

  if (primary_app_install_data_.crx_file_location.empty() &&
      primary_app == nullptr) {
    ReportInstallFailure(InstallResult::kPrimaryAppNotCached);
    return;
  }

  ChromeKioskExternalLoaderBroker::Get()->TriggerPrimaryAppInstall(
      primary_app_install_data_);
  if (IsExtensionInstallPending(profile_.get(), primary_app_id())) {
    ObserveInstallations({primary_app_id()});
    return;
  }

  if (primary_app == nullptr) {
    // The extension is skipped for installation due to some error.
    ReportInstallFailure(InstallResult::kPrimaryAppInstallFailed);
    return;
  }

  if (!extensions::KioskModeInfo::IsKioskEnabled(primary_app)) {
    // The installed primary app is not kiosk enabled.
    ReportInstallFailure(InstallResult::kPrimaryAppNotKioskEnabled);
    return;
  }

  // Install secondary apps.
  MaybeInstallSecondaryApps(*primary_app);
}

void ChromeKioskAppInstaller::MaybeInstallSecondaryApps(
    const extensions::Extension& primary_app) {
  if (install_complete_) {
    return;
  }

  secondary_apps_installing_ = true;

  auto secondary_app_ids = SecondaryAppIdsOf(primary_app);

  ChromeKioskExternalLoaderBroker::Get()->UpdateSecondaryAppList(
      secondary_app_ids);

  if (!secondary_app_ids.empty()) {
    auto pending_ids = CopyIdsPendingInstall(profile_.get(), secondary_app_ids);
    if (!pending_ids.empty()) {
      ObserveInstallations(pending_ids);
      return;
    }
  }

  if (!AreExtensionsInstalled(profile_.get(), secondary_app_ids)) {
    ReportInstallFailure(InstallResult::kSecondaryAppInstallFailed);
    return;
  }

  // Check extension update before launching the primary kiosk app.
  MaybeCheckExtensionUpdate();
}

void ChromeKioskAppInstaller::MaybeCheckExtensionUpdate() {
  DCHECK(!install_complete_);

  SYSLOG(INFO) << "MaybeCheckExtensionUpdate";

  // Record update start time to calculate time consumed by update check. When
  // `OnExtensionUpdateCheckFinished` is called the update is already finished
  // because `extensions::ExtensionUpdater::CheckParams::install_immediately` is
  // set to true.
  extension_update_start_time_ = base::Time::Now();

  // Observe installation failures.
  install_stage_observation_.Observe(
      extensions::InstallStageTracker::Get(&profile_.get()));

  // Enforce an immediate version update check for all extensions before
  // launching the primary app. After the chromeos is updated, the shared
  // module (e.g. ARC runtime) may need to be updated to a newer version
  // compatible with the new chromeos. See crbug.com/555083.
  update_checker_ =
      std::make_unique<StartupAppLauncherUpdateChecker>(&profile_.get());
  if (!update_checker_->Run(base::BindOnce(
          &ChromeKioskAppInstaller::OnExtensionUpdateCheckFinished,
          weak_ptr_factory_.GetWeakPtr()))) {
    update_checker_.reset();
    install_stage_observation_.Reset();
    SYSLOG(WARNING) << "Could not check extension updates";
    FinalizeAppInstall();
    return;
  }

  SYSLOG(INFO) << "Checking extension updates";
}

void ChromeKioskAppInstaller::OnExtensionUpdateCheckFinished(
    bool update_found) {
  DCHECK(!install_complete_);

  SYSLOG(INFO) << "OnExtensionUpdateCheckFinished";
  update_checker_.reset();
  install_stage_observation_.Reset();
  if (update_found) {
    SYSLOG(INFO) << "Reloading extension with id " << primary_app_id();

    // Reload the primary app to make sure any reference to the previous version
    // of the shared module, extension, etc will be cleaned up and the new
    // version will be loaded.
    extensions::ExtensionRegistrar::Get(&profile_.get())
        ->ReloadExtension(primary_app_id());

    SYSLOG(INFO) << "Reloaded extension with id " << primary_app_id();
  }

  base::UmaHistogramMediumTimes(
      update_found ? kChromeKioskExtensionHasUpdateDurationHistogram
                   : kChromeKioskExtensionNoUpdateDurationHistogram,
      base::Time::Now() - extension_update_start_time_);

  FinalizeAppInstall();
}

void ChromeKioskAppInstaller::FinalizeAppInstall() {
  DCHECK(!install_complete_);

  install_complete_ = true;

  if (primary_app_update_failed_) {
    ReportInstallFailure(
        ChromeKioskAppInstaller::InstallResult::kPrimaryAppUpdateFailed);
  } else if (secondary_app_update_failed_) {
    ReportInstallFailure(
        ChromeKioskAppInstaller::InstallResult::kSecondaryAppUpdateFailed);
  } else {
    ReportInstallSuccess();
  }
}

void ChromeKioskAppInstaller::OnFinishCrxInstall(
    content::BrowserContext* context,
    const base::FilePath& source_file,
    const std::string& extension_id,
    const extensions::Extension* extension,
    bool success) {
  DCHECK(!install_complete_);

  SYSLOG(INFO) << (success ? "OnFinishCrxInstall succeeded for id: "
                           : "OnFinishCrxInstall failed for id: ")
               << extension_id;

  // Exit early if this is not one of the IDs we care about.
  if (!waiting_ids_.contains(extension_id)) {
    return;
  }
  waiting_ids_.erase(extension_id);

  // Also wait for updates on any shared modules the extension imports.
  if (extension != nullptr) {
    InsertPendingSharedModules(profile_.get(), waiting_ids_, *extension);
  }

  const auto* primary_app =
      FindInstalledExtension(profile_.get(), primary_app_id());

  if (!success) {
    // Primary or secondary app install failed. Abort and report the failure.
    if (primary_app == nullptr && extension_id == primary_app_id()) {
      install_observation_.Reset();
      ReportInstallFailure(InstallResult::kPrimaryAppInstallFailed);
      return;
    }
    if (primary_app != nullptr &&
        SecondaryAppsContain(*primary_app, extension_id) &&
        !IsExtensionInstalled(profile_.get(), extension_id)) {
      install_observation_.Reset();
      ReportInstallFailure(InstallResult::kSecondaryAppInstallFailed);
      return;
    }
    // Primary or secondary app update failed, but there is an installed version
    // in the `profile_`. Proceed for now and report the update failure later.
    if (primary_app != nullptr && extension_id == primary_app_id()) {
      primary_app_update_failed_ = true;
    }
    if (primary_app != nullptr &&
        SecondaryAppsContain(*primary_app, extension_id) &&
        IsExtensionInstalled(profile_.get(), extension_id)) {
      secondary_app_update_failed_ = true;
    }
  }

  // Wait for `OnFinishCrxInstall` to be called for remaining `waiting_ids_`.
  if (!waiting_ids_.empty()) {
    return;
  }

  install_observation_.Reset();

  if (primary_app == nullptr) {
    ReportInstallFailure(InstallResult::kPrimaryAppInstallFailed);
    return;
  }

  if (!extensions::KioskModeInfo::IsKioskEnabled(primary_app)) {
    ReportInstallFailure(InstallResult::kPrimaryAppNotKioskEnabled);
    return;
  }

  if (!secondary_apps_installing_) {
    MaybeInstallSecondaryApps(*primary_app);
  } else {
    MaybeCheckExtensionUpdate();
  }
}

void ChromeKioskAppInstaller::OnExtensionInstallationFailed(
    const extensions::ExtensionId& id,
    extensions::InstallStageTracker::FailureReason reason) {
  base::UmaHistogramEnumeration(kChromeKioskExtensionUpdateErrorHistogram,
                                reason);
}

void ChromeKioskAppInstaller::ReportInstallSuccess() {
  DCHECK(install_complete_);
  SYSLOG(INFO) << "Kiosk app install succeeded";

  std::move(on_ready_callback_)
      .Run(ChromeKioskAppInstaller::InstallResult::kSuccess);
}

void ChromeKioskAppInstaller::ReportInstallFailure(
    ChromeKioskAppInstaller::InstallResult error) {
  SYSLOG(ERROR) << "App install failed, error: " << static_cast<int>(error);
  DCHECK_NE(ChromeKioskAppInstaller::InstallResult::kSuccess, error);

  std::move(on_ready_callback_).Run(error);
}

void ChromeKioskAppInstaller::ObserveInstallations(
    const std::vector<extensions::ExtensionId>& ids) {
  waiting_ids_.insert(ids.begin(), ids.end());
  install_observation_.Observe(
      extensions::InstallTrackerFactory::GetForBrowserContext(&profile_.get()));
}

}  // namespace chromeos