// Copyright 2016 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Definitions that allow for DRM support, common between Player and Decoder
// interfaces.

#include "media/crypto/starboard_decryptor.h"

#include "base/logging.h"
#include "media/base/decrypt_config.h"

namespace media {

namespace {

std::string ToString(const void* buffer, int size) {
  const char* char_buffer = reinterpret_cast<const char*>(buffer);
  return std::string(char_buffer, char_buffer + size);
}

}  // namespace

StarboardDecryptor::StarboardDecryptor(const char* key_system,
                                       DecryptorClient* decryptor_client)
    : client_(decryptor_client) {
  drm_system_ =
      SbDrmCreateSystem(key_system, this, KeyRequestFunc, KeyAddedFunc);
}

StarboardDecryptor::~StarboardDecryptor() {
  SbDrmDestroySystem(drm_system_);
}

bool StarboardDecryptor::GenerateKeyRequest(const std::string& key_system,
                                            const std::string& type,
                                            const uint8_t* init_data,
                                            int init_data_length) {
  if (drm_system_ == kSbDrmSystemInvalid) {
    return false;
  }
  if (key_system_.empty()) {
    key_system_ = key_system;
  }
  DCHECK_EQ(key_system_, key_system);
  SbDrmGenerateSessionUpdateRequest(drm_system_, type.c_str(), init_data,
                                    init_data_length);
  return true;
}

void StarboardDecryptor::AddKey(const std::string& key_system,
                                const uint8_t* key,
                                int key_length,
                                const uint8_t* init_data,
                                int init_data_length,
                                const std::string& session_id) {
  SbDrmUpdateSession(drm_system_, key, key_length, session_id.c_str(),
                     session_id.size());
}

void StarboardDecryptor::CancelKeyRequest(const std::string& key_system,
                                          const std::string& session_id) {
  SbDrmCloseSession(drm_system_, session_id.c_str(), session_id.size());
}

void StarboardDecryptor::RegisterKeyAddedCB(StreamType stream_type,
                                            const KeyAddedCB& key_added_cb) {
  NOTREACHED();
}

void StarboardDecryptor::Decrypt(StreamType stream_type,
                                 const scoped_refptr<DecoderBuffer>& encrypted,
                                 const DecryptCB& decrypt_cb) {
  decrypt_cb.Run(kSuccess, encrypted);
}

void StarboardDecryptor::CancelDecrypt(StreamType stream_type) {
  // no-op
}

void StarboardDecryptor::InitializeAudioDecoder(
    scoped_ptr<AudioDecoderConfig> config,
    const DecoderInitCB& init_cb) {
  // StarboardDecryptor does not support audio decoding.
  // This puts us in "decrypt only" mode.
  // Decoding is handled by the system default decoders.
  init_cb.Run(false);
}

void StarboardDecryptor::InitializeVideoDecoder(
    scoped_ptr<VideoDecoderConfig> config,
    const DecoderInitCB& init_cb) {
  // StarboardDecryptor does not support video decoding.
  // This puts us in "decrypt only" mode.
  // Decoding is handled by the system default decoders.
  init_cb.Run(false);
}

void StarboardDecryptor::DecryptAndDecodeAudio(
    const scoped_refptr<DecoderBuffer>& encrypted,
    const AudioDecodeCB& audio_decode_cb) {
  NOTREACHED();
}

void StarboardDecryptor::DecryptAndDecodeVideo(
    const scoped_refptr<DecoderBuffer>& encrypted,
    const VideoDecodeCB& video_decode_cb) {
  NOTREACHED();
}

void StarboardDecryptor::ResetDecoder(StreamType stream_type) {
  NOTREACHED();
}

void StarboardDecryptor::DeinitializeDecoder(StreamType stream_type) {
  NOTREACHED();
}

void StarboardDecryptor::OnKeyRequest(const void* session_id,
                                      int session_id_size,
                                      const void* content,
                                      int content_size,
                                      const char* url) {
  if (session_id) {
    client_->KeyMessage(key_system_, ToString(session_id, session_id_size),
                        ToString(content, content_size), url);
  } else {
    client_->KeyError(key_system_, "", Decryptor::kUnknownError, 0);
  }
}

void StarboardDecryptor::OnKeyAdded(const void* session_id,
                                    int session_id_length,
                                    bool succeeded) {
  std::string session(
      reinterpret_cast<const char*>(session_id),
      reinterpret_cast<const char*>(session_id) + session_id_length);

  if (succeeded) {
    client_->KeyAdded(key_system_, session);
  } else {
    client_->KeyError(key_system_, session, Decryptor::kUnknownError, 0);
  }
}

// static
void StarboardDecryptor::KeyRequestFunc(SbDrmSystem drm_system,
                                        void* context,
                                        const void* session_id,
                                        int session_id_size,
                                        const void* content,
                                        int content_size,
                                        const char* url) {
  DCHECK(context);
  StarboardDecryptor* decryptor =
      reinterpret_cast<StarboardDecryptor*>(context);
  DCHECK_EQ(drm_system, decryptor->drm_system_);

  decryptor->OnKeyRequest(session_id, session_id_size, content, content_size,
                          url);
}

// static
void StarboardDecryptor::KeyAddedFunc(SbDrmSystem drm_system,
                                      void* context,
                                      const void* session_id,
                                      int session_id_length,
                                      bool succeeded) {
  DCHECK(context);
  StarboardDecryptor* decryptor =
      reinterpret_cast<StarboardDecryptor*>(context);
  DCHECK_EQ(drm_system, decryptor->drm_system_);
  decryptor->OnKeyAdded(session_id, session_id_length, succeeded);
}

}  // namespace media