// 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 "chromeos/ash/components/scalable_iph/scalable_iph.h"

#include <memory>
#include <string_view>
#include <vector>

#include "ash/constants/ash_features.h"
#include "base/check.h"
#include "base/check_is_test.h"
#include "base/containers/enum_set.h"
#include "base/containers/fixed_flat_map.h"
#include "base/containers/fixed_flat_set.h"
#include "base/feature_list.h"
#include "base/functional/bind.h"
#include "base/location.h"
#include "base/memory/raw_ptr.h"
#include "base/metrics/field_trial_params.h"
#include "base/no_destructor.h"
#include "base/notreached.h"
#include "base/strings/strcat.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_split.h"
#include "base/strings/stringprintf.h"
#include "base/time/time.h"
#include "chromeos/ash/components/scalable_iph/config.h"
#include "chromeos/ash/components/scalable_iph/iph_session.h"
#include "chromeos/ash/components/scalable_iph/logger.h"
#include "chromeos/ash/components/scalable_iph/scalable_iph_constants.h"
#include "chromeos/ash/components/scalable_iph/scalable_iph_delegate.h"
#include "components/feature_engagement/public/feature_constants.h"

namespace scalable_iph {

namespace {

using NotificationParams =
    ::scalable_iph::ScalableIphDelegate::NotificationParams;
using BubbleParams = ::scalable_iph::ScalableIphDelegate::BubbleParams;
using BubbleIcon = ::scalable_iph::ScalableIphDelegate::BubbleIcon;

constexpr char kFunctionCallAfterKeyedServiceShutdown[] =
    "Function call after keyed service shutdown.";

// A set of ScalableIph events which can trigger an IPH.
constexpr auto kIphTriggeringEvents =
    base::MakeFixedFlatSet<ScalableIph::Event>(
        {ScalableIph::Event::kFiveMinTick, ScalableIph::Event::kUnlocked});

bool force_enable_iph_feature_for_testing = false;

std::string GetHelpAppIphEventName(ActionType action_type) {
  switch (action_type) {
    case ActionType::kOpenChrome:
      return kEventNameHelpAppActionTypeOpenChrome;
    case ActionType::kOpenLauncher:
      return kEventNameHelpAppActionTypeOpenLauncher;
    case ActionType::kOpenPersonalizationApp:
      return kEventNameHelpAppActionTypeOpenPersonalizationApp;
    case ActionType::kOpenPlayStore:
      return kEventNameHelpAppActionTypeOpenPlayStore;
    case ActionType::kOpenGoogleDocs:
      return kEventNameHelpAppActionTypeOpenGoogleDocs;
    case ActionType::kOpenGooglePhotos:
      return kEventNameHelpAppActionTypeOpenGooglePhotos;
    case ActionType::kOpenSettingsPrinter:
      return kEventNameHelpAppActionTypeOpenSettingsPrinter;
    case ActionType::kOpenPhoneHub:
      return kEventNameHelpAppActionTypeOpenPhoneHub;
    case ActionType::kOpenYouTube:
      return kEventNameHelpAppActionTypeOpenYouTube;
    case ActionType::kOpenFileManager:
      return kEventNameHelpAppActionTypeOpenFileManager;
    case ActionType::kInvalid:
    default:
      return "";
  }
}

// The list of IPH features `SclableIph` supports. `ScalableIph` checks trigger
// conditions of all events listed in this list when it receives an `Event`.
const std::vector<raw_ptr<const base::Feature, VectorExperimental>>&
GetFeatureListConstant() {
  static const base::NoDestructor<
      std::vector<raw_ptr<const base::Feature, VectorExperimental>>>
      feature_list({
          // This must be sorted from One to Ten. A config expects that IPHs are
          // evaluated in this priority.
          // Timer based.
          &feature_engagement::kIPHScalableIphTimerBasedOneFeature,
          &feature_engagement::kIPHScalableIphTimerBasedTwoFeature,
          &feature_engagement::kIPHScalableIphTimerBasedThreeFeature,
          &feature_engagement::kIPHScalableIphTimerBasedFourFeature,
          &feature_engagement::kIPHScalableIphTimerBasedFiveFeature,
          &feature_engagement::kIPHScalableIphTimerBasedSixFeature,
          &feature_engagement::kIPHScalableIphTimerBasedSevenFeature,
          &feature_engagement::kIPHScalableIphTimerBasedEightFeature,
          &feature_engagement::kIPHScalableIphTimerBasedNineFeature,
          &feature_engagement::kIPHScalableIphTimerBasedTenFeature,
          // Unlocked based.
          &feature_engagement::kIPHScalableIphUnlockedBasedOneFeature,
          &feature_engagement::kIPHScalableIphUnlockedBasedTwoFeature,
          &feature_engagement::kIPHScalableIphUnlockedBasedThreeFeature,
          &feature_engagement::kIPHScalableIphUnlockedBasedFourFeature,
          &feature_engagement::kIPHScalableIphUnlockedBasedFiveFeature,
          &feature_engagement::kIPHScalableIphUnlockedBasedSixFeature,
          &feature_engagement::kIPHScalableIphUnlockedBasedSevenFeature,
          &feature_engagement::kIPHScalableIphUnlockedBasedEightFeature,
          &feature_engagement::kIPHScalableIphUnlockedBasedNineFeature,
          &feature_engagement::kIPHScalableIphUnlockedBasedTenFeature,
          // Help App based.
          &feature_engagement::kIPHScalableIphHelpAppBasedNudgeFeature,
          &feature_engagement::kIPHScalableIphHelpAppBasedOneFeature,
          &feature_engagement::kIPHScalableIphHelpAppBasedTwoFeature,
          &feature_engagement::kIPHScalableIphHelpAppBasedThreeFeature,
          &feature_engagement::kIPHScalableIphHelpAppBasedFourFeature,
          &feature_engagement::kIPHScalableIphHelpAppBasedFiveFeature,
          &feature_engagement::kIPHScalableIphHelpAppBasedSixFeature,
          &feature_engagement::kIPHScalableIphHelpAppBasedSevenFeature,
          &feature_engagement::kIPHScalableIphHelpAppBasedEightFeature,
          &feature_engagement::kIPHScalableIphHelpAppBasedNineFeature,
          &feature_engagement::kIPHScalableIphHelpAppBasedTenFeature,
          // Gaming.
          &feature_engagement::kIPHScalableIphGamingFeature,
      });
  return *feature_list;
}

constexpr auto kActionTypesMap =
    // Key will be set in server side config.
    base::MakeFixedFlatMap<std::string_view, ActionType>({
        {kActionTypeOpenChrome, ActionType::kOpenChrome},
        {kActionTypeOpenLauncher, ActionType::kOpenLauncher},
        {kActionTypeOpenPersonalizationApp,
         ActionType::kOpenPersonalizationApp},
        {kActionTypeOpenPlayStore, ActionType::kOpenPlayStore},
        {kActionTypeOpenGoogleDocs, ActionType::kOpenGoogleDocs},
        {kActionTypeOpenGooglePhotos, ActionType::kOpenGooglePhotos},
        {kActionTypeOpenSettingsPrinter, ActionType::kOpenSettingsPrinter},
        {kActionTypeOpenPhoneHub, ActionType::kOpenPhoneHub},
        {kActionTypeOpenYouTube, ActionType::kOpenYouTube},
        {kActionTypeOpenFileManager, ActionType::kOpenFileManager},
        {kActionTypeOpenHelpAppPerks, ActionType::kOpenHelpAppPerks},
        {kActionTypeOpenChromebookPerksWeb,
         ActionType::kOpenChromebookPerksWeb},
        {kActionTypeOpenChromebookPerksGfnPriority2022,
         ActionType::kOpenChromebookPerksGfnPriority2022},
        {kActionTypeOpenChromebookPerksMinecraft2023,
         ActionType::kOpenChromebookPerksMinecraft2023},
        {kActionTypeOpenChromebookPerksMinecraftRealms2023,
         ActionType::kOpenChromebookPerksMinecraftRealms2023},
    });

constexpr auto kBubbleIconsMap =
    // Key will be set in server side config.
    base::MakeFixedFlatMap<std::string_view, BubbleIcon>({
        {kBubbleIconChromeIcon, BubbleIcon::kChromeIcon},
        {kBubbleIconPlayStoreIcon, BubbleIcon::kPlayStoreIcon},
        {kBubbleIconGoogleDocsIcon, BubbleIcon::kGoogleDocsIcon},
        {kBubbleIconGooglePhotosIcon, BubbleIcon::kGooglePhotosIcon},
        {kBubbleIconPrintJobsIcon, BubbleIcon::kPrintJobsIcon},
        {kBubbleIconYouTubeIcon, BubbleIcon::kYouTubeIcon},
    });

constexpr auto kAppListItemActivationEventsMap =
    base::MakeFixedFlatMap<std::string_view, ScalableIph::Event>({
        {kWebAppGoogleDocsAppId,
         ScalableIph::Event::kAppListItemActivationGoogleDocs},
        {kWebAppYouTubeAppId,
         ScalableIph::Event::kAppListItemActivationYouTube},
        {kWebAppGooglePhotosAppId,
         ScalableIph::Event::kAppListItemActivationGooglePhotosWeb},
        {kAndroidAppGooglePlayStoreAppId,
         ScalableIph::Event::kAppListItemActivationGooglePlayStore},
        {kAndroidAppGooglePhotosAppId,
         ScalableIph::Event::kAppListItemActivationGooglePhotosAndroid},
    });

constexpr auto kShelfItemActivationEventsMap =
    base::MakeFixedFlatMap<std::string_view, ScalableIph::Event>({
        {kWebAppGoogleDocsAppId,
         ScalableIph::Event::kShelfItemActivationGoogleDocs},
        {kWebAppYouTubeAppId, ScalableIph::Event::kShelfItemActivationYouTube},
        {kWebAppGooglePhotosAppId,
         ScalableIph::Event::kShelfItemActivationGooglePhotosWeb},
        {kAndroidGooglePhotosAppId,
         ScalableIph::Event::kShelfItemActivationGooglePhotosAndroid},
    });

constexpr base::TimeDelta kTimeTickEventInterval = base::Minutes(5);

std::string GetEventName(ScalableIph::Event event) {
  // Use switch statement as you can get a compiler error if you forget to add a
  // conversion.
  switch (event) {
    case ScalableIph::Event::kFiveMinTick:
      return kEventNameFiveMinTick;
    case ScalableIph::Event::kUnlocked:
      return kEventNameUnlocked;
    case ScalableIph::Event::kAppListShown:
      return kEventNameAppListShown;
    case ScalableIph::Event::kAppListItemActivationYouTube:
      return kEventNameAppListItemActivationYouTube;
    case ScalableIph::Event::kAppListItemActivationGoogleDocs:
      return kEventNameAppListItemActivationGoogleDocs;
    case ScalableIph::Event::kAppListItemActivationGooglePhotosWeb:
      return kEventNameAppListItemActivationGooglePhotosWeb;
    case ScalableIph::Event::kOpenPersonalizationApp:
      return kEventNameOpenPersonalizationApp;
    case ScalableIph::Event::kShelfItemActivationYouTube:
      return kEventNameShelfItemActivationYouTube;
    case ScalableIph::Event::kShelfItemActivationGoogleDocs:
      return kEventNameShelfItemActivationGoogleDocs;
    case ScalableIph::Event::kShelfItemActivationGooglePhotosWeb:
      return kEventNameShelfItemActivationGooglePhotosWeb;
    case ScalableIph::Event::kShelfItemActivationGooglePhotosAndroid:
      return kEventNameShelfItemActivationGooglePhotosAndroid;
    case ScalableIph::Event::kShelfItemActivationGooglePlay:
      return kEventNameShelfItemActivationGooglePlay;
    case ScalableIph::Event::kAppListItemActivationGooglePlayStore:
      return kEventNameAppListItemActivationGooglePlayStore;
    case ScalableIph::Event::kAppListItemActivationGooglePhotosAndroid:
      return kEventNameAppListItemActivationGooglePhotosAndroid;
    case ScalableIph::Event::kPrintJobCreated:
      return kEventNamePrintJobCreated;
    case ScalableIph::Event::kGameWindowOpened:
      return kEventNameGameWindowOpened;
  }
}

std::string GetParamValue(const base::Feature& feature,
                          const std::string& param_name) {
  std::unique_ptr<Config> config = GetConfig(feature);
  if (config && config->params.contains(param_name)) {
    return config->params.at(param_name);
  }

  std::string fully_qualified_param_name =
      base::StrCat({feature.name, "_", param_name});
  std::string value = base::GetFieldTrialParamValueByFeature(
      feature, fully_qualified_param_name);

  // Non-fully-qualified name field must always be empty.
  DCHECK(base::GetFieldTrialParamValueByFeature(feature, param_name).empty())
      << param_name
      << " is specified in a non-fully-qualified way. It should be specified "
         "as "
      << fully_qualified_param_name
      << ". It's often the case in Scalable Iph to enable multiple features at "
         "once. To avoid an unexpected fall-back behavior, non-fully-qualified "
         "name is not accepted. Parameter names of custom fields must be "
         "specified in a fully qualified way: [Feature Name]_[Parameter Name]";

  return value;
}

void LogParamValueParseError(Logger* logger,
                             const base::Location& location,
                             const std::string& feature_name,
                             const std::string& param_name) {
  logger->Log(
      location,
      base::StringPrintf(
          "%s does not have a valid %s param value. Stop parsing the config.",
          feature_name.c_str(), param_name.c_str()));
}

UiType ParseUiType(Logger* logger, const base::Feature& feature) {
  std::string ui_type = GetParamValue(feature, kCustomUiTypeParamName);
  if (ui_type != kCustomUiTypeValueNotification &&
      ui_type != kCustomUiTypeValueBubble &&
      ui_type != kCustomUiTypeValueNone) {
    SCALABLE_IPH_LOG(logger) << ui_type << " is not a valid UI type.";
  }

  if (ui_type == kCustomUiTypeValueNotification) {
    return UiType::kNotification;
  }

  if (ui_type == kCustomUiTypeValueBubble) {
    return UiType::kBubble;
  }

  return UiType::kNone;
}

UiType GetUiType(Logger* logger, const base::Feature& feature) {
  std::unique_ptr<Config> config = GetConfig(feature);
  if (config) {
    return config->ui_type;
  }

  return ParseUiType(logger, feature);
}

ActionType ParseActionType(const std::string& action_type_string) {
  auto it = kActionTypesMap.find(action_type_string);
  if (it == kActionTypesMap.end()) {
    // If the server side config action type cannot be parsed, will return the
    // kInvalid as the parsed result.
    return ActionType::kInvalid;
  }

  return it->second;
}

std::string ParseActionEventName(const std::string& event_used_param) {
  // The `event_used_param` is in this format:
  // `name:ScalableIphTimerBasedOneEventUsed;comparator:any;window:365;storage:365`.
  auto key_values = base::SplitString(
      event_used_param, ";", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
  if (key_values.size() != 4) {
    return "";
  }
  auto name_value = base::SplitString(key_values[0], ":", base::TRIM_WHITESPACE,
                                      base::SPLIT_WANT_NONEMPTY);
  if (name_value.size() != 2) {
    return "";
  }

  if (name_value[0] != "name") {
    return "";
  }
  return name_value[1];
}

ScalableIphDelegate::NotificationIcon GetNotificationIcon(
    const std::string& icon) {
  if (icon == kCustomNotificationIconValueRedeem) {
    return ScalableIphDelegate::NotificationIcon::kRedeem;
  }

  return ScalableIphDelegate::NotificationIcon::kDefault;
}

ScalableIphDelegate::NotificationSummaryText GetNotificationSummaryText(
    const std::string& summary_text) {
  if (summary_text == kCustomNotificationSummaryTextValueNone) {
    return ScalableIphDelegate::NotificationSummaryText::kNone;
  }

  return ScalableIphDelegate::NotificationSummaryText::kWelcomeTips;
}

std::unique_ptr<NotificationParams> ParseNotificationParams(
    Logger* logger,
    const base::Feature& feature) {
  std::unique_ptr<NotificationParams> param =
      std::make_unique<NotificationParams>();
  param->notification_id =
      GetParamValue(feature, kCustomNotificationIdParamName);
  if (param->notification_id.empty()) {
    LogParamValueParseError(logger, FROM_HERE, feature.name,
                            kCustomNotificationIdParamName);
    return nullptr;
  }
  param->title = GetParamValue(feature, kCustomNotificationTitleParamName);
  if (param->title.empty()) {
    LogParamValueParseError(logger, FROM_HERE, feature.name,
                            kCustomNotificationTitleParamName);
    return nullptr;
  }

  // Notification body text is an optional field. This can take an empty string.
  param->text = GetParamValue(feature, kCustomNotificationBodyTextParamName);

  param->button.text =
      GetParamValue(feature, kCustomNotificationButtonTextParamName);
  if (param->button.text.empty()) {
    LogParamValueParseError(logger, FROM_HERE, feature.name,
                            kCustomNotificationButtonTextParamName);
    return nullptr;
  }
  std::string action_type =
      GetParamValue(feature, kCustomButtonActionTypeParamName);
  if (action_type.empty()) {
    LogParamValueParseError(logger, FROM_HERE, feature.name,
                            kCustomButtonActionTypeParamName);
    return nullptr;
  }
  param->button.action.action_type = ParseActionType(action_type);
  if (param->button.action.action_type == ActionType::kInvalid) {
    LogParamValueParseError(logger, FROM_HERE, feature.name,
                            kCustomButtonActionTypeParamName);
    return nullptr;
  }
  std::string event_used =
      GetParamValue(feature, kCustomButtonActionEventParamName);
  if (event_used.empty()) {
    LogParamValueParseError(logger, FROM_HERE, feature.name,
                            kCustomButtonActionEventParamName);
    return nullptr;
  }
  param->button.action.iph_event_name = ParseActionEventName(event_used);
  if (param->button.action.iph_event_name.empty()) {
    LogParamValueParseError(logger, FROM_HERE, feature.name,
                            kCustomButtonActionEventParamName);
    return nullptr;
  }

  std::string image_type =
      GetParamValue(feature, kCustomNotificationImageTypeParamName);
  param->image_type = ScalableIphDelegate::NotificationImageType::kNoImage;
  if (image_type == kCustomNotificationImageTypeValueWallpaper) {
    param->image_type = ScalableIphDelegate::NotificationImageType::kWallpaper;
  } else if (image_type == kCustomNotificationImageTypeValueMinecraft) {
    param->image_type = ScalableIphDelegate::NotificationImageType::kMinecraft;
  }

  std::string icon = GetParamValue(feature, kCustomNotificationIconParamName);
  if (!icon.empty()) {
    param->icon = GetNotificationIcon(icon);
  }
  SCALABLE_IPH_LOG(logger) << kCustomNotificationIconParamName
                           << " is specified as " << icon << ". " << param->icon
                           << " is set.";

  std::string summary_text =
      GetParamValue(feature, kCustomNotificationSummaryTextParamName);
  if (!summary_text.empty()) {
    param->summary_text = GetNotificationSummaryText(summary_text);
  }
  SCALABLE_IPH_LOG(logger) << kCustomNotificationSummaryTextParamName
                           << " is specified as " << summary_text << ". "
                           << param->summary_text << " is set.";

  std::string source =
      GetParamValue(feature, kCustomNotificationSourceTextParamName);
  if (!source.empty()) {
    param->source = source;
  } else {
    param->source = kCustomNotificationSourceTextValueDefault;
  }
  SCALABLE_IPH_LOG(logger) << kCustomNotificationSourceTextParamName
                           << " is specified as " << source << ". "
                           << param->source << " is set.";

  return param;
}

std::unique_ptr<NotificationParams> GetNotificationParams(
    Logger* logger,
    const base::Feature& feature) {
  std::unique_ptr<Config> config = GetConfig(feature);
  if (config) {
    return std::move(config->notification_params);
  }

  return ParseNotificationParams(logger, feature);
}

BubbleIcon ParseBubbleIcon(const std::string& icon_string) {
  auto it = kBubbleIconsMap.find(icon_string);
  if (it == kBubbleIconsMap.end()) {
    // If the server side config bubble icon cannot be parsed, will return the
    // kNoIcon as the parsed result.
    return BubbleIcon::kNoIcon;
  }
  return it->second;
}

std::unique_ptr<BubbleParams> ParseBubbleParams(Logger* logger,
                                                const base::Feature& feature) {
  std::unique_ptr<BubbleParams> param = std::make_unique<BubbleParams>();
  param->bubble_id = GetParamValue(feature, kCustomBubbleIdParamName);
  if (param->bubble_id.empty()) {
    LogParamValueParseError(logger, FROM_HERE, feature.name,
                            kCustomBubbleIdParamName);
    return nullptr;
  }
  // Title of bubble could be empty.
  param->title = GetParamValue(feature, kCustomBubbleTitleParamName);
  param->text = GetParamValue(feature, kCustomBubbleTextParamName);
  if (param->text.empty()) {
    LogParamValueParseError(logger, FROM_HERE, feature.name,
                            kCustomBubbleTextParamName);
    return nullptr;
  }

  // Button and action:
  // Some nudge may not have a button and action.
  param->button.text = GetParamValue(feature, kCustomBubbleButtonTextParamName);
  if (!param->button.text.empty()) {
    std::string action_type =
        GetParamValue(feature, kCustomButtonActionTypeParamName);
    if (action_type.empty()) {
      LogParamValueParseError(logger, FROM_HERE, feature.name,
                              kCustomButtonActionTypeParamName);
      return nullptr;
    }

    param->button.action.action_type = ParseActionType(action_type);
    if (param->button.action.action_type == ActionType::kInvalid) {
      LogParamValueParseError(logger, FROM_HERE, feature.name,
                              kCustomButtonActionTypeParamName);
      return nullptr;
    }

    std::string event_used =
        GetParamValue(feature, kCustomButtonActionEventParamName);
    if (event_used.empty()) {
      LogParamValueParseError(logger, FROM_HERE, feature.name,
                              kCustomButtonActionEventParamName);
      return nullptr;
    }
    param->button.action.iph_event_name = ParseActionEventName(event_used);
    if (param->button.action.iph_event_name.empty()) {
      LogParamValueParseError(logger, FROM_HERE, feature.name,
                              kCustomButtonActionEventParamName);
      return nullptr;
    }
  }

  auto icon_string = GetParamValue(feature, kCustomBubbleIconParamName);
  param->icon = ParseBubbleIcon(icon_string);
  param->anchor_view_app_id =
      GetParamValue(feature, kCustomBubbleAnchorViewAppIdParamName);

  return param;
}

std::unique_ptr<BubbleParams> GetBubbleParams(Logger* logger,
                                              const base::Feature& feature) {
  std::unique_ptr<Config> config = GetConfig(feature);
  if (config) {
    return std::move(config->bubble_params);
  }

  return ParseBubbleParams(logger, feature);
}

bool ValidateVersionNumber(const base::Feature& feature) {
  std::unique_ptr<Config> config = GetConfig(feature);
  if (config) {
    return config->version_number == kCurrentVersionNumber;
  }

  std::string version_number_value =
      GetParamValue(feature, kCustomParamsVersionNumberParamName);
  if (version_number_value.empty()) {
    return false;
  }

  int version_number = 0;
  if (!base::StringToInt(version_number_value, &version_number)) {
    return false;
  }

  return version_number == kCurrentVersionNumber;
}

// `ScalableIphDelegate::SessionState` can take four states:
// `kUnknownInitialValue`, `kActive`, `kLocked`, `kOther`. We care two cases:
//
// 1. Session start
// For session start, we observe `kUnknownInitialValue` -[any intermediate
// states]-> `kActive` as unlock event. To allow [any intermediate states] in
// the middle, we won't advance internal `session_state_` during the phase. In
// production, there is `session_manager::SessionState::LOGGED_IN_NOT_ACTIVE`,
// which will be observed as: `kUnknownInitialValue` -> `kOther` -> `kActive`.
//
// 2. Unlock event
// For unlock event, we observe `kLocked` -> `kActive` as unlock event.
//
// This method returns `TransitionSet`, which is a set of enums. `GetTransition`
// does not maintain its state. But it expect the caller to manage it. The set
// specifies expected operations for the caller: advancing its internal state,
// handling unlock transition.
ScalableIph::TransitionSet GetTransition(ScalableIphDelegate::SessionState from,
                                         ScalableIphDelegate::SessionState to) {
  if (from == to) {
    // Note that `OnSessionStateChanged` can be called more than once with the
    // same `session_state` as `session_manager::SessionState` does not map to
    // `ScalableIphDelegate::SessionState` with a 1:1 mapping, e.g.
    // `ScalableIphDelegate::SessionState::kOther` is mapped to several states
    // of `session_manager::SessionState`.
    return {};
  }

  if (to == ScalableIphDelegate::SessionState::kUnknownInitialValue) {
    // There should be no transition to `kUnknownInitialValue`. Ignore those
    // transitions.
    return {};
  }

  switch (from) {
    case ScalableIphDelegate::SessionState::kUnknownInitialValue:
      if (to == ScalableIphDelegate::SessionState::kActive) {
        return {ScalableIph::SessionStateTransition::kAdvanceState,
                ScalableIph::SessionStateTransition::kUnlock};
      }
      return {};
    case ScalableIphDelegate::SessionState::kOther:
      return {ScalableIph::SessionStateTransition::kAdvanceState};
    case ScalableIphDelegate::SessionState::kLocked:
      return to == ScalableIphDelegate::SessionState::kActive
                 ? ScalableIph::TransitionSet(
                       {ScalableIph::SessionStateTransition::kAdvanceState,
                        ScalableIph::SessionStateTransition::kUnlock})
                 : ScalableIph::TransitionSet(
                       {ScalableIph::SessionStateTransition::kAdvanceState});
    case ScalableIphDelegate::SessionState::kActive:
      return {ScalableIph::SessionStateTransition::kAdvanceState};
  }
}

}  // namespace

// static
bool ScalableIph::IsAnyIphFeatureEnabled() {
  if (force_enable_iph_feature_for_testing) {
    return true;
  }

  const std::vector<raw_ptr<const base::Feature, VectorExperimental>>&
      feature_list = GetFeatureListConstant();
  for (auto feature : feature_list) {
    if (base::FeatureList::IsEnabled(*feature)) {
      return true;
    }
  }
  return false;
}

// static
void ScalableIph::ForceEnableIphFeatureForTesting() {
  CHECK_IS_TEST();
  CHECK(!force_enable_iph_feature_for_testing)
      << "Iph feature is already force enabled";

  force_enable_iph_feature_for_testing = true;
}

ScalableIph::ScalableIph(feature_engagement::Tracker* tracker,
                         std::unique_ptr<ScalableIphDelegate> delegate,
                         std::unique_ptr<Logger> logger)
    : tracker_(tracker),
      delegate_(std::move(delegate)),
      logger_(std::move(logger)) {
  CHECK(tracker_);
  CHECK(delegate_);
  CHECK(logger_);

  delegate_observation_.Observe(delegate_.get());

  EnsureTimerStarted();

  online_ = delegate_->IsOnline();

  SCALABLE_IPH_LOG(GetLogger()) << "Initialize: Online: " << online_;

  tracker_->AddOnInitializedCallback(
      base::BindOnce(&ScalableIph::CheckTriggerConditionsOnInitSuccess,
                     weak_ptr_factory_.GetWeakPtr()));
}

ScalableIph::~ScalableIph() = default;

void ScalableIph::Shutdown() {
  timer_.Stop();

  tracker_ = nullptr;

  delegate_observation_.Reset();
  delegate_.reset();
}

void ScalableIph::OnConnectionChanged(bool online) {
  if (online_ == online) {
    return;
  }

  online_ = online;

  SCALABLE_IPH_LOG(GetLogger())
      << "Connection status changed. Online: " << online;

  tracker_->AddOnInitializedCallback(
      base::BindOnce(&ScalableIph::CheckTriggerConditionsOnInitSuccess,
                     weak_ptr_factory_.GetWeakPtr()));
}

void ScalableIph::OnSessionStateChanged(
    ScalableIphDelegate::SessionState new_session_state) {
  TransitionSet transition_set =
      GetTransition(session_state_, new_session_state);
  if (transition_set.empty()) {
    SCALABLE_IPH_LOG(GetLogger())
        << "Uninterested session state transition observed from "
        << session_state_ << " to " << new_session_state
        << ". No state update made. No unlock event observed.";
  }

  // State transition must happen before `RecordEvent` as any code after
  // `RecordEvent` can read the latest state.
  if (transition_set.Has(SessionStateTransition::kAdvanceState)) {
    SCALABLE_IPH_LOG(GetLogger())
        << "Session state changed from " << session_state_ << " to "
        << new_session_state;
    session_state_ = new_session_state;
  }

  if (transition_set.Has(SessionStateTransition::kUnlock)) {
    SCALABLE_IPH_LOG(GetLogger()) << "Transition is recognized as unlock event";
    // Recording `kUnlocked` can trigger condition checks.
    RecordEvent(Event::kUnlocked);
  }
}

void ScalableIph::OnSuspendDoneWithoutLockScreen() {
  if (session_state_ == ScalableIphDelegate::SessionState::kLocked) {
    SCALABLE_IPH_LOG(GetLogger())
        << "Unexpected ScalableIph::OnSuspendDoneWithoutLockScreen call";
    DCHECK(false) << "OnSuspendDoneWithoutLockScreen should never be called "
                     "with a lock screen";
  }

  SCALABLE_IPH_LOG(GetLogger())
      << "Recording kUnlocked because of OnSuspendDoneWithoutLockScreen";
  RecordEvent(Event::kUnlocked);
}

void ScalableIph::OnAppListVisibilityChanged(bool shown) {
  SCALABLE_IPH_LOG(GetLogger())
      << "App list visibility changed. Shown: " << shown;

  if (shown) {
    RecordEvent(Event::kAppListShown);
  }
}

void ScalableIph::OnHasSavedPrintersChanged(bool has_saved_printers) {
  DCHECK_NE(has_saved_printers_, has_saved_printers);

  has_saved_printers_ = has_saved_printers;

  SCALABLE_IPH_LOG(GetLogger())
      << "Has saved printers status changed. Has saved printers: "
      << has_saved_printers;

  if (!has_saved_printers_closure_for_testing_.is_null()) {
    has_saved_printers_closure_for_testing_.Run();
    has_saved_printers_closure_for_testing_.Reset();
  }
}

void ScalableIph::OnPhoneHubOnboardingEligibleChanged(
    bool phonehub_onboarding_eligible) {
  DCHECK_NE(phonehub_onboarding_eligible_, phonehub_onboarding_eligible);

  SCALABLE_IPH_LOG(GetLogger())
      << "Phonehub onboarding eligible state has "
         "changed: Phone hub onboarding eligible: from: "
      << phonehub_onboarding_eligible_
      << " to: " << phonehub_onboarding_eligible;

  phonehub_onboarding_eligible_ = phonehub_onboarding_eligible;
}

void ScalableIph::PerformActionForIphSession(ActionType action_type) {
  SCALABLE_IPH_LOG(GetLogger())
      << "Performing an action for an iph session. Action type:" << action_type;
  PerformAction(action_type);
}

void ScalableIph::MaybeRecordAppListItemActivation(const std::string& id) {
  auto it = kAppListItemActivationEventsMap.find(id);
  if (it == kAppListItemActivationEventsMap.end()) {
    SCALABLE_IPH_LOG(GetLogger())
        << "Observed an app list item activation. But not recording an app "
           "list item activation as it's not listed in the map.";
    return;
  }

  SCALABLE_IPH_LOG(GetLogger())
      << "Recording an app list item activation as event: " << it->second;
  // Record an event via `RecordEvent` instead of directly notifying an event to
  // `tracker_` as `RecordEvent` can do common tasks, e.g. Making sure that a
  // `tracker_` is initialized, etc.
  RecordEvent(it->second);
}

void ScalableIph::MaybeRecordShelfItemActivationById(const std::string& id) {
  auto it = kShelfItemActivationEventsMap.find(id);
  if (it == kShelfItemActivationEventsMap.end()) {
    SCALABLE_IPH_LOG(GetLogger())
        << "Observed a shelf item activation. But not recording a shelf item "
           "activation as it's not listed in the map.";
    return;
  }

  SCALABLE_IPH_LOG(GetLogger())
      << "Recording a shelf item activation as event: " << it->second;
  RecordEvent(it->second);
}

void ScalableIph::OverrideFeatureListForTesting(
    const std::vector<raw_ptr<const base::Feature, VectorExperimental>>
        feature_list) {
  CHECK(feature_list_for_testing_.size() == 0)
      << "It's NOT allowed to override feature list twice for testing";
  CHECK(feature_list.size() > 0) << "An empty list is NOT allowed to set.";

  feature_list_for_testing_ = feature_list;
}

void ScalableIph::OverrideTaskRunnerForTesting(
    scoped_refptr<base::SequencedTaskRunner> task_runner) {
  CHECK(timer_.IsRunning())
      << "Timer is expected to be always running until Shutdown";
  timer_.Stop();
  timer_.SetTaskRunner(task_runner);
  EnsureTimerStarted();
}

const std::vector<raw_ptr<const base::Feature, VectorExperimental>>&
ScalableIph::GetFeatureListConstantForTesting() {
  CHECK_IS_TEST();
  return GetFeatureListConstant();
}

// static:
ScalableIph::TransitionSet ScalableIph::GetTransitionForTesting(
    ScalableIphDelegate::SessionState from,
    ScalableIphDelegate::SessionState to) {
  CHECK_IS_TEST();
  return GetTransition(from, to);
}

bool ScalableIph::CheckTriggerEventForTesting(
    const base::Feature& feature,
    const std::optional<ScalableIph::Event>& trigger_event) {
  CHECK_IS_TEST();
  return CheckTriggerEvent(feature, trigger_event);
}

bool ScalableIph::ShouldPinHelpAppToShelf() {
  return ash::features::AreHelpAppWelcomeTipsEnabled();
}

void ScalableIph::PerformActionForHelpApp(ActionType action_type) {
  SCALABLE_IPH_LOG(GetLogger())
      << "Perform action for help app. Action type: " << action_type;

  std::string iph_event_name = GetHelpAppIphEventName(action_type);

  // ActionType enum is defined on the client side. We can use CHECK as this is
  // a client side constraint.
  CHECK(!iph_event_name.empty()) << "Unable to resolve the IPH event name to "
                                    "an action type for the help app";

  tracker_->NotifyEvent(iph_event_name);

  PerformAction(action_type);
}

void ScalableIph::PerformAction(ActionType action_type) {
  delegate_->PerformActionForScalableIph(action_type);
}

void ScalableIph::SetHasSavedPrintersChangedClosureForTesting(
    base::RepeatingClosure has_saved_printers_closure) {
  CHECK(has_saved_printers_closure_for_testing_.is_null());
  has_saved_printers_closure_for_testing_ =
      std::move(has_saved_printers_closure);
}

void ScalableIph::RecordEvent(ScalableIph::Event event) {
  SCALABLE_IPH_LOG(GetLogger()) << "Record event. Event: " << event;

  if (!tracker_) {
    DCHECK(false) << kFunctionCallAfterKeyedServiceShutdown;
    return;
  }

  // `AddOnInitializedCallback` immediately calls the callback if it's already
  // initialized.
  tracker_->AddOnInitializedCallback(
      base::BindOnce(&ScalableIph::RecordEventInternal,
                     weak_ptr_factory_.GetWeakPtr(), event));
}

Logger* ScalableIph::GetLogger() {
  return logger_.get();
}

void ScalableIph::EnsureTimerStarted() {
  timer_.Start(FROM_HERE, kTimeTickEventInterval,
               base::BindRepeating(&ScalableIph::RecordTimeTickEvent,
                                   weak_ptr_factory_.GetWeakPtr()));
}

void ScalableIph::RecordTimeTickEvent() {
  // Do not record timer event outside of an active session, e.g. OOBE, lock
  // screen.
  if (session_state_ != ScalableIphDelegate::SessionState::kActive) {
    SCALABLE_IPH_LOG(GetLogger())
        << "Observed time tick event. But not recording it as session state is "
           "not Active. Current session state is: "
        << session_state_;
    return;
  }

  SCALABLE_IPH_LOG(GetLogger()) << "Record time tick event.";
  RecordEvent(Event::kFiveMinTick);
}

void ScalableIph::RecordEventInternal(ScalableIph::Event event,
                                      bool init_success) {
  if (!tracker_) {
    DCHECK(false) << kFunctionCallAfterKeyedServiceShutdown;
    return;
  }

  if (!init_success) {
    SCALABLE_IPH_LOG(GetLogger())
        << "Failed to initialize feature_engagement::Tracker";
    DCHECK(false) << "Failed to initialize feature_engagement::Tracker.";
    return;
  }

  if (session_state_ != ScalableIphDelegate::SessionState::kActive) {
    SCALABLE_IPH_LOG(GetLogger())
        << "No event is expected to be recorded outside of an active session.";
    return;
  }

  const std::string event_name = GetEventName(event);
  SCALABLE_IPH_LOG(GetLogger()) << "Recording event as " << event_name;
  tracker_->NotifyEvent(event_name);

  if (kIphTriggeringEvents.contains(event)) {
    SCALABLE_IPH_LOG(GetLogger()) << event
                                  << " is a condition check triggering event. "
                                     "Running trigger conditions check.";
    CheckTriggerConditions(event);
  }
}

void ScalableIph::CheckTriggerConditionsOnInitSuccess(bool init_success) {
  if (!init_success) {
    SCALABLE_IPH_LOG(GetLogger())
        << "Failed to initialize feature_engagement::Tracker.";
    return;
  }

  CheckTriggerConditions(std::nullopt);
}

void ScalableIph::CheckTriggerConditions(
    const std::optional<ScalableIph::Event>& trigger_event) {
  // Make sure that `tracker_` is initialized. `tracker_` should not cause crash
  // even if we call `ShouldTriggerHelpUI` before initialization. But it returns
  // false. It can become a difficult to notice/debug bug if we accidentally
  // introduce a code path where we call it before initialization.
  DCHECK(tracker_->IsInitialized());

  if (session_state_ != ScalableIphDelegate::SessionState::kActive) {
    SCALABLE_IPH_LOG(GetLogger()) << "Session state is not Active. No trigger "
                                     "condition check. Session state is "
                                  << session_state_;
    return;
  }

  SCALABLE_IPH_LOG(GetLogger()) << "Running trigger conditions check.";
  for (const base::Feature* feature : GetFeatureList()) {
    SCALABLE_IPH_LOG(GetLogger()) << "Checking: " << feature->name;

    if (!base::FeatureList::IsEnabled(*feature)) {
      SCALABLE_IPH_LOG(GetLogger())
          << feature->name << " is not enabled. Skipping condition check.";
      continue;
    }

    if (!ValidateVersionNumber(*feature)) {
      SCALABLE_IPH_LOG(GetLogger())
          << "Version number does not match with the current version "
             "number. Skipping a config: "
          << feature->name;
      continue;
    }

    if (!CheckCustomConditions(*feature, trigger_event)) {
      SCALABLE_IPH_LOG(GetLogger())
          << "Custom conditions are not satisfied for " << feature->name;
      continue;
    }
    SCALABLE_IPH_LOG(GetLogger())
        << "Custom conditions are satisfied for " << feature->name;

    if (!tracker_->ShouldTriggerHelpUI(*feature)) {
      SCALABLE_IPH_LOG(GetLogger())
          << "Trigger conditions in feature_engagement::Tracker are not "
             "satisfied for "
          << feature->name;
      continue;
    }
    SCALABLE_IPH_LOG(GetLogger())
        << "Trigger conditions in feature_engagement::Tracker are satisfied "
           "for "
        << feature->name;

    UiType ui_type = GetUiType(GetLogger(), *feature);
    switch (ui_type) {
      case UiType::kNotification: {
        std::unique_ptr<NotificationParams> notification_params =
            GetNotificationParams(GetLogger(), *feature);
        if (!notification_params) {
          SCALABLE_IPH_LOG(GetLogger())
              << "Failed to parse notification params for " << feature->name
              << ". Skipping the config.";
          continue;
        }
        SCALABLE_IPH_LOG(GetLogger()) << "Triggering a notification.";

        if (delegate_->ShowNotification(
                *notification_params.get(),
                std::make_unique<IphSession>(*feature, tracker_, this))) {
          SCALABLE_IPH_LOG(GetLogger())
              << "Requested the UI framework to show a notification. Request "
                 "status: success. -> Do not check other trigger conditions to "
                 "avoid triggering multiple IPHs at the same time.";
          return;
        }

        SCALABLE_IPH_LOG(GetLogger())
            << "Requested the UI framework to show a notification. Request "
               "status: failure. -> Keep checking other trigger conditions as "
               "this IPH should not be shown.";
        continue;
      }
      case UiType::kBubble: {
        std::unique_ptr<BubbleParams> bubble_params =
            GetBubbleParams(GetLogger(), *feature);
        if (!bubble_params) {
          SCALABLE_IPH_LOG(GetLogger())
              << "Failed to parse bubble params for " << feature->name
              << ". Skipping the config.";
          continue;
        }
        SCALABLE_IPH_LOG(GetLogger()) << "Triggering a bubble.";
        if (delegate_->ShowBubble(
                *bubble_params.get(),
                std::make_unique<IphSession>(*feature, tracker_, this))) {
          SCALABLE_IPH_LOG(GetLogger())
              << "Requested the UI framework to show a bubble. Request status: "
                 "success. -> Do not check other trigger conditions to avoid "
                 "triggering multiple IPHs at the same time.";
          return;
        }

        SCALABLE_IPH_LOG(GetLogger())
            << "Requested the UI framework to show a bubble. Request status: "
               "failure. -> Keep checking other trigger conditions as this IPH "
               "should not be shown.";
        continue;
      }
      case UiType::kNone:
        SCALABLE_IPH_LOG(GetLogger())
            << "Condition gets satisfied. But specified ui type is None.";
        break;
    }
  }
}

bool ScalableIph::CheckCustomConditions(
    const base::Feature& feature,
    const std::optional<ScalableIph::Event>& trigger_event) {
  SCALABLE_IPH_LOG(GetLogger())
      << "Checking custom conditions for " << feature.name;
  return CheckTriggerEvent(feature, trigger_event) &&
         CheckNetworkConnection(feature) && CheckClientAge(feature) &&
         CheckHasSavedPrinters(feature) &&
         CheckPhoneHubOnboardingEligible(feature);
}

bool ScalableIph::CheckTriggerEvent(
    const base::Feature& feature,
    const std::optional<ScalableIph::Event>& trigger_event) {
  SCALABLE_IPH_LOG(GetLogger())
      << "Checking trigger event condition for " << feature.name;

  std::string trigger_event_condition =
      GetParamValue(feature, kCustomConditionTriggerEventParamName);
  if (trigger_event_condition.empty()) {
    SCALABLE_IPH_LOG(GetLogger()) << "No trigger event condition specified.";
    return true;
  }

  if (!trigger_event.has_value()) {
    SCALABLE_IPH_LOG(GetLogger())
        << "This condition check is NOT triggered by an event. But trigger "
           "event condition is specified. Condition unsatisfied.";
    return false;
  }

  std::string trigger_event_name = GetEventName(trigger_event.value());

  const bool result = trigger_event_condition == trigger_event_name;
  SCALABLE_IPH_LOG(GetLogger())
      << "Specified trigger event name is " << trigger_event_condition
      << ". This condition check is triggered by " << trigger_event.value()
      << ". Compared trigger event name is " << trigger_event_name
      << ". Result: " << result;
  return result;
}

bool ScalableIph::CheckNetworkConnection(const base::Feature& feature) {
  SCALABLE_IPH_LOG(GetLogger())
      << "Checking network condition for " << feature.name;
  std::string connection_condition =
      GetParamValue(feature, kCustomConditionNetworkConnectionParamName);
  if (connection_condition.empty()) {
    SCALABLE_IPH_LOG(GetLogger()) << "No network condition specified.";
    return true;
  }

  // If an invalid value is provided, does not satisfy a condition for a
  // fail-safe behavior.
  if (connection_condition != kCustomConditionNetworkConnectionOnline) {
    SCALABLE_IPH_LOG(GetLogger())
        << "Only " << kCustomConditionNetworkConnectionOnline
        << " is the valid value for network connection condition";
    return false;
  }

  SCALABLE_IPH_LOG(GetLogger())
      << "Expecting online. Current status is: Online: " << online_;
  return online_;
}

bool ScalableIph::CheckClientAge(const base::Feature& feature) {
  SCALABLE_IPH_LOG(GetLogger()) << "Checking client age for " << feature.name;
  std::string client_age_condition =
      GetParamValue(feature, kCustomConditionClientAgeInDaysParamName);
  if (client_age_condition.empty()) {
    SCALABLE_IPH_LOG(GetLogger()) << "No client age condition specified.";
    return true;
  }

  // Use `SCALABLE_IPH_LOG`s for logging instead of `DCHECK(false)` as we want
  // to test those fail-safe behaviors in browser_tests.
  int max_client_age = 0;
  if (!base::StringToInt(client_age_condition, &max_client_age)) {
    SCALABLE_IPH_LOG(GetLogger())
        << "Failed to parse client age condition. It must be an integer.";
    return false;
  }

  if (max_client_age < 0) {
    SCALABLE_IPH_LOG(GetLogger())
        << "Client age condition must be a positive integer value.";
    return false;
  }

  int client_age = delegate_->ClientAgeInDays();
  if (client_age < 0) {
    SCALABLE_IPH_LOG(GetLogger())
        << "Client age is a negative number. This can happen if a "
           "user changes time zone, etc. Condition is not satisfied "
           "for a fail safe behavior.";
    return false;
  }

  const bool result = client_age <= max_client_age;
  SCALABLE_IPH_LOG(GetLogger())
      << "Current client age is " << client_age
      << ". Specified max client age is " << max_client_age
      << " (inclusive). Condition satisfied is: " << result;
  return result;
}

bool ScalableIph::CheckHasSavedPrinters(const base::Feature& feature) {
  SCALABLE_IPH_LOG(GetLogger())
      << "Checking has saved printers condition for " << feature.name;
  std::string has_saved_printers_condition =
      GetParamValue(feature, kCustomConditionHasSavedPrintersParamName);
  if (has_saved_printers_condition.empty()) {
    SCALABLE_IPH_LOG(GetLogger())
        << "No has saved printers condition specified.";
    return true;
  }

  if (has_saved_printers_condition !=
          kCustomConditionHasSavedPrintersValueTrue &&
      has_saved_printers_condition !=
          kCustomConditionHasSavedPrintersValueFalse) {
    SCALABLE_IPH_LOG(GetLogger())
        << "Invalid value provided for "
        << kCustomConditionHasSavedPrintersParamName
        << ". This condition is not satisfied for a fail-safe behavior.";
    return false;
  }

  const bool expected_value =
      has_saved_printers_condition == kCustomConditionHasSavedPrintersValueTrue;
  const bool result = has_saved_printers_ == expected_value;
  SCALABLE_IPH_LOG(GetLogger())
      << "Expected value is " << expected_value
      << ". Current has saved printers value is " << has_saved_printers_
      << ". Result is " << result;
  return result;
}

bool ScalableIph::CheckPhoneHubOnboardingEligible(
    const base::Feature& feature) {
  SCALABLE_IPH_LOG(GetLogger())
      << "Checking phone hub onboarding eligible for " << feature.name;

  std::string phonehub_onboarding_eligible_value = GetParamValue(
      feature, kCustomConditionPhoneHubOnboardingEligibleParamName);
  if (phonehub_onboarding_eligible_value.empty()) {
    SCALABLE_IPH_LOG(GetLogger())
        << "No phone hub onboarding eligible condition specified.";
    return true;
  }

  if (phonehub_onboarding_eligible_value !=
      kCustomConditionPhoneHubOnboardingEligibleValueTrue) {
    SCALABLE_IPH_LOG(GetLogger())
        << "Only " << kCustomConditionPhoneHubOnboardingEligibleValueTrue
        << " is a valid value for "
        << kCustomConditionPhoneHubOnboardingEligibleParamName
        << ". Provided value: " << phonehub_onboarding_eligible_value
        << ". Condition not satisfied for a fail-safe behavior.";
    return false;
  }

  SCALABLE_IPH_LOG(GetLogger())
      << "Expected value is "
      << kCustomConditionPhoneHubOnboardingEligibleValueTrue
      << ". Current phone hub onboarding eligible value is "
      << phonehub_onboarding_eligible_ << ". Result is "
      << phonehub_onboarding_eligible_;
  return phonehub_onboarding_eligible_;
}

const std::vector<raw_ptr<const base::Feature, VectorExperimental>>&
ScalableIph::GetFeatureList() const {
  if (!feature_list_for_testing_.empty()) {
    return feature_list_for_testing_;
  }

  return GetFeatureListConstant();
}

std::ostream& operator<<(std::ostream& out, ScalableIph::Event event) {
  return out << GetEventName(event);
}

}  // namespace scalable_iph