// Copyright 2013 Google Inc. All Rights Reserved.

#include "wv_content_decryption_module.h"

#include <iostream>

#include "cdm_engine.h"
#include "log.h"
#include "wv_cdm_constants.h"
#include "wv_cdm_event_listener.h"

namespace wvcdm {

WvContentDecryptionModule::WvContentDecryptionModule() :
    cdm_engine_(new CdmEngine()) {
}

WvContentDecryptionModule::~WvContentDecryptionModule() {
}

CdmResponseType WvContentDecryptionModule::OpenSession(
    const CdmKeySystem& key_system,
    CdmSessionId* session_id) {
  return cdm_engine_->OpenSession(key_system, session_id);
}

CdmResponseType WvContentDecryptionModule::CloseSession(
    const CdmSessionId& session_id) {
  return cdm_engine_->CloseSession(session_id);
}

CdmResponseType WvContentDecryptionModule::GenerateKeyRequest(
    const CdmSessionId& session_id,
    const CdmInitData& init_data,
    const CdmLicenseType license_type,
    CdmAppParameterMap& app_parameters,
    CdmKeyMessage* key_request) {
  CdmKeySystem key_system;
  return cdm_engine_->GenerateKeyRequest(session_id, false, key_system,
                                         init_data, license_type,
                                         app_parameters, key_request);
}

CdmResponseType WvContentDecryptionModule::AddKey(
    const CdmSessionId& session_id,
    const CdmKeyResponse& key_data) {
  CdmKeySystem key_system;
  CdmInitData init_data;
  return cdm_engine_->AddKey(session_id, false, key_system,
                             init_data, key_data);
}

CdmResponseType WvContentDecryptionModule::CancelKeyRequest(
    const CdmSessionId& session_id) {
  CdmKeySystem key_system;
  return cdm_engine_->CancelKeyRequest(session_id, false, key_system);
}

CdmResponseType WvContentDecryptionModule::QueryStatus(
    CdmQueryMap* key_info) {
  return cdm_engine_->QueryStatus(key_info);
}

CdmResponseType WvContentDecryptionModule::QueryKeyStatus(
    const CdmSessionId& session_id,
    CdmQueryMap* key_info) {
  return cdm_engine_->QueryKeyStatus(session_id, key_info);
}

CdmResponseType WvContentDecryptionModule::QueryKeyControlInfo(
    const CdmSessionId& session_id,
    CdmQueryMap* key_info) {
  return cdm_engine_->QueryKeyControlInfo(session_id, key_info);
}

CdmResponseType WvContentDecryptionModule::GetProvisioningRequest(
    CdmProvisioningRequest* request,
    std::string* default_url) {
  return cdm_engine_->GetProvisioningRequest(request, default_url);
}

CdmResponseType WvContentDecryptionModule::HandleProvisioningResponse(
    CdmProvisioningResponse& response) {
  return cdm_engine_->HandleProvisioningResponse(response);
}

CdmResponseType WvContentDecryptionModule::GetSecureStops(
    CdmSecureStops* secure_stops) {
  return cdm_engine_->GetSecureStops(secure_stops);
}

CdmResponseType WvContentDecryptionModule::ReleaseSecureStops(
    const CdmSecureStopReleaseMessage& message) {
  return cdm_engine_->ReleaseSecureStops(message);
}

CdmResponseType WvContentDecryptionModule::Decrypt(
    const CdmSessionId& session_id,
    bool is_encrypted,
    const KeyId& key_id,
    const uint8_t* encrypt_buffer,
    size_t encrypt_length,
    const std::vector<uint8_t>& iv,
    size_t block_offset,
    void* decrypt_buffer,
    size_t decrypt_buffer_offset) {
  return cdm_engine_->Decrypt(session_id, is_encrypted, key_id,
                              encrypt_buffer, encrypt_length, iv,
                              block_offset, decrypt_buffer,
                              decrypt_buffer_offset, true);
}

bool WvContentDecryptionModule::AttachEventListener(
    const CdmSessionId& session_id,
    WvCdmEventListener* listener) {
  return cdm_engine_->AttachEventListener(session_id, listener);
}

bool WvContentDecryptionModule::DetachEventListener(
    const CdmSessionId& session_id,
    WvCdmEventListener* listener) {
  return cdm_engine_->DetachEventListener(session_id, listener);
}

}  // namespace wvcdm