// Copyright 2013 Google Inc. All Rights Reserved.
//
//  Mock implementation of OEMCrypto APIs
//
#ifndef MOCK_OEMCRYPTO_ENGINE_MOCK_H_
#define MOCK_OEMCRYPTO_ENGINE_MOCK_H_

#include <stdint.h>
#include <time.h>
#include <map>
#include <vector>

#include <openssl/rsa.h>

#include "OEMCryptoCENC.h"  // Needed for enums only.
#include "file_store.h"
#include "lock.h"
#include "oemcrypto_auth_mock.h"
#include "oemcrypto_key_mock.h"
#include "oemcrypto_rsa_key_shared.h"
#include "oemcrypto_session.h"
#include "oemcrypto_usage_table_mock.h"
#include "wv_cdm_types.h"

namespace wvoec_mock {

typedef std::map<SessionId, SessionContext*> ActiveSessions;

class CryptoEngine {
 public:
  CryptoEngine(wvcdm::FileSystem* file_system);
  ~CryptoEngine();

  bool Initialized() { return true; }

  bool ValidRootOfTrust() { return root_of_trust_.Validate(); }

  bool InstallKeybox(const uint8_t* keybox, size_t keybox_length) {
    return root_of_trust_.InstallKeybox(keybox, keybox_length);
  }

  void UseTestKeybox() { root_of_trust_.UseTestKeybox(); }

  bool LoadTestRsaKey() { return root_of_trust_.LoadTestRsaKey(); }

  KeyboxError ValidateKeybox() { return root_of_trust_.ValidateKeybox(); }

  const std::vector<uint8_t>& DeviceRootKey(bool override_to_real = false) {
    return root_of_trust_.DeviceKey(override_to_real);
  }

  const std::vector<uint8_t>& DeviceRootId() {
    return root_of_trust_.DeviceId();
  }

  size_t DeviceRootTokenLength() { return root_of_trust_.DeviceTokenLength(); }

  const uint8_t* const DeviceRootToken() {
    return root_of_trust_.DeviceToken();
  }

  void Terminate();

  SessionId CreateSession();

  bool DestroySession(SessionId sid);

  SessionContext* FindSession(SessionId sid);

  size_t GetNumberOfOpenSessions() { return sessions_.size(); }

  size_t GetMaxNumberOfSessions() {
    // An arbitrary limit for mock implementation.
    static const size_t kMaxSupportedOEMCryptoSessions = 64;
    return kMaxSupportedOEMCryptoSessions;
  }

  // Configuration constants - controls behavior of this CryptoEngine
  OEMCrypto_HDCP_Capability config_current_hdcp_capability();
  OEMCrypto_HDCP_Capability config_maximum_hdcp_capability();

  UsageTable& usage_table() { return usage_table_; }
  wvcdm::FileSystem* file_system() { return file_system_; }

  bool config_local_display_only();
  bool config_closed_platform();
  bool config_supports_usage_table();
  bool config_supports_keybox();
  OEMCrypto_ProvisioningMethod config_provisioning_method();
  OEMCryptoResult get_oem_certificate(SessionContext* session,
                                      uint8_t* public_cert,
                                      size_t* public_cert_length);
  bool config_is_anti_rollback_hw_present();
  const char* config_security_level();
  uint8_t config_security_patch_level();

 private:
  ActiveSessions sessions_;
  AuthenticationRoot root_of_trust_;
  wvcdm::Lock session_table_lock_;
  wvcdm::FileSystem* file_system_;
  UsageTable usage_table_;

  CORE_DISALLOW_COPY_AND_ASSIGN(CryptoEngine);
};

}  // namespace wvoec_mock

#endif  // MOCK_OEMCRYPTO_ENGINE_MOCK_H_