// 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.

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/40285824): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif

#include "chromeos/ash/components/language_packs/language_pack_manager.h"

#include <optional>
#include <string>
#include <string_view>
#include <utility>

#include "ash/constants/ash_features.h"
#include "ash/constants/ash_pref_names.h"
#include "base/check_is_test.h"
#include "base/containers/contains.h"
#include "base/containers/fixed_flat_map.h"
#include "base/containers/flat_map.h"
#include "base/feature_list.h"
#include "base/functional/bind.h"
#include "base/functional/callback.h"
#include "base/functional/callback_helpers.h"
#include "base/hash/hash.h"
#include "base/location.h"
#include "base/logging.h"
#include "base/metrics/histogram_functions.h"
#include "base/no_destructor.h"
#include "base/sequence_checker.h"
#include "base/strings/string_split.h"
#include "base/task/single_thread_task_runner.h"
#include "chromeos/ash/components/dbus/dlcservice/dlcservice.pb.h"
#include "chromeos/ash/components/dbus/dlcservice/dlcservice_client.h"
#include "chromeos/ash/components/language_packs/handwriting.h"
#include "chromeos/ash/components/language_packs/language_packs_util.h"
#include "components/prefs/pref_service.h"
#include "third_party/cros_system_api/dbus/dlcservice/dbus-constants.h"

using ::ash::input_method::InputMethodManager;

namespace ash::language_packs {
namespace {

LanguagePackManager* g_instance = nullptr;

// Finds the ID of the DLC corresponding to the Base Pack for a feature.
// Returns the DLC ID if the feature has a Base Pack or std::nullopt
// otherwise.
std::optional<std::string_view> GetDlcIdForBasePack(
    const std::string& feature_id) {
  // Map of all features and corresponding Base Pack DLC IDs.
  static constexpr auto kAllBasePackDlcIds =
      base::MakeFixedFlatMap<std::string_view, std::string_view>({
          {kHandwritingFeatureId, "handwriting-base"},
      });

  // We search in the static list for the given |feature_id|.
  const auto it = kAllBasePackDlcIds.find(feature_id);
  if (it == kAllBasePackDlcIds.end()) {
    return std::nullopt;
  }

  return it->second;
}

// Run a callback later in the current `SingleThreadedTaskRunner`.
void RunCallbackLater(base::OnceClosure task) {
  base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(FROM_HERE,
                                                              std::move(task));
}

void InstallDlc(std::string_view dlc_id,
                DlcserviceClient::InstallCallback callback) {
  DlcserviceClient* client = DlcserviceClient::Get();
  if (client) {
    dlcservice::InstallRequest install_request;
    install_request.set_id(dlc_id);
    client->Install(install_request, std::move(callback), base::DoNothing());
  } else {
    CHECK_IS_TEST();
    DlcserviceClient::InstallResult result;
    result.error = dlcservice::kErrorInternal;

    RunCallbackLater(base::BindOnce(std::move(callback), std::move(result)));
  }
}

void GetDlcState(const std::string& dlc_id,
                 DlcserviceClient::GetDlcStateCallback callback) {
  DlcserviceClient* client = DlcserviceClient::Get();
  if (client) {
    client->GetDlcState(dlc_id, std::move(callback));
  } else {
    CHECK_IS_TEST();
    dlcservice::DlcState state;
    state.set_id(dlc_id);
    state.set_state(dlcservice::DlcState::State::DlcState_State_NOT_INSTALLED);
    RunCallbackLater(base::BindOnce(
        std::move(callback), dlcservice::kErrorInternal, std::move(state)));
  }
}

void UninstallDlc(const std::string& dlc_id,
                  DlcserviceClient::UninstallCallback callback) {
  DlcserviceClient* client = DlcserviceClient::Get();
  if (client) {
    client->Uninstall(dlc_id, std::move(callback));
  } else {
    CHECK_IS_TEST();
    RunCallbackLater(
        base::BindOnce(std::move(callback), dlcservice::kErrorInternal));
  }
}

// Warning: These DLCs are guaranteed to be downloaded (is_trusted), but not
// guaranteed to be installed (state == INSTALLED).
void GetExistingDlcs(DlcserviceClient::GetExistingDlcsCallback callback) {
  DlcserviceClient* client = DlcserviceClient::Get();
  if (client) {
    client->GetExistingDlcs(std::move(callback));
  } else {
    CHECK_IS_TEST();
    RunCallbackLater(base::BindOnce(std::move(callback),
                                    dlcservice::kErrorInternal,
                                    dlcservice::DlcsWithContent()));
  }
}

void OnInstallDlcComplete(OnInstallCompleteCallback callback,
                          const std::string& feature_id,
                          const std::string& locale,
                          const DlcserviceClient::InstallResult& dlc_result) {
  PackResult result = ConvertDlcInstallResultToPackResult(dlc_result);
  result.feature_id = feature_id;
  result.language_code = locale;

  const bool success = result.operation_error == PackResult::ErrorCode::kNone;
  if (!success) {
    if (feature_id == kHandwritingFeatureId) {
      base::UmaHistogramEnumeration(
          "ChromeOS.LanguagePacks.InstallError.Handwriting",
          GetDlcErrorTypeForUma(dlc_result.error));
    } else if (feature_id == kTtsFeatureId) {
      base::UmaHistogramEnumeration("ChromeOS.LanguagePacks.InstallError.Tts",
                                    GetDlcErrorTypeForUma(dlc_result.error));
    } else if (feature_id == kFontsFeatureId) {
      base::UmaHistogramEnumeration("ChromeOS.LanguagePacks.InstallError.Fonts",
                                    GetDlcErrorTypeForUma(dlc_result.error));
    }
  }

  base::UmaHistogramEnumeration("ChromeOS.LanguagePacks.InstallPack.Success",
                                GetSuccessValueForUma(feature_id, success));

  std::move(callback).Run(result);
}

void OnUninstallDlcComplete(OnUninstallCompleteCallback callback,
                            std::string_view feature_id,
                            const std::string& locale,
                            std::string_view err) {
  PackResult result;
  result.feature_id = feature_id;
  result.language_code = locale;
  result.operation_error = ConvertDlcErrorToErrorCode(err);

  const bool success = err == dlcservice::kErrorNone;
  if (success) {
    result.pack_state = PackResult::StatusCode::kNotInstalled;
  } else {
    result.pack_state = PackResult::StatusCode::kUnknown;
  }

  base::UmaHistogramBoolean("ChromeOS.LanguagePacks.UninstallComplete.Success",
                            success);

  std::move(callback).Run(result);
}

void OnGetDlcState(GetPackStateCallback callback,
                   std::string feature_id,
                   const std::string& locale,
                   std::string_view err,
                   const dlcservice::DlcState& dlc_state) {
  PackResult result;
  if (dlc_state.is_verified() &&
      dlc_state.state() == dlcservice::DlcState_State_NOT_INSTALLED) {
    // Mount the DLC for the client if it already exists on disk.
    // By pure coincidence, `GetPackStateCallback` is the same as
    // `OnInstallCompleteCallback`, so we can directly pass in the
    // client-supplied callback here.
    InstallDlc(dlc_state.id(),
               base::BindOnce(&OnInstallDlcComplete, std::move(callback),
                              std::move(feature_id), std::move(locale)));
    return;
  }

  // GetDlcState() returns 2 errors:
  // one for the DBus call and one for the actual DLC.
  // If the first error is set we can ignore the DLC state.
  if (err.empty() || err == dlcservice::kErrorNone) {
    result = ConvertDlcStateToPackResult(dlc_state);
  } else {
    result.operation_error = ConvertDlcErrorToErrorCode(err);
    result.pack_state = PackResult::StatusCode::kUnknown;
  }

  result.feature_id = feature_id;
  result.language_code = locale;

  std::move(callback).Run(result);
}

// This functions goes through the list of locales to install and remove,
// according to the diff. It performs the actual installation and uninstallation
// of DLCs on the device.
// It should be called whenever Input Methods are changed.
void InstallOrRemoveToMatchState(const std::string& feature_id,
                                 const StringsDiff& locale_diff) {
  for (const std::string& locale : locale_diff.remove) {
    LanguagePackManager::RemovePack(feature_id, locale, base::DoNothing());
  }
  for (const std::string& locale : locale_diff.add) {
    LanguagePackManager::InstallPack(feature_id, locale, base::DoNothing());
  }
}

// Updates packs for input methods based on the user prefs and the currently
// installed DLCs.
// TODO: b/294162606 - Write unit tests for this function if possible.
void UpdateFromInputMethodPrefs(
    base::span<const std::string> installed_hwr_locales,
    input_method::InputMethodUtil* input_method_util,
    PrefService* prefs) {
  const std::vector<std::string> input_method_ids =
      ExtractInputMethodsFromPrefs(prefs);
  const base::flat_set<std::string> target_hwr_locales = MapThenFilterStrings(
      input_method_ids, base::BindRepeating(MapInputMethodIdToHandwritingLocale,
                                            input_method_util));

  const StringsDiff locale_diff = ComputeStringsDiff(
      {installed_hwr_locales.begin(), installed_hwr_locales.end()},
      target_hwr_locales);

  InstallOrRemoveToMatchState(kHandwritingFeatureId, locale_diff);
}

// Callback for dlcservice::GetExistingDlcs().
// TODO: b/294162606 - Write unit tests for this function if possible.
void OnGetExistingDlcs(PrefService* prefs,
                       std::string_view err,
                       const dlcservice::DlcsWithContent& dlcs_with_content) {
  if (!err.empty() && err != dlcservice::kErrorNone) {
    DLOG(ERROR) << "DlcserviceClient::GetExisingDlcs() returned error";
    // TODO: b/285985206 - Record a UMA histogram.
    return;
  }

  const base::flat_set<std::string> hwr_locales =
      ConvertDlcsWithContentToHandwritingLocales(dlcs_with_content);
  UpdateFromInputMethodPrefs({hwr_locales.begin(), hwr_locales.end()},
                             InputMethodManager::Get()->GetInputMethodUtil(),
                             prefs);
}

}  // namespace

const base::flat_map<PackSpecPair, std::string>& GetAllLanguagePackDlcIds() {
  // Map of all DLCs and corresponding IDs.
  // It's a map from PackSpecPair to DLC ID. The pair is <feature id, locale>.
  // Whenever a new DLC is created, it needs to be added here.
  // Clients of Language Packs don't need to know the IDs.
  static const base::NoDestructor<base::flat_map<PackSpecPair, std::string>>
      all_dlc_ids({
          // Handwriting Recognition.
          {{kHandwritingFeatureId, "am"}, "handwriting-am"},
          {{kHandwritingFeatureId, "ar"}, "handwriting-ar"},
          {{kHandwritingFeatureId, "be"}, "handwriting-be"},
          {{kHandwritingFeatureId, "bg"}, "handwriting-bg"},
          {{kHandwritingFeatureId, "bn"}, "handwriting-bn"},
          {{kHandwritingFeatureId, "ca"}, "handwriting-ca"},
          {{kHandwritingFeatureId, "cs"}, "handwriting-cs"},
          {{kHandwritingFeatureId, "da"}, "handwriting-da"},
          {{kHandwritingFeatureId, "de"}, "handwriting-de"},
          {{kHandwritingFeatureId, "el"}, "handwriting-el"},
          {{kHandwritingFeatureId, "en"}, "handwriting-en"},
          {{kHandwritingFeatureId, "es"}, "handwriting-es"},
          {{kHandwritingFeatureId, "et"}, "handwriting-et"},
          {{kHandwritingFeatureId, "fa"}, "handwriting-fa"},
          {{kHandwritingFeatureId, "fi"}, "handwriting-fi"},
          {{kHandwritingFeatureId, "fil"}, "handwriting-fil"},
          {{kHandwritingFeatureId, "fr"}, "handwriting-fr"},
          {{kHandwritingFeatureId, "ga"}, "handwriting-ga"},
          {{kHandwritingFeatureId, "gu"}, "handwriting-gu"},
          {{kHandwritingFeatureId, "hi"}, "handwriting-hi"},
          {{kHandwritingFeatureId, "hr"}, "handwriting-hr"},
          {{kHandwritingFeatureId, "hu"}, "handwriting-hu"},
          {{kHandwritingFeatureId, "hy"}, "handwriting-hy"},
          {{kHandwritingFeatureId, "id"}, "handwriting-id"},
          {{kHandwritingFeatureId, "is"}, "handwriting-is"},
          {{kHandwritingFeatureId, "it"}, "handwriting-it"},
          {{kHandwritingFeatureId, "iw"}, "handwriting-iw"},
          {{kHandwritingFeatureId, "ja"}, "handwriting-ja"},
          {{kHandwritingFeatureId, "ka"}, "handwriting-ka"},
          {{kHandwritingFeatureId, "kk"}, "handwriting-kk"},
          {{kHandwritingFeatureId, "km"}, "handwriting-km"},
          {{kHandwritingFeatureId, "kn"}, "handwriting-kn"},
          {{kHandwritingFeatureId, "ko"}, "handwriting-ko"},
          {{kHandwritingFeatureId, "lo"}, "handwriting-lo"},
          {{kHandwritingFeatureId, "lt"}, "handwriting-lt"},
          {{kHandwritingFeatureId, "lv"}, "handwriting-lv"},
          {{kHandwritingFeatureId, "ml"}, "handwriting-ml"},
          {{kHandwritingFeatureId, "mn"}, "handwriting-mn"},
          {{kHandwritingFeatureId, "mr"}, "handwriting-mr"},
          {{kHandwritingFeatureId, "ms"}, "handwriting-ms"},
          {{kHandwritingFeatureId, "mt"}, "handwriting-mt"},
          {{kHandwritingFeatureId, "my"}, "handwriting-my"},
          {{kHandwritingFeatureId, "ne"}, "handwriting-ne"},
          {{kHandwritingFeatureId, "nl"}, "handwriting-nl"},
          {{kHandwritingFeatureId, "no"}, "handwriting-no"},
          {{kHandwritingFeatureId, "or"}, "handwriting-or"},
          {{kHandwritingFeatureId, "pa"}, "handwriting-pa"},
          {{kHandwritingFeatureId, "pl"}, "handwriting-pl"},
          {{kHandwritingFeatureId, "pt"}, "handwriting-pt"},
          {{kHandwritingFeatureId, "ro"}, "handwriting-ro"},
          {{kHandwritingFeatureId, "ru"}, "handwriting-ru"},
          {{kHandwritingFeatureId, "si"}, "handwriting-si"},
          {{kHandwritingFeatureId, "sk"}, "handwriting-sk"},
          {{kHandwritingFeatureId, "sl"}, "handwriting-sl"},
          {{kHandwritingFeatureId, "sr"}, "handwriting-sr"},
          {{kHandwritingFeatureId, "sv"}, "handwriting-sv"},
          {{kHandwritingFeatureId, "ta"}, "handwriting-ta"},
          {{kHandwritingFeatureId, "te"}, "handwriting-te"},
          {{kHandwritingFeatureId, "th"}, "handwriting-th"},
          {{kHandwritingFeatureId, "ti"}, "handwriting-ti"},
          {{kHandwritingFeatureId, "tr"}, "handwriting-tr"},
          {{kHandwritingFeatureId, "uk"}, "handwriting-uk"},
          {{kHandwritingFeatureId, "ur"}, "handwriting-ur"},
          {{kHandwritingFeatureId, "vi"}, "handwriting-vi"},
          {{kHandwritingFeatureId, "zh"}, "handwriting-zh"},
          {{kHandwritingFeatureId, "zh-HK"}, "handwriting-zh-HK"},

          // Text-To-Speech.
          {{kTtsFeatureId, "bn"}, "tts-bn-bd-c"},
          {{kTtsFeatureId, "cs"}, "tts-cs-cz-c"},
          {{kTtsFeatureId, "da"}, "tts-da-dk-c"},
          {{kTtsFeatureId, "de"}, "tts-de-de-c"},
          {{kTtsFeatureId, "el"}, "tts-el-gr-c"},
          {{kTtsFeatureId, "en-au"}, "tts-en-au-c"},
          {{kTtsFeatureId, "en-gb"}, "tts-en-gb-c"},
          {{kTtsFeatureId, "en-us"}, "tts-en-us-d"},
          {{kTtsFeatureId, "es-es"}, "tts-es-es-c"},
          {{kTtsFeatureId, "es-us"}, "tts-es-us-c"},
          {{kTtsFeatureId, "fi"}, "tts-fi-fi-c"},
          {{kTtsFeatureId, "fil"}, "tts-fil-ph-c"},
          {{kTtsFeatureId, "fr"}, "tts-fr-fr-c"},
          {{kTtsFeatureId, "hi"}, "tts-hi-in-c"},
          {{kTtsFeatureId, "hu"}, "tts-hu-hu-c"},
          {{kTtsFeatureId, "id"}, "tts-id-id-c"},
          {{kTtsFeatureId, "it"}, "tts-it-it-c"},
          {{kTtsFeatureId, "ja"}, "tts-ja-jp-c"},
          {{kTtsFeatureId, "km"}, "tts-km-kh-c"},
          {{kTtsFeatureId, "ko"}, "tts-ko-kr-c"},
          {{kTtsFeatureId, "nb"}, "tts-nb-no-c"},
          {{kTtsFeatureId, "ne"}, "tts-ne-np-c"},
          {{kTtsFeatureId, "nl"}, "tts-nl-nl-c"},
          {{kTtsFeatureId, "pl"}, "tts-pl-pl-c"},
          {{kTtsFeatureId, "pt-br"}, "tts-pt-br-c"},
          {{kTtsFeatureId, "pt-pt"}, "tts-pt-pt-c"},
          {{kTtsFeatureId, "si"}, "tts-si-lk-c"},
          {{kTtsFeatureId, "sk"}, "tts-sk-sk-c"},
          {{kTtsFeatureId, "sv"}, "tts-sv-se-c"},
          {{kTtsFeatureId, "th"}, "tts-th-th-c"},
          {{kTtsFeatureId, "tr"}, "tts-tr-tr-c"},
          {{kTtsFeatureId, "uk"}, "tts-uk-ua-c"},
          {{kTtsFeatureId, "vi"}, "tts-vi-vn-c"},
          {{kTtsFeatureId, "yue"}, "tts-yue-hk-c"},

          // Fonts.
          {{kFontsFeatureId, "ja"}, "extrafonts-ja"},
          {{kFontsFeatureId, "ko"}, "extrafonts-ko"},
      });

  return *all_dlc_ids;
}

// TODO: b/294162606 - Calling this function with a `std::string_view` or a
// `const char*` argument causes two string copies per argument - one to call
// the function, and one to create the `PackSpecPair` to look up in the map.
// Either refactor this function to take in a `std::string_view` to reduce it
// down to one string copy per argument, use heterogeneous lookup
// (https://abseil.io/tips/144) to reduce it down to zero string copies, or
// rewrite this function completely.
std::optional<std::string> GetDlcIdForLanguagePack(
    const std::string& feature_id,
    const std::string& locale) {
  // We search in the static list for the given Pack spec.
  const PackSpecPair spec(feature_id, locale);
  const auto it = GetAllLanguagePackDlcIds().find(spec);

  if (it == GetAllLanguagePackDlcIds().end()) {
    return std::nullopt;
  }

  return it->second;
}

std::optional<std::string> DlcToTtsLocale(std::string_view dlc_id) {
  const base::flat_map<PackSpecPair, std::string>& all_ids =
      GetAllLanguagePackDlcIds();
  // Relies on the fact that TTS `PackSpecPair`s are "grouped together" in the
  // sorted `flat_map`.
  auto it = all_ids.upper_bound({kTtsFeatureId, ""});
  while (it != all_ids.end() && it->first.feature_id == kTtsFeatureId) {
    if (it->second == dlc_id) {
      return it->first.locale;
    }
    ++it;
  }

  return std::nullopt;
}

///////////////////////////////////////////////////////////
// PackResult constructors and destructors.
PackResult::PackResult() {
  this->pack_state = PackResult::StatusCode::kUnknown;
}

PackResult::~PackResult() = default;

PackResult::PackResult(const PackResult&) = default;
///////////////////////////////////////////////////////////

bool LanguagePackManager::IsPackAvailable(const std::string& feature_id,
                                          const std::string& input_locale) {
  const std::string locale = ResolveLocale(feature_id, input_locale);

  // We search in the static list for the given Pack spec.
  const PackSpecPair spec(feature_id, locale);
  return base::Contains(GetAllLanguagePackDlcIds(), spec);
}

void LanguagePackManager::InstallPack(const std::string& feature_id,
                                      const std::string& input_locale,
                                      OnInstallCompleteCallback callback) {
  const std::string locale = ResolveLocale(feature_id, input_locale);
  const std::optional<std::string> dlc_id =
      GetDlcIdForLanguagePack(feature_id, locale);

  // If the given Language Pack doesn't exist, run callback and don't reach the
  // DLC Service.
  if (!dlc_id) {
    std::move(callback).Run(CreateInvalidDlcPackResult());
    return;
  }

  InstallDlc(*dlc_id, base::BindOnce(&OnInstallDlcComplete, std::move(callback),
                                     feature_id, locale));
}

void LanguagePackManager::GetPackState(const std::string& feature_id,
                                       const std::string& input_locale,
                                       GetPackStateCallback callback) {
  const std::string locale = ResolveLocale(feature_id, input_locale);
  const std::optional<std::string> dlc_id =
      GetDlcIdForLanguagePack(feature_id, locale);

  // If the given Language Pack doesn't exist, run callback and don't reach the
  // DLC Service.
  if (!dlc_id) {
    std::move(callback).Run(CreateInvalidDlcPackResult());
    return;
  }

  // TODO: b/351723265 - Split this language code metric into a metric for each
  // feature.
  base::UmaHistogramSparse("ChromeOS.LanguagePacks.GetPackState.LanguageCode",
                           static_cast<int32_t>(base::PersistentHash(locale)));
  base::UmaHistogramEnumeration("ChromeOS.LanguagePacks.GetPackState.FeatureId",
                                GetFeatureIdValueForUma(feature_id));

  GetDlcState(*dlc_id, base::BindOnce(&OnGetDlcState, std::move(callback),
                                      feature_id, locale));
}

void LanguagePackManager::RemovePack(const std::string& feature_id,
                                     const std::string& input_locale,
                                     OnUninstallCompleteCallback callback) {
  const std::string locale = ResolveLocale(feature_id, input_locale);
  const std::optional<std::string> dlc_id =
      GetDlcIdForLanguagePack(feature_id, locale);

  // If the given Language Pack doesn't exist, run callback and don't reach the
  // DLC Service.
  if (!dlc_id) {
    std::move(callback).Run(CreateInvalidDlcPackResult());
    return;
  }

  UninstallDlc(*dlc_id,
               base::BindOnce(&OnUninstallDlcComplete, std::move(callback),
                              feature_id, locale));
}

void LanguagePackManager::InstallBasePack(
    const std::string& feature_id,
    OnInstallBasePackCompleteCallback callback) {
  const std::optional<std::string_view> dlc_id =
      GetDlcIdForBasePack(feature_id);

  // If the given |feature_id| doesn't have a Base Pack, run callback and
  // don't reach the DLC Service.
  if (!dlc_id) {
    std::move(callback).Run(CreateInvalidDlcPackResult());
    return;
  }

  base::UmaHistogramEnumeration(
      "ChromeOS.LanguagePacks.InstallBasePack.FeatureId",
      GetFeatureIdValueForUma(feature_id));

  InstallDlc(*dlc_id, base::BindOnce(&OnInstallDlcComplete, std::move(callback),
                                     feature_id, ""));
}

void LanguagePackManager::UpdatePacksForOobe(
    const std::string& input_locale,
    OnUpdatePacksForOobeCallback callback) {
  if (!IsOobe()) {
    DLOG(ERROR) << "Language Packs: UpdatePackForOobe called while not in OOBE";
    return;
  }

  // For now, TTS is the only feature we want to install during OOBE.
  // In the future we'll have a function that returns the list of features to
  // install.
  const std::string locale = ResolveLocale(kTtsFeatureId, input_locale);
  const std::optional<std::string> dlc_id =
      GetDlcIdForLanguagePack(kTtsFeatureId, locale);

  if (dlc_id) {
    base::UmaHistogramBoolean("ChromeOS.LanguagePacks.Oobe.ValidLocale", true);
    InstallDlc(*dlc_id,
               base::BindOnce(&OnInstallDlcComplete, std::move(callback),
                              kTtsFeatureId, locale));
  } else {
    base::UmaHistogramBoolean("ChromeOS.LanguagePacks.Oobe.ValidLocale", false);
    DLOG(ERROR) << "Language Packs: UpdatePacksForOobe locale does not exist";
    std::move(callback).Run(CreateInvalidDlcPackResult());
  }
}

void LanguagePackManager::CheckAndUpdateDlcsForInputMethods(
    PrefService* pref_service) {
  // The list of input methods have changed. We need to get the list of current
  // DLCs installed on device, which is an asynchronous method.
  GetExistingDlcs(base::BindOnce(&OnGetExistingDlcs, pref_service));
}

void LanguagePackManager::ObservePrefs(PrefService* pref_service) {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  // This is the main gate for the functionality of observing Prefs.
  // If this flag is false, all of the cascading logic is disabled.
  if (base::FeatureList::IsEnabled(features::kLanguagePacksInSettings)) {
    pref_change_registrar_.Init(pref_service);
    base::RepeatingClosure callback = base::BindRepeating(
        &LanguagePackManager::CheckAndUpdateDlcsForInputMethods, pref_service);
    pref_change_registrar_.Add(ash::prefs::kLanguagePreloadEngines, callback);
  }
}

void LanguagePackManager::AddObserver(Observer* const observer) {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  observers_.AddObserver(observer);
}

void LanguagePackManager::RemoveObserver(Observer* const observer) {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  observers_.RemoveObserver(observer);
}

void LanguagePackManager::NotifyPackStateChanged(
    std::string_view feature_id,
    std::string_view locale,
    const dlcservice::DlcState& dlc_state) {
  PackResult result = ConvertDlcStateToPackResult(dlc_state);
  result.feature_id = feature_id;
  result.language_code = locale;
  for (Observer& observer : observers_) {
    observer.OnPackStateChanged(result);
  }
}

void LanguagePackManager::OnDlcStateChanged(
    const dlcservice::DlcState& dlc_state) {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

  const std::optional<std::string> handwriting_locale =
      DlcToHandwritingLocale(dlc_state.id());
  if (handwriting_locale.has_value()) {
    NotifyPackStateChanged(kHandwritingFeatureId, *handwriting_locale,
                           dlc_state);
  }

  const std::optional<std::string> tts_locale = DlcToTtsLocale(dlc_state.id());
  if (tts_locale.has_value()) {
    NotifyPackStateChanged(kTtsFeatureId, *tts_locale, dlc_state);
  }
}

LanguagePackManager::LanguagePackManager() {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  CHECK(!g_instance);
  g_instance = this;
  DlcserviceClient* client = DlcserviceClient::Get();
  if (client) {
    obs_.Observe(client);
  } else {
    CHECK_IS_TEST();
    // No observation.
  }
}

LanguagePackManager::~LanguagePackManager() {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  CHECK_EQ(g_instance, this);
  pref_change_registrar_.RemoveAll();
  g_instance = nullptr;
}

void LanguagePackManager::Initialise() {
  // Heap-allocates an instance, which is then set in `g_instance` in the
  // constructor.
  // This instance will be cleaned up in `Shutdown()`.
  // Calling this while `g_instance` is set will result in a `CHECK` failure
  // instead of a memory leak.
  new LanguagePackManager();
}

void LanguagePackManager::Shutdown() {
  CHECK(g_instance);
  delete g_instance;
}

// static
LanguagePackManager* LanguagePackManager::GetInstance() {
  return g_instance;
}

}  // namespace ash::language_packs