// Copyright 2018 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_PROPERTIES_H_
#define WVCDM_CORE_PROPERTIES_H_

#include <map>
#include <memory>
#include <mutex>
#include <string>

#include "cdm_client_property_set.h"
#include "wv_cdm_types.h"
#include "wv_class_utils.h"

#if defined(UNIT_TEST)
#include <gtest/gtest_prod.h>
#endif

namespace wvcdm {

using CdmClientPropertySetMap = std::map<CdmSessionId, CdmClientPropertySet*>;

// This class saves information about features and properties enabled
// for a given platform. At initialization it initializes properties from
// property_configuration.h. That file specifies features selected for each
// platform. Core CDM can then query enabled features though specific getter
// methods.
// Setter methods are provided but their only planned use is for testing.
class Properties {
 public:
  Properties() = delete;
  WVCDM_DISALLOW_COPY_AND_MOVE(Properties);

  static void Init() {
    std::unique_lock<std::mutex> lock(init_mutex_);

    if (!is_initialized_) {
      InitOnce();
      is_initialized_ = true;
    }
  }

  static inline bool oem_crypto_use_secure_buffers() {
    return oem_crypto_use_secure_buffers_;
  }
  static inline bool oem_crypto_use_fifo() { return oem_crypto_use_fifo_; }
  static inline bool oem_crypto_use_userspace_buffers() {
    return oem_crypto_use_userspace_buffers_;
  }
  static inline bool provisioning_messages_are_binary() {
    return provisioning_messages_are_binary_;
  }
  static inline bool allow_service_certificate_requests() {
    return allow_service_certificate_requests_;
  }
  static inline bool device_files_is_a_real_filesystem() {
    return device_files_is_a_real_filesystem_;
  }
  static inline bool allow_restore_of_offline_licenses_with_release() {
    return allow_restore_of_offline_licenses_with_release_;
  }
  static void set_provisioning_messages_are_binary(bool flag) {
    provisioning_messages_are_binary_ = flag;
  }
  static inline bool delay_oem_crypto_termination() {
    return delay_oem_crypto_termination_;
  }
  static bool GetCompanyName(std::string* company_name);
  static bool GetModelName(std::string* model_name);
  static bool GetModelYear(std::string* model_year);
  static bool GetArchitectureName(std::string* arch_name);
  static bool GetDeviceName(std::string* device_name);
  static bool GetProductName(std::string* product_name);
  static bool GetBuildInfo(std::string* build_info);
  static bool GetWVCdmVersion(std::string* version);
  static bool GetPlatform(std::string* platform);
  static bool GetFormFactor(std::string* form_factor);
  // Gets the base path for the device non-secure storage. Note that, depending
  // on the value of device_files_is_a_real_filesystem, this may or may not be
  // a real filesystem path.
  static bool GetDeviceFilesBasePath(CdmSecurityLevel security_level,
                                     std::string* base_path);
  static bool GetFactoryKeyboxPath(std::string* keybox);
  static bool GetOEMCryptoPaths(std::vector<std::string>* library_name);
  static bool GetSandboxId(std::string* sandbox_id);
  static bool AlwaysUseKeySetIds();
  static bool UseProviderIdInProvisioningRequest();
  // Cdm only loads L3 library when this returns true
  static bool ForceL3();

  static bool GetSecurityLevelDirectories(std::vector<std::string>* dirs);
  static bool GetApplicationId(const CdmSessionId& session_id,
                               std::string* app_id);
  static bool GetServiceCertificate(const CdmSessionId& session_id,
                                    std::string* service_certificate);
  static bool SetServiceCertificate(const CdmSessionId& session_id,
                                    const std::string& service_certificate);
  static bool UsePrivacyMode(const CdmSessionId& session_id);
  static uint32_t GetSessionSharingId(const CdmSessionId& session_id);

  static bool AddSessionPropertySet(const CdmSessionId& session_id,
                                    CdmClientPropertySet* property_set);
  static bool RemoveSessionPropertySet(const CdmSessionId& session_id);

 protected:
  // This function always runs the code in |Init()| (and subsequently
  // |InitOnce()|) even if Properties have already been initialized. This is
  // needed by certain tests that are dependent on controlling the mutable state
  // of Properties. Should not be used in general, as most tests rely on
  // Properties' normal guarantee about |Init()| being safe to call multiple
  // times without destroying mutable state.
  static void ForceReinit() {
    {
      std::unique_lock<std::mutex> lock(init_mutex_);
      is_initialized_ = false;
    }
    Init();
  }

 private:
  static CdmClientPropertySet* GetCdmClientPropertySet(
      const CdmSessionId& session_id);
  static void set_oem_crypto_use_secure_buffers(bool flag) {
    oem_crypto_use_secure_buffers_ = flag;
  }
  static void set_oem_crypto_use_fifo(bool flag) {
    oem_crypto_use_fifo_ = flag;
  }
  static void set_oem_crypto_use_userspace_buffers(bool flag) {
    oem_crypto_use_userspace_buffers_ = flag;
  }
  static void set_use_certificates_as_identification(bool flag) {
    use_certificates_as_identification_ = flag;
  }

#if defined(UNIT_TEST)
  FRIEND_TEST(CdmSessionTest, InitWithBuiltInCertificate);
  FRIEND_TEST(CdmSessionTest, InitWithCertificate);
  FRIEND_TEST(CdmSessionTest, InitWithKeybox);
  FRIEND_TEST(CdmSessionTest, ReInitFail);
  FRIEND_TEST(CdmSessionTest, InitFailCryptoError);
  FRIEND_TEST(CdmSessionTest, InitNeedsProvisioning);
  FRIEND_TEST(CdmLicenseTest, PrepareKeyRequestValidation);
#endif

  // Called at least once before any properties are used.
  static void InitOnce();

  static std::mutex init_mutex_;
  static std::mutex session_mutex_;
  static bool is_initialized_;
  static bool oem_crypto_use_secure_buffers_;
  static bool oem_crypto_use_fifo_;
  static bool oem_crypto_use_userspace_buffers_;
  static bool use_certificates_as_identification_;
  static bool provisioning_messages_are_binary_;
  static bool allow_service_certificate_requests_;
  static bool device_files_is_a_real_filesystem_;
  static bool allow_restore_of_offline_licenses_with_release_;
  static bool delay_oem_crypto_termination_;
  static std::unique_ptr<CdmClientPropertySetMap> session_property_set_;
};  // class Properties
}  // namespace wvcdm
#endif  // WVCDM_CORE_PROPERTIES_H_