// Copyright 2020 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/ash/child_accounts/time_limits/persisted_app_info.h"

#include "base/logging.h"
#include "base/strings/string_number_conversions.h"
#include "chrome/browser/ash/child_accounts/time_limits/app_time_policy_helpers.h"

namespace ash {
namespace app_time {

namespace {

// The following keys are stored in user pref. Modification will result in
// errors when parsing old data.
constexpr char kAppInfoKey[] = "app_info";
constexpr char kAppStateKey[] = "app_state";
constexpr char kRunningActiveTimeKey[] = "running_active_time";
constexpr char kActiveTimesKey[] = "active_times";
constexpr char kActiveFromKey[] = "active_from";
constexpr char kActiveToKey[] = "active_to";

std::optional<AppActivity::ActiveTime> AppActivityFromDict(
    const base::Value::Dict& dict) {
  const std::string* active_from = dict.FindString(kActiveFromKey);
  if (!active_from) {
    VLOG(1) << "Invalid |active_from| entry in dictionary";
    return std::nullopt;
  }

  const std::string* active_to = dict.FindString(kActiveToKey);
  if (!active_to) {
    VLOG(1) << "Invalid |active_to| entry in dictionary.";
    return std::nullopt;
  }

  int64_t active_from_microseconds;
  int64_t active_to_microseconds;
  if (!base::StringToInt64(*active_from, &active_from_microseconds) ||
      !base::StringToInt64(*active_to, &active_to_microseconds)) {
    return std::nullopt;
  }

  base::Time active_from_time = base::Time::FromDeltaSinceWindowsEpoch(
      base::Microseconds(active_from_microseconds));
  base::Time active_to_time = base::Time::FromDeltaSinceWindowsEpoch(
      base::Microseconds(active_to_microseconds));

  return AppActivity::ActiveTime(active_from_time, active_to_time);
}

base::Value::Dict AppActivityToDict(
    const AppActivity::ActiveTime& active_time) {
  base::Value::Dict dict;

  auto serializeTime = [](base::Time time) -> std::string {
    return base::NumberToString(
        time.ToDeltaSinceWindowsEpoch().InMicroseconds());
  };

  dict.Set(kActiveFromKey, serializeTime(active_time.active_from()));
  dict.Set(kActiveToKey, serializeTime(active_time.active_to()));

  return dict;
}

std::vector<AppActivity::ActiveTime> AppActiveTimesFromList(
    const base::Value::List* list) {
  std::vector<AppActivity::ActiveTime> active_times;

  if (!list) {
    VLOG(1) << " Invalid app activity list";
    return active_times;
  }

  for (const auto& value : *list) {
    auto* dict = value.GetIfDict();
    if (!dict) {
      VLOG(1) << "Value is not a dictionary";
      continue;
    }
    std::optional<AppActivity::ActiveTime> entry = AppActivityFromDict(*dict);
    if (!entry)
      continue;
    active_times.push_back(entry.value());
  }

  return active_times;
}

}  // namespace

// static
std::optional<PersistedAppInfo> PersistedAppInfo::PersistedAppInfoFromDict(
    const base::Value::Dict* dict,
    bool include_app_activity_array) {
  if (!dict) {
    VLOG(1) << "Invalid application information.";
    return std::nullopt;
  }

  std::optional<AppId> app_id = policy::AppIdFromAppInfoDict(dict);
  if (!app_id)
    return std::nullopt;

  std::optional<AppState> state = GetAppStateFromDict(dict);
  if (!state) {
    VLOG(1) << "Invalid application state.";
    return std::nullopt;
  }

  const std::string* running_active_time =
      dict->FindString(kRunningActiveTimeKey);
  if (!running_active_time) {
    VLOG(1) << "Invalid running active time.";
    return std::nullopt;
  }

  int64_t running_active_time_int;
  if (!base::StringToInt64(*running_active_time, &running_active_time_int)) {
    VLOG(1) << "Invalid running active time.";
    return std::nullopt;
  }

  std::vector<AppActivity::ActiveTime> active_times;
  if (include_app_activity_array) {
    const base::Value::List* list = dict->FindList(kActiveTimesKey);
    active_times = AppActiveTimesFromList(list);
  }

  return PersistedAppInfo(app_id.value(), state.value(),
                          base::Microseconds(running_active_time_int),
                          std::move(active_times));
}

// static
std::vector<PersistedAppInfo> PersistedAppInfo::PersistedAppInfosFromList(
    const base::Value::List& list,
    bool include_app_activity_array) {
  std::vector<PersistedAppInfo> apps_info;

  for (const auto& per_app_info : list) {
    std::optional<PersistedAppInfo> info = PersistedAppInfoFromDict(
        per_app_info.GetIfDict(), include_app_activity_array);
    if (!info.has_value())
      continue;

    apps_info.push_back(std::move(info.value()));
  }

  return apps_info;
}

// static
std::optional<AppState> PersistedAppInfo::GetAppStateFromDict(
    const base::Value::Dict* value) {
  if (!value) {
    return std::nullopt;
  }

  std::optional<int> state = value->FindInt(kAppStateKey);
  if (!state.has_value())
    return std::nullopt;

  return static_cast<AppState>(state.value());
}

PersistedAppInfo::PersistedAppInfo(
    const AppId& app_id,
    AppState state,
    base::TimeDelta active_running_time,
    std::vector<AppActivity::ActiveTime> active_times)
    : app_id_(app_id),
      app_state_(state),
      active_running_time_(active_running_time),
      active_times_(active_times) {}

PersistedAppInfo::PersistedAppInfo(const PersistedAppInfo& info)
    : app_id_(info.app_id_),
      app_state_(info.app_state_),
      active_running_time_(info.active_running_time_),
      active_times_(info.active_times_) {}

PersistedAppInfo::PersistedAppInfo(PersistedAppInfo&& info)
    : app_id_(info.app_id_),
      app_state_(info.app_state_),
      active_running_time_(info.active_running_time_),
      active_times_(std::move(info.active_times_)) {}

PersistedAppInfo& PersistedAppInfo::operator=(const PersistedAppInfo& info) {
  app_id_ = info.app_id_;
  app_state_ = info.app_state_;
  active_running_time_ = info.active_running_time_;
  active_times_ = info.active_times_;
  return *this;
}

PersistedAppInfo& PersistedAppInfo::operator=(PersistedAppInfo&& info) {
  app_id_ = info.app_id_;
  app_state_ = info.app_state_;
  active_running_time_ = info.active_running_time_;
  active_times_ = std::move(info.active_times_);
  return *this;
}

PersistedAppInfo::~PersistedAppInfo() = default;

void PersistedAppInfo::UpdateAppActivityPreference(
    base::Value::Dict& dict,
    bool replace_activity) const {
  dict.Set(kAppInfoKey, policy::AppIdToDict(app_id_));
  dict.Set(kAppStateKey, static_cast<int>(app_state()));
  dict.Set(kRunningActiveTimeKey,
           base::NumberToString(active_running_time().InMicroseconds()));

  if (replace_activity) {
    base::Value::List active_times_list;
    for (const auto& entry : active_times_) {
      active_times_list.Append(AppActivityToDict(entry));
    }

    dict.SetByDottedPath(kActiveTimesKey, std::move(active_times_list));
    return;
  }

  base::Value::List* list = dict.FindList(kActiveTimesKey);
  if (!list) {
    list =
        &dict.SetByDottedPath(kActiveTimesKey, base::Value::List())->GetList();
  }

  if (active_times_.size() == 0)
    return;

  // start index into |active_times_|
  size_t start_index = 0;

  // If the last entry in |list| can be merged with the first entry in
  // |active_times_| merge them.
  base::Value::List& list_view = *list;
  if (list_view.size() > 0) {
    base::Value& mergeable_entry = list_view[list_view.size() - 1];
    CHECK(mergeable_entry.is_dict());
    std::optional<AppActivity::ActiveTime> active_time =
        AppActivityFromDict(mergeable_entry.GetDict());
    CHECK(active_time.has_value());

    std::optional<AppActivity::ActiveTime> merged =
        AppActivity::ActiveTime::Merge(active_time.value(), active_times_[0]);
    if (merged.has_value()) {
      mergeable_entry = base::Value(AppActivityToDict(merged.value()));
      start_index = 1;
    }
  }

  for (size_t i = start_index; i < active_times_.size(); i++) {
    list->Append(AppActivityToDict(active_times_[i]));
  }
}

void PersistedAppInfo::RemoveActiveTimeEarlierThan(base::Time timestamp) {
  std::vector<AppActivity::ActiveTime> active_times = std::move(active_times_);

  // |active_times_| is empty now. Populate it with active times later than
  // |timestamp|.
  for (auto& entry : active_times) {
    if (entry.IsLaterThan(timestamp)) {
      active_times_.push_back(entry);
    } else if (entry.Contains(timestamp)) {
      entry.set_active_from(timestamp);
      active_times_.push_back(entry);
    }
  }
}

bool PersistedAppInfo::ShouldRestoreApp() const {
  bool is_installed = app_state() != AppState::kUninstalled;
  bool has_active_running_time = active_running_time() > base::Seconds(0);
  return is_installed || has_active_running_time;
}

bool PersistedAppInfo::ShouldRemoveApp() const {
  return !ShouldRestoreApp() && active_times().empty();
}

}  // namespace app_time
}  // namespace ash