////////////////////////////////////////////////////////////////////////////////
// Copyright 2019 Google LLC.
//
// This software is licensed under the terms defined in the Widevine Master
// License Agreement. For a copy of this agreement, please contact
// widevine-licensing@google.com.
////////////////////////////////////////////////////////////////////////////////

#include "common/core_message_util.h"

#include "common/oemcrypto_core_message/odk/include/core_message_deserialize.h"
#include "common/oemcrypto_core_message/odk/include/core_message_serialize.h"
#include "common/oemcrypto_core_message/odk/include/core_message_serialize_proto.h"
#include "common/sha_util.h"

using oemcrypto_core_message::deserialize::CoreCommonRequestFromMessage;
using oemcrypto_core_message::deserialize::CoreLicenseRequestFromMessage;
using oemcrypto_core_message::deserialize::CoreProvisioningRequestFromMessage;
using oemcrypto_core_message::deserialize::CoreRenewalRequestFromMessage;
using oemcrypto_core_message::serialize::CreateCoreLicenseResponseFromProto;
using oemcrypto_core_message::serialize::
    CreateCoreProvisioningResponseFromProto;
using oemcrypto_core_message::serialize::CreateCoreRenewalResponse;
using widevine::Sha256_Hash;

namespace widevine {
namespace core_message_util {
bool GetCoreProvisioningResponse(
    const std::string& serialized_provisioning_response,
    const std::string& request_core_message,
    std::string* response_core_message) {
  if (request_core_message.empty()) {
    return false;
  }
  oemcrypto_core_message::ODK_ProvisioningRequest odk_provisioning_request;
  if (CoreProvisioningRequestFromMessage(request_core_message,
                                         &odk_provisioning_request)) {
    return CreateCoreProvisioningResponseFromProto(
        serialized_provisioning_response, odk_provisioning_request,
        response_core_message);
  }
  return false;
}

bool GetCoreRenewalOrReleaseLicenseResponse(
    uint64_t renewal_duration_seconds, const std::string& request_core_message,
    std::string* response_core_message) {
  if (request_core_message.empty()) {
    return false;
  }
  oemcrypto_core_message::ODK_RenewalRequest odk_renewal_request;
  if (!CoreRenewalRequestFromMessage(request_core_message,
                                     &odk_renewal_request)) {
    return false;
  }
  return CreateCoreRenewalResponse(
      odk_renewal_request, renewal_duration_seconds, response_core_message);
}

bool GetCoreNewLicenseResponse(const std::string& license,
                               const std::string& request_core_message,
                               const bool nonce_required,
                               std::string* response_core_message) {
  if (request_core_message.empty()) {
    return false;
  }
  oemcrypto_core_message::ODK_LicenseRequest odk_license_request;
  if (!CoreLicenseRequestFromMessage(request_core_message,
                                     &odk_license_request)) {
    return false;
  }
  std::string core_request_sha256 = Sha256_Hash(request_core_message);
  return CreateCoreLicenseResponseFromProto(license, odk_license_request,
                                            core_request_sha256, nonce_required,
                                            response_core_message);
}

bool GetCoreVersion(const std::string& request_core_message,
                    uint16_t* odk_major_version, uint16_t* odk_minor_version) {
  if (odk_major_version == nullptr || odk_minor_version == nullptr) {
    return false;
  }
  oemcrypto_core_message::ODK_CommonRequest odk_common_request;
  if (!CoreCommonRequestFromMessage(request_core_message,
                                    &odk_common_request)) {
    return false;
  }
  *odk_major_version = odk_common_request.api_major_version;
  *odk_minor_version = odk_common_request.api_minor_version;
  return true;
}

}  // namespace core_message_util
}  // namespace widevine