// Copyright 2017 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/ui/webui/ash/settings/pages/power/device_power_handler.h"

#include <memory>
#include <utility>

#include "ash/constants/ash_features.h"
#include "ash/constants/ash_pref_names.h"
#include "ash/public/cpp/power_utils.h"
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/utf_string_conversions.h"
#include "base/time/time.h"
#include "base/values.h"
#include "chrome/grit/generated_resources.h"
#include "chromeos/ash/components/dbus/dbus_thread_manager.h"
#include "chromeos/dbus/power_manager/power_supply_properties.pb.h"
#include "components/prefs/pref_change_registrar.h"
#include "components/prefs/pref_service.h"
#include "content/public/browser/web_ui.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/base/l10n/time_format.h"
#include "ui/base/webui/web_ui_util.h"

namespace ash::settings {

namespace {

using ::chromeos::PowerManagerClient;
using ::chromeos::PowerPolicyController;

std::u16string GetBatteryTimeText(base::TimeDelta time_left) {
  int hour = 0;
  int min = 0;
  power_utils::SplitTimeIntoHoursAndMinutes(time_left, &hour, &min);

  std::u16string time_text;
  if (hour == 0 || min == 0) {
    // Display only one unit ("2 hours" or "10 minutes").
    return ui::TimeFormat::Simple(ui::TimeFormat::FORMAT_DURATION,
                                  ui::TimeFormat::LENGTH_LONG, time_left);
  }

  return ui::TimeFormat::Detailed(ui::TimeFormat::FORMAT_DURATION,
                                  ui::TimeFormat::LENGTH_LONG,
                                  -1,  // force hour and minute output
                                  time_left);
}

int PowerSourceToDisplayId(
    const power_manager::PowerSupplyProperties_PowerSource& source) {
  switch (source.port()) {
    case power_manager::PowerSupplyProperties_PowerSource_Port_UNKNOWN:
      return IDS_POWER_SOURCE_PORT_UNKNOWN;
    case power_manager::PowerSupplyProperties_PowerSource_Port_LEFT:
      return IDS_POWER_SOURCE_PORT_LEFT;
    case power_manager::PowerSupplyProperties_PowerSource_Port_RIGHT:
      return IDS_POWER_SOURCE_PORT_RIGHT;
    case power_manager::PowerSupplyProperties_PowerSource_Port_BACK:
      return IDS_POWER_SOURCE_PORT_BACK;
    case power_manager::PowerSupplyProperties_PowerSource_Port_FRONT:
      return IDS_POWER_SOURCE_PORT_FRONT;
    case power_manager::PowerSupplyProperties_PowerSource_Port_LEFT_FRONT:
      return IDS_POWER_SOURCE_PORT_LEFT_FRONT;
    case power_manager::PowerSupplyProperties_PowerSource_Port_LEFT_BACK:
      return IDS_POWER_SOURCE_PORT_LEFT_BACK;
    case power_manager::PowerSupplyProperties_PowerSource_Port_RIGHT_FRONT:
      return IDS_POWER_SOURCE_PORT_RIGHT_FRONT;
    case power_manager::PowerSupplyProperties_PowerSource_Port_RIGHT_BACK:
      return IDS_POWER_SOURCE_PORT_RIGHT_BACK;
    case power_manager::PowerSupplyProperties_PowerSource_Port_BACK_LEFT:
      return IDS_POWER_SOURCE_PORT_BACK_LEFT;
    case power_manager::PowerSupplyProperties_PowerSource_Port_BACK_RIGHT:
      return IDS_POWER_SOURCE_PORT_BACK_RIGHT;
  }
  NOTREACHED();
}

}  // namespace

PowerHandler::IdleBehaviorInfo::IdleBehaviorInfo() = default;
PowerHandler::IdleBehaviorInfo::~IdleBehaviorInfo() = default;

PowerHandler::IdleBehaviorInfo::IdleBehaviorInfo(
    const std::set<PowerHandler::IdleBehavior>& possible_behaviors,
    const PowerHandler::IdleBehavior& current_behavior,
    const bool is_managed)
    : possible_behaviors(possible_behaviors),
      current_behavior(current_behavior),
      is_managed(is_managed) {}

PowerHandler::IdleBehaviorInfo::IdleBehaviorInfo(const IdleBehaviorInfo& o) =
    default;

const char PowerHandler::kPowerManagementSettingsChangedName[] =
    "power-management-settings-changed";

const char PowerHandler::kPossibleAcIdleBehaviorsKey[] =
    "possibleAcIdleBehaviors";
const char PowerHandler::kPossibleBatteryIdleBehaviorsKey[] =
    "possibleBatteryIdleBehaviors";
const char PowerHandler::kCurrentAcIdleBehaviorKey[] = "currentAcIdleBehavior";
const char PowerHandler::kCurrentBatteryIdleBehaviorKey[] =
    "currentBatteryIdleBehavior";
const char PowerHandler::kLidClosedBehaviorKey[] = "lidClosedBehavior";
const char PowerHandler::kAcIdleManagedKey[] = "acIdleManaged";
const char PowerHandler::kBatteryIdleManagedKey[] = "batteryIdleManaged";

const char PowerHandler::kLidClosedControlledKey[] = "lidClosedControlled";
const char PowerHandler::kHasLidKey[] = "hasLid";
const char PowerHandler::kAdaptiveChargingKey[] = "adaptiveCharging";
const char PowerHandler::kAdaptiveChargingManagedKey[] =
    "adaptiveChargingManaged";
const char PowerHandler::kBatterySaverFeatureEnabledKey[] =
    "batterySaverFeatureEnabled";

PowerHandler::TestAPI::TestAPI(PowerHandler* handler) : handler_(handler) {}

PowerHandler::TestAPI::~TestAPI() = default;

void PowerHandler::TestAPI::RequestPowerManagementSettings() {
  handler_->HandleRequestPowerManagementSettings(base::Value::List());
}

void PowerHandler::TestAPI::SetIdleBehavior(IdleBehavior behavior,
                                            bool when_on_ac) {
  base::Value::List args;
  args.Append(static_cast<int>(behavior));
  args.Append(when_on_ac);
  handler_->HandleSetIdleBehavior(args);
}

void PowerHandler::TestAPI::SetLidClosedBehavior(
    PowerPolicyController::Action behavior) {
  base::Value::List args;
  args.Append(behavior);
  handler_->HandleSetLidClosedBehavior(args);
}

void PowerHandler::TestAPI::SetAdaptiveCharging(bool enabled) {
  base::Value::List args;
  args.Append(enabled);
  handler_->HandleSetAdaptiveCharging(args);
}

PowerHandler::PowerHandler(PrefService* prefs) : prefs_(prefs) {}

PowerHandler::~PowerHandler() = default;

void PowerHandler::RegisterMessages() {
  web_ui()->RegisterMessageCallback(
      "updatePowerStatus",
      base::BindRepeating(&PowerHandler::HandleUpdatePowerStatus,
                          base::Unretained(this)));
  web_ui()->RegisterMessageCallback(
      "setPowerSource", base::BindRepeating(&PowerHandler::HandleSetPowerSource,
                                            base::Unretained(this)));
  web_ui()->RegisterMessageCallback(
      "requestPowerManagementSettings",
      base::BindRepeating(&PowerHandler::HandleRequestPowerManagementSettings,
                          base::Unretained(this)));
  web_ui()->RegisterMessageCallback(
      "setLidClosedBehavior",
      base::BindRepeating(&PowerHandler::HandleSetLidClosedBehavior,
                          base::Unretained(this)));
  web_ui()->RegisterMessageCallback(
      "setIdleBehavior",
      base::BindRepeating(&PowerHandler::HandleSetIdleBehavior,
                          base::Unretained(this)));
  web_ui()->RegisterMessageCallback(
      "setAdaptiveCharging",
      base::BindRepeating(&PowerHandler::HandleSetAdaptiveCharging,
                          base::Unretained(this)));
}

void PowerHandler::OnJavascriptAllowed() {
  PowerManagerClient* power_manager_client = PowerManagerClient::Get();
  power_manager_client_observation_.Observe(power_manager_client);
  power_manager_client->GetSwitchStates(base::BindOnce(
      &PowerHandler::OnGotSwitchStates, weak_ptr_factory_.GetWeakPtr()));

  // Observe power management prefs used in the UI.
  base::RepeatingClosure callback(
      base::BindRepeating(&PowerHandler::SendPowerManagementSettings,
                          base::Unretained(this), false /* force */));
  pref_change_registrar_ = std::make_unique<PrefChangeRegistrar>();
  pref_change_registrar_->Init(prefs_);
  pref_change_registrar_->Add(ash::prefs::kPowerAcIdleAction, callback);
  pref_change_registrar_->Add(ash::prefs::kPowerAcScreenDimDelayMs, callback);
  pref_change_registrar_->Add(ash::prefs::kPowerAcScreenOffDelayMs, callback);
  pref_change_registrar_->Add(ash::prefs::kPowerAcScreenLockDelayMs, callback);
  pref_change_registrar_->Add(ash::prefs::kPowerBatteryIdleAction, callback);
  pref_change_registrar_->Add(ash::prefs::kPowerBatteryScreenDimDelayMs,
                              callback);
  pref_change_registrar_->Add(ash::prefs::kPowerBatteryScreenOffDelayMs,
                              callback);
  pref_change_registrar_->Add(ash::prefs::kPowerBatteryScreenLockDelayMs,
                              callback);
  pref_change_registrar_->Add(ash::prefs::kPowerLidClosedAction, callback);
  pref_change_registrar_->Add(ash::prefs::kPowerAdaptiveChargingEnabled,
                              callback);
}

void PowerHandler::OnJavascriptDisallowed() {
  power_manager_client_observation_.Reset();
  pref_change_registrar_.reset();
}

void PowerHandler::PowerChanged(
    const power_manager::PowerSupplyProperties& proto) {
  SendBatteryStatus();
  SendPowerSources();
}

void PowerHandler::PowerManagerRestarted() {
  PowerManagerClient::Get()->GetSwitchStates(base::BindOnce(
      &PowerHandler::OnGotSwitchStates, weak_ptr_factory_.GetWeakPtr()));
}

void PowerHandler::LidEventReceived(PowerManagerClient::LidState state,
                                    base::TimeTicks timestamp) {
  lid_state_ = state;
  SendPowerManagementSettings(false /* force */);
}

void PowerHandler::HandleUpdatePowerStatus(const base::Value::List& args) {
  AllowJavascript();
  chromeos::PowerManagerClient::Get()->RequestStatusUpdate();
}

void PowerHandler::HandleSetPowerSource(const base::Value::List& args) {
  AllowJavascript();

  const std::string& id = args[0].GetString();
  chromeos::PowerManagerClient::Get()->SetPowerSource(id);
}

void PowerHandler::HandleRequestPowerManagementSettings(
    const base::Value::List& args) {
  AllowJavascript();
  SendPowerManagementSettings(true /* force */);
}

void PowerHandler::HandleSetIdleBehavior(const base::Value::List& args) {
  AllowJavascript();

  const auto& list = args;
  CHECK_GE(list.size(), 2u);
  int value = list[0].GetInt();
  bool when_on_ac = list[1].GetBool();

  const char* idle_pref = when_on_ac ? ash::prefs::kPowerAcIdleAction
                                     : ash::prefs::kPowerBatteryIdleAction;
  const char* screen_dim_delay_pref =
      when_on_ac ? ash::prefs::kPowerAcScreenDimDelayMs
                 : ash::prefs::kPowerBatteryScreenDimDelayMs;
  const char* screen_off_delay_pref =
      when_on_ac ? ash::prefs::kPowerAcScreenOffDelayMs
                 : ash::prefs::kPowerBatteryScreenOffDelayMs;
  const char* screen_lock_delay_pref =
      when_on_ac ? ash::prefs::kPowerAcScreenLockDelayMs
                 : ash::prefs::kPowerBatteryScreenLockDelayMs;

  switch (static_cast<IdleBehavior>(value)) {
    case IdleBehavior::DISPLAY_OFF_SLEEP:
      // The default behavior is to turn the display off and sleep.
      // Clear the prefs so we use the default delays.
      prefs_->ClearPref(idle_pref);
      prefs_->ClearPref(screen_dim_delay_pref);
      prefs_->ClearPref(screen_off_delay_pref);
      prefs_->ClearPref(screen_lock_delay_pref);
      break;
    case IdleBehavior::DISPLAY_OFF:
      // Override idle actions to keep the system awake, but use the
      // default screen delays.
      prefs_->SetInteger(idle_pref, PowerPolicyController::ACTION_DO_NOTHING);
      prefs_->ClearPref(screen_dim_delay_pref);
      prefs_->ClearPref(screen_off_delay_pref);
      prefs_->ClearPref(screen_lock_delay_pref);
      break;
    case IdleBehavior::DISPLAY_ON:
      // Override idle actions and set screen delays to 0 in order to
      // disable them (i.e. keep the screen on).
      prefs_->SetInteger(idle_pref, PowerPolicyController::ACTION_DO_NOTHING);
      prefs_->SetInteger(screen_dim_delay_pref, 0);
      prefs_->SetInteger(screen_off_delay_pref, 0);
      prefs_->SetInteger(screen_lock_delay_pref, 0);
      break;
    default:
      NOTREACHED() << "Invalid idle behavior " << value;
  }
}

void PowerHandler::HandleSetLidClosedBehavior(const base::Value::List& args) {
  AllowJavascript();

  const auto& list = args;
  CHECK_GE(list.size(), 1u);
  int value = list[0].GetInt();
  switch (static_cast<PowerPolicyController::Action>(value)) {
    case PowerPolicyController::ACTION_SUSPEND:
      prefs_->ClearPref(ash::prefs::kPowerLidClosedAction);
      break;
    case PowerPolicyController::ACTION_DO_NOTHING:
      prefs_->SetInteger(ash::prefs::kPowerLidClosedAction,
                         PowerPolicyController::ACTION_DO_NOTHING);
      break;
    default:
      NOTREACHED() << "Unsupported lid-closed behavior " << value;
  }
}

void PowerHandler::HandleSetAdaptiveCharging(const base::Value::List& args) {
  AllowJavascript();

  CHECK_GE(args.size(), 1u);
  bool enabled = args[0].GetBool();

  prefs_->SetBoolean(ash::prefs::kPowerAdaptiveChargingEnabled, enabled);
}

void PowerHandler::SendBatteryStatus() {
  const std::optional<power_manager::PowerSupplyProperties>& proto =
      PowerManagerClient::Get()->GetLastStatus();
  DCHECK(proto);
  bool charging = proto->battery_state() ==
                  power_manager::PowerSupplyProperties_BatteryState_CHARGING;
  bool calculating = proto->is_calculating_battery_time();
  int percent = power_utils::GetRoundedBatteryPercent(proto->battery_percent());
  base::TimeDelta time_left;
  bool show_time = false;

  if (!calculating) {
    time_left = base::Seconds(charging ? proto->battery_time_to_full_sec()
                                       : proto->battery_time_to_empty_sec());
    show_time = power_utils::ShouldDisplayBatteryTime(time_left);
  }

  std::u16string status_text;
  if (show_time) {
    status_text = l10n_util::GetStringFUTF16(
        charging ? IDS_SETTINGS_BATTERY_STATUS_CHARGING
                 : IDS_SETTINGS_BATTERY_STATUS,
        base::NumberToString16(percent), GetBatteryTimeText(time_left));
  } else {
    status_text = l10n_util::GetStringFUTF16(IDS_SETTINGS_BATTERY_STATUS_SHORT,
                                             base::NumberToString16(percent));
  }

  auto battery_dict =
      base::Value::Dict()
          .Set(
              "present",
              proto->battery_state() !=
                  power_manager::PowerSupplyProperties_BatteryState_NOT_PRESENT)
          .Set("charging", charging)
          .Set("calculating", calculating)
          .Set("percent", percent)
          .Set("statusText", status_text);

  FireWebUIListener("battery-status-changed", battery_dict);
}

void PowerHandler::SendPowerSources() {
  const std::optional<power_manager::PowerSupplyProperties>& proto =
      PowerManagerClient::Get()->GetLastStatus();
  DCHECK(proto);
  base::Value::List sources_list;
  for (int i = 0; i < proto->available_external_power_source_size(); i++) {
    const auto& source = proto->available_external_power_source(i);
    sources_list.Append(
        base::Value::Dict()
            .Set("id", source.id())
            .Set("is_dedicated_charger", source.active_by_default())
            .Set("description",
                 l10n_util::GetStringUTF16(PowerSourceToDisplayId(source))));
  }

  FireWebUIListener(
      "power-sources-changed", sources_list,
      base::Value(proto->external_power_source_id()),
      base::Value(proto->external_power() ==
                  power_manager::PowerSupplyProperties_ExternalPower_USB),
      base::Value(proto->external_power() ==
                  power_manager::PowerSupplyProperties_ExternalPower_AC));
}

void PowerHandler::SendPowerManagementSettings(bool force) {
  const PowerHandler::IdleBehaviorInfo ac_idle_info =
      GetAllowedIdleBehaviors(PowerSource::kAc);
  const PowerHandler::IdleBehaviorInfo battery_idle_info =
      GetAllowedIdleBehaviors(PowerSource::kBattery);

  const PowerPolicyController::Action lid_closed_behavior =
      static_cast<PowerPolicyController::Action>(
          prefs_->GetInteger(ash::prefs::kPowerLidClosedAction));
  const bool lid_closed_controlled =
      prefs_->IsManagedPreference(ash::prefs::kPowerLidClosedAction);
  const bool has_lid = lid_state_ != PowerManagerClient::LidState::NOT_PRESENT;

  const bool adaptive_charging =
      prefs_->GetBoolean(ash::prefs::kPowerAdaptiveChargingEnabled);
  const bool adaptive_charging_managed =
      prefs_->IsManagedPreference(ash::prefs::kPowerAdaptiveChargingEnabled);
  const bool battery_saver_feature_enabled =
      ash::features::IsBatterySaverAvailable();
  // Don't notify the UI if nothing changed.
  if (!force && ac_idle_info == last_ac_idle_info_ &&
      battery_idle_info == last_battery_idle_info_ &&
      lid_closed_behavior == last_lid_closed_behavior_ &&
      lid_closed_controlled == last_lid_closed_controlled_ &&
      has_lid == last_has_lid_ &&
      adaptive_charging == last_adaptive_charging_ &&
      adaptive_charging_managed == last_adaptive_charging_managed_ &&
      battery_saver_feature_enabled == last_battery_saver_feature_enabled_) {
    return;
  }

  auto dict =
      base::Value::Dict()
          .Set(kCurrentAcIdleBehaviorKey,
               static_cast<int>(ac_idle_info.current_behavior))
          .Set(kCurrentBatteryIdleBehaviorKey,
               static_cast<int>(battery_idle_info.current_behavior))
          .Set(kLidClosedBehaviorKey, lid_closed_behavior)
          .Set(kAcIdleManagedKey, ac_idle_info.is_managed)
          .Set(kBatteryIdleManagedKey, battery_idle_info.is_managed)
          .Set(kLidClosedControlledKey, lid_closed_controlled)
          .Set(kHasLidKey, has_lid)
          .Set(kAdaptiveChargingKey, adaptive_charging)
          .Set(kAdaptiveChargingManagedKey, adaptive_charging_managed)
          .Set(kBatterySaverFeatureEnabledKey, battery_saver_feature_enabled);

  base::Value::List* list = dict.EnsureList(kPossibleAcIdleBehaviorsKey);
  for (auto idle_behavior : ac_idle_info.possible_behaviors) {
    list->Append(static_cast<int>(idle_behavior));
  }

  list = dict.EnsureList(kPossibleBatteryIdleBehaviorsKey);
  for (auto idle_behavior : battery_idle_info.possible_behaviors) {
    list->Append(static_cast<int>(idle_behavior));
  }

  FireWebUIListener(kPowerManagementSettingsChangedName, dict);

  last_ac_idle_info_ = ac_idle_info;
  last_battery_idle_info_ = battery_idle_info;
  last_lid_closed_behavior_ = lid_closed_behavior;
  last_lid_closed_controlled_ = lid_closed_controlled;
  last_has_lid_ = has_lid;
  last_adaptive_charging_ = adaptive_charging;
  last_adaptive_charging_managed_ = adaptive_charging_managed;
  last_battery_saver_feature_enabled_ = battery_saver_feature_enabled;
}

void PowerHandler::OnGotSwitchStates(
    std::optional<PowerManagerClient::SwitchStates> result) {
  if (!result.has_value()) {
    return;
  }
  lid_state_ = result->lid_state;
  SendPowerManagementSettings(false /* force */);
}

PowerHandler::IdleBehaviorInfo PowerHandler::GetAllowedIdleBehaviors(
    PowerSource power_source) {
  const char* idle_pref = power_source == PowerSource::kAc
                              ? ash::prefs::kPowerAcIdleAction
                              : ash::prefs::kPowerBatteryIdleAction;
  const char* screen_off_delay_pref =
      power_source == PowerSource::kAc
          ? ash::prefs::kPowerAcScreenOffDelayMs
          : ash::prefs::kPowerBatteryScreenOffDelayMs;

  std::set<IdleBehavior> possible_behaviors;
  IdleBehavior current_idle_behavior;

  // If idle action is managed and set to suspend, only possible idle
  // behaviour is sleep with display off.
  if (prefs_->IsManagedPreference(idle_pref) &&
      prefs_->GetInteger(idle_pref) == PowerPolicyController::ACTION_SUSPEND) {
    current_idle_behavior = IdleBehavior::DISPLAY_OFF_SLEEP;
    possible_behaviors.insert(IdleBehavior::DISPLAY_OFF_SLEEP);
    return IdleBehaviorInfo(possible_behaviors, current_idle_behavior,
                            IsIdleManaged(power_source));
  }

  // If idle action is managed and set to STOP_SESSION, STOP_SESSION is the only
  // possibility.
  if (prefs_->IsManagedPreference(idle_pref) &&
      (prefs_->GetInteger(idle_pref) ==
       PowerPolicyController::ACTION_STOP_SESSION)) {
    current_idle_behavior = IdleBehavior::STOP_SESSION;
    possible_behaviors.insert(IdleBehavior::STOP_SESSION);
    return IdleBehaviorInfo(possible_behaviors, current_idle_behavior,
                            IsIdleManaged(power_source));
  }

  // If idle action is managed and set to SHUT_DOWN, SHUT_DOWN is the only
  // possibility.
  if (prefs_->IsManagedPreference(idle_pref) &&
      (prefs_->GetInteger(idle_pref) ==
       PowerPolicyController::ACTION_SHUT_DOWN)) {
    current_idle_behavior = IdleBehavior::SHUT_DOWN;
    possible_behaviors.insert(IdleBehavior::SHUT_DOWN);
    return IdleBehaviorInfo(possible_behaviors, current_idle_behavior,
                            IsIdleManaged(power_source));
  }

  // Note that after this point |idle_pref| should either be:
  //    1. Not managed.
  //    2. Or managed and set to
  //    PowerPolicyController::ACTION_DO_NOTHING.
  DCHECK(!prefs_->IsManagedPreference(idle_pref) ||
         (prefs_->GetInteger(idle_pref) ==
          PowerPolicyController::ACTION_DO_NOTHING));

  // If screen off delay is managed and set to a value greater than 0
  // and
  //   1. If idle action is managed and set to DO_NOTHING, only
  //      possible idle behavior is DISPLAY_OFF.
  //   2. If idle action is not managed then possible idle options
  //      are DiSPLAY_OFF and DISPLAY_OFF_SLEEP
  if (prefs_->IsManagedPreference(screen_off_delay_pref) &&
      prefs_->GetInteger(screen_off_delay_pref) > 0) {
    if (prefs_->IsManagedPreference(idle_pref) &&
        prefs_->GetInteger(idle_pref) ==
            PowerPolicyController::ACTION_DO_NOTHING) {
      current_idle_behavior = IdleBehavior::DISPLAY_OFF;
      possible_behaviors.insert(IdleBehavior::DISPLAY_OFF);
      return IdleBehaviorInfo(possible_behaviors, current_idle_behavior,
                              IsIdleManaged(power_source));
    }

    possible_behaviors.insert(IdleBehavior::DISPLAY_OFF);
    possible_behaviors.insert(IdleBehavior::DISPLAY_OFF_SLEEP);
    // Set the current default option based on the current idle action.
    const PowerPolicyController::Action idle_action =
        static_cast<PowerPolicyController::Action>(
            prefs_->GetInteger(idle_pref));

    if (idle_action == PowerPolicyController::ACTION_SUSPEND) {
      current_idle_behavior = IdleBehavior::DISPLAY_OFF_SLEEP;
    } else {
      current_idle_behavior = IdleBehavior::DISPLAY_OFF;
    }
    return IdleBehaviorInfo(possible_behaviors, current_idle_behavior,
                            IsIdleManaged(power_source));
  }

  // If idle action is managed and set to DO_NOTHING, and
  //   1. If screen off delay is also managed (and set to 0), only
  //   possible idle
  //      action is DISPLAY_ON.
  //   2. If AC screen off delay is not managed, possible idle actions
  //      are DISPLAY_ON && DISPLAY_OFF.
  if (prefs_->IsManagedPreference(idle_pref) &&
      prefs_->GetInteger(idle_pref) ==
          PowerPolicyController::ACTION_DO_NOTHING) {
    if (prefs_->IsManagedPreference(screen_off_delay_pref)) {
      // Note that we reach here only when screen off delays are
      // set by enterprise policy to 0 to prevent display from turning
      // off.
      DCHECK(prefs_->GetInteger(screen_off_delay_pref) == 0);
      current_idle_behavior = IdleBehavior::DISPLAY_ON;
      possible_behaviors.insert(IdleBehavior::DISPLAY_ON);
      return IdleBehaviorInfo(possible_behaviors, current_idle_behavior,
                              IsIdleManaged(power_source));
    }
    possible_behaviors.insert(IdleBehavior::DISPLAY_ON);
    possible_behaviors.insert(IdleBehavior::DISPLAY_OFF);
    // Set the current default option based on the current screen off
    // delay.
    current_idle_behavior = prefs_->GetInteger(screen_off_delay_pref) > 0
                                ? IdleBehavior::DISPLAY_OFF
                                : IdleBehavior::DISPLAY_ON;
    return IdleBehaviorInfo(possible_behaviors, current_idle_behavior,
                            IsIdleManaged(power_source));
  }

  // Looks like we did not find enterprise policy restricitng the idle
  // options. So add all three idle options to what user can select
  // from.
  possible_behaviors.insert(IdleBehavior::DISPLAY_ON);
  possible_behaviors.insert(IdleBehavior::DISPLAY_OFF);
  possible_behaviors.insert(IdleBehavior::DISPLAY_OFF_SLEEP);

  // Infer the idle behavior based on the current idle action
  // (determining whether we'll sleep eventually or not) and the AC
  // screen-off delay.
  const PowerPolicyController::Action idle_action =
      static_cast<PowerPolicyController::Action>(prefs_->GetInteger(idle_pref));

  if (idle_action == PowerPolicyController::ACTION_SUSPEND) {
    current_idle_behavior = IdleBehavior::DISPLAY_OFF_SLEEP;
  } else if (idle_action == PowerPolicyController::ACTION_DO_NOTHING) {
    current_idle_behavior = (prefs_->GetInteger(screen_off_delay_pref) > 0
                                 ? IdleBehavior::DISPLAY_OFF
                                 : IdleBehavior::DISPLAY_ON);
  } else {
    NOTREACHED() << "Idle behavior is set to a enterprise-only value, but "
                 << "the setting is not enterprise managed. Defaulting to "
                 << "DISPLAY_OFF_SLEEP behavior.";
  }

  return IdleBehaviorInfo(possible_behaviors, current_idle_behavior,
                          IsIdleManaged(power_source));
}

bool PowerHandler::IsIdleManaged(PowerSource power_source) {
  switch (power_source) {
    case PowerSource::kAc:
      return prefs_->IsManagedPreference(ash::prefs::kPowerAcIdleAction) ||
             prefs_->IsManagedPreference(
                 ash::prefs::kPowerAcScreenDimDelayMs) ||
             prefs_->IsManagedPreference(
                 ash::prefs::kPowerAcScreenOffDelayMs) ||
             prefs_->IsManagedPreference(ash::prefs::kPowerAcScreenLockDelayMs);
    case PowerSource::kBattery:
      return prefs_->IsManagedPreference(ash::prefs::kPowerBatteryIdleAction) ||
             prefs_->IsManagedPreference(
                 ash::prefs::kPowerBatteryScreenDimDelayMs) ||
             prefs_->IsManagedPreference(
                 ash::prefs::kPowerBatteryScreenOffDelayMs) ||
             prefs_->IsManagedPreference(
                 ash::prefs::kPowerBatteryScreenLockDelayMs);
  }
}

}  // namespace ash::settings