// Copyright 2020 Google LLC. All Rights Reserved. This file and proprietary
// source code may only be used and distributed under the Widevine License
// Agreement.

#ifndef WVCDM_CORE_POLICY_TIMERS_H_
#define WVCDM_CORE_POLICY_TIMERS_H_

#include <memory>
#include <string>

#include "license_protocol.pb.h"
#include "wv_cdm_constants.h"
#include "wv_cdm_types.h"
#include "wv_class_utils.h"

namespace wvcdm {
// This is driven by the Policy Engine and maintains timer related
// information from the policy such as duration windows and renewals.
// Timer expiration behavior has changed with the introduction of core
// messages in OEMCrypto v16. Handling of behavior that differs between
// a OEMCrypto v16 license with core messages and one without is left to
// a class that derives from this interface.
class PolicyTimers {
 public:
  WVCDM_DISALLOW_COPY_AND_MOVE(PolicyTimers);

  virtual ~PolicyTimers() {}

  // SetLicense is used in handling the initial license response.
  virtual void SetLicense(const video_widevine::License& license);

  // UpdateLicense is used in handling a license response, a renewal response,
  // or when restoring or releasing a persistent license.
  // In a renewal the response may only contain policy fields that have
  // changed. In this case an exact copy is not what we want to happen.
  virtual bool UpdateLicense(int64_t current_time,
                             const video_widevine::License& license) = 0;

  // Call this on first decrypt to set the start of playback.
  virtual void BeginDecryption(int64_t current_time) = 0;
  // Call this periodically to update the most recent playback time.
  virtual void DecryptionEvent(int64_t current_time);

  // For offline save and restore
  virtual int64_t GetPlaybackStartTime() { return playback_start_time_; }
  virtual int64_t GetLastPlaybackTime() { return last_playback_time_; }
  // This is a legacy field for offline licenses. Since no grace period is
  // supported return a default value.
  virtual int64_t GetGracePeriodEndTime() { return 0; }
  virtual void RestorePlaybackTimes(int64_t current_time,
                                    int64_t playback_start_time,
                                    int64_t last_playback_time,
                                    int64_t grace_period_end_time);

  virtual bool HasPlaybackStarted(int64_t /* current_time */) {
    return playback_start_time_ != 0;
  }

  // For licenses that support core messages, evaluation of only rental and
  // playback durations are needed.
  virtual bool HasLicenseOrRentalOrPlaybackDurationExpired(
      int64_t current_time) {
    return HasRentalOrPlaybackDurationExpired(current_time);
  }
  virtual bool HasPassedGracePeriod(int64_t /* current_time */) { return true; }

  // This returns
  // * before playback begins: the time remaining on |rental_duration_seconds|
  // * after playback begins:
  //   - |soft_enforce_playback_duration| is true: the time remaining on
  //     |playback_duration_seconds|
  //   - |soft_enforce_playback_duration| is false: the minimum
  //     of the time remaining on |rental_duration_seconds| or
  //     |playback_duration_seconds|
  //
  // |license_duration_seconds| is ignored with the introduction of core
  // messages
  virtual int64_t GetLicenseOrRentalOrPlaybackDurationRemaining(
      int64_t current_time);
  // This is only used in Query. This should return the time remaining on
  // |rental_duration_seconds|.
  virtual int64_t GetLicenseOrRentalDurationRemaining(int64_t current_time) {
    return GetRentalDurationRemaining(current_time);
  };

  // This is only used in Query. This should return |playback_duration_seconds|
  // before playback begins or the time remaining on
  // |playback_duration_seconds| after playback begins.
  virtual int64_t GetPlaybackDurationRemaining(int64_t current_time);

  virtual bool GetSecondsSinceStarted(int64_t current_time,
                                      int64_t* seconds_since_started);
  virtual bool GetSecondsSinceLastPlayed(int64_t current_time,
                                         int64_t* seconds_since_started);

  virtual bool IsLicenseForFuture(int64_t current_time);

  virtual bool UpdateExpirationTime(int64_t current_time, int64_t* expiry_time);

  // Renewal related methods
  virtual bool HasRenewalDelayExpired(int64_t current_time) = 0;
  virtual bool HasRenewalRetryIntervalExpired(int64_t current_time);
  virtual void UpdateRenewalRequest(int64_t current_time);
  virtual bool HasRenewalRecoveryDurationExpired(int64_t current_time);

  const video_widevine::License::Policy& get_policy() { return policy_; }

 protected:
  PolicyTimers()
      : license_start_time_(0),
        playback_start_time_(0),
        last_playback_time_(0),
        last_expiry_time_(0),
        last_expiry_time_set_(false),
        next_renewal_time_(0),
        was_expired_on_load_(false) {}

  // Gets the clock time that the license expires based on whether we have
  // started playing. This takes into account GetHardLicenseExpiryTime.
  virtual int64_t GetExpiryTime(int64_t current_time,
                                bool ignore_soft_enforce_playback_duration);
  virtual int64_t GetRentalExpiryTime(int64_t current_time);
  virtual int64_t GetRenewalStartTime() { return renewal_start_time_; }

  // This is the current policy information for this license. This gets updated
  // as license renewals occur.
  video_widevine::License::Policy policy_;

  int64_t license_start_time_;
  int64_t playback_start_time_;
  int64_t last_playback_time_;
  int64_t last_expiry_time_;
  int64_t last_expiry_time_set_;
  int64_t renewal_start_time_ = 0;
  int64_t next_renewal_time_;

  // Indicates whether a persistent license was expired when loaded
  bool was_expired_on_load_;

 private:
  // Gets the clock time that the rental duration or playback will expire.
  virtual int64_t GetPlaybackExpiryTime(
      int64_t current_time, bool ignore_soft_enforce_playback_duration);
  bool HasRentalOrPlaybackDurationExpired(int64_t current_time);
  virtual int64_t GetRentalDurationRemaining(int64_t current_time);
};  // class PolicyTimers
}  // namespace wvcdm
#endif  // WVCDM_CORE_POLICY_TIMERS_H_