// Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// Processor for the UsageTimeLimit policy. Used to determine the current state
// of the client, for example if it is locked and the reason why it may be
// locked.

#ifndef CHROME_BROWSER_CHROMEOS_CHILD_ACCOUNTS_USAGE_TIME_LIMIT_PROCESSOR_H_
#define CHROME_BROWSER_CHROMEOS_CHILD_ACCOUNTS_USAGE_TIME_LIMIT_PROCESSOR_H_

#include "base/optional.h"
#include "base/time/time.h"
#include "base/values.h"
#include "chromeos/settings/timezone_settings.h"

namespace chromeos {
namespace usage_time_limit {
namespace internal {

enum class Weekday {
  kSunday = 0,
  kMonday,
  kTuesday,
  kWednesday,
  kThursday,
  kFriday,
  kSaturday,
  kCount,
};

struct TimeWindowLimitBoundaries {
  base::Time starts;
  base::Time ends;
};

struct TimeWindowLimitEntry {
  TimeWindowLimitEntry();

  // Whether the time window limit entry ends on the following day from its
  // start.
  bool IsOvernight() const;

  // Returns a pair containing the timestamps for the start and end of a time
  // window limit. The input parameter is the UTC midnight on of the start day.
  TimeWindowLimitBoundaries GetLimits(base::Time start_day_midnight);

  // Start time of time window limit. This is the distance from midnight.
  base::TimeDelta starts_at;
  // End time of time window limit. This is the distance from midnight.
  base::TimeDelta ends_at;
  // Last time this entry was updated.
  base::Time last_updated;
};

class TimeWindowLimit {
 public:
  TimeWindowLimit(const base::Value& window_limit_dict);
  ~TimeWindowLimit();
  TimeWindowLimit(TimeWindowLimit&&);
  TimeWindowLimit& operator=(TimeWindowLimit&&);

  std::unordered_map<Weekday, base::Optional<TimeWindowLimitEntry>> entries;

 private:
  DISALLOW_COPY_AND_ASSIGN(TimeWindowLimit);
};

struct TimeUsageLimitEntry {
  TimeUsageLimitEntry();

  base::TimeDelta usage_quota;
  base::Time last_updated;
};

class TimeUsageLimit {
 public:
  TimeUsageLimit(const base::Value& usage_limit_dict);
  ~TimeUsageLimit();
  TimeUsageLimit(TimeUsageLimit&&);
  TimeUsageLimit& operator=(TimeUsageLimit&&);

  std::unordered_map<Weekday, base::Optional<TimeUsageLimitEntry>> entries;
  base::TimeDelta resets_at;

 private:
  DISALLOW_COPY_AND_ASSIGN(TimeUsageLimit);
};

class Override {
 public:
  enum class Action { kLock, kUnlock };

  Override(const base::Value& override_dict);
  ~Override();
  Override(Override&&);
  Override& operator=(Override&&);

  Action action;
  base::Time created_at;
  base::Optional<base::TimeDelta> duration;

 private:
  DISALLOW_COPY_AND_ASSIGN(Override);
};

}  // namespace internal

enum class ActivePolicies {
  kNoActivePolicy,
  kOverride,
  kFixedLimit,
  kUsageLimit
};

struct State {
  // Whether the device is currently locked.
  bool is_locked = false;

  // Which policy is responsible for the current state.
  // If it is locked, one of [ override, fixed_limit, usage_limit ]
  // If it is not locked, one of [ no_active_policy, override ]
  ActivePolicies active_policy;

  // Whether time_usage_limit is currently active.
  bool is_time_usage_limit_enabled = false;

  // Remaining screen usage quota. Only available if
  // is_time_limit_enabled = true
  base::TimeDelta remaining_usage;

  // When the time usage limit started being enforced. Only available when
  // is_time_usage_limit_enabled = true and remaining_usage is 0, which means
  // that the time usage limit is enforced, and therefore should have a start
  // time.
  base::Time time_usage_limit_started;

  // Next epoch time that time limit state could change. This could be the
  // start time of the next fixed window limit, the end time of the current
  // fixed limit, the earliest time a usage limit could be reached, or the
  // next time when screen time will start.
  base::Time next_state_change_time;

  // The policy that will be active in the next state.
  ActivePolicies next_state_active_policy;

  // This is the next time that the user's session will be unlocked. This is
  // only set when is_locked=true;
  base::Time next_unlock_time;

  // Last time the state changed.
  base::Time last_state_changed;
};

// Returns the current state of the user session with the given usage time limit
// policy.
State GetState(const std::unique_ptr<base::DictionaryValue>& time_limit,
               const base::TimeDelta& used_time,
               const base::Time& usage_timestamp,
               const base::Time& current_time,
               const icu::TimeZone* const time_zone,
               const base::Optional<State>& previous_state);

// Ruturns the expected time that the used time stored should be reseted.
base::Time GetExpectedResetTime(
    const std::unique_ptr<base::DictionaryValue>& time_limit,
    base::Time current_time,
    const icu::TimeZone* const time_zone);

}  // namespace usage_time_limit
}  // namespace chromeos

#endif  // CHROME_BROWSER_CHROMEOS_CHILD_ACCOUNTS_USAGE_TIME_LIMIT_PROCESSOR_H_