////////////////////////////////////////////////////////////////////////////////
// Copyright 2018 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.
////////////////////////////////////////////////////////////////////////////////

// Example of how to use the wv_cas_ecm library.

#include <cassert>
#include <fstream>
#include <iostream>
#include <string>

#include "media_cas_packager_sdk/public/wv_cas_ecm.h"
#include "media_cas_packager_sdk/public/wv_cas_types.h"

const size_t kContentIvSize = 8;
const bool kKeyRotation = false;   // whether key rotation is enabled
const char kCryptoMode[] = "CTR";  // CBC, CTR, or CSA2
const int kEcmPid = 149;           // PID for the ECM packet
const char kOutputFile[] =
    "/tmp/ecm.ts";  // ECM TS packet will be output to here

const char kCsaEvenKey[] = "even_key";                    // 8 bytes
const char kEvenContentIv8Bytes[] = "even_iv.";           // 8 bytes
const char kEvenEntitlementKeyId[] = "fake_key_id1....";  // 16 bytes
const char kEvenEntitlementKey[] =
    "fakefakefakefakefakefakefake1...";                  // 32 bytes
const char kCsaOddKey[] = "odd_key.";                    // 8 bytes
const char kOddContentIv8Bytes[] = "odd_iv..";           // 8 bytes
const char kOddEntitlementKeyId[] = "fake_key_id2....";  // 16 bytes
const char kOddEntitlementKey[] =
    "fakefakefakefakefakefakefake2...";  // 32 bytes
const uint8_t kTableId = 0x80;
const size_t kTsPacketSize = 188;

widevine::cas::CryptoMode GetCryptoMode(const std::string& crypto_mode) {
  if (crypto_mode.compare("CBC") == 0) {
    return widevine::cas::CryptoMode::kAesCbc;
  }
  if (crypto_mode.compare("CTR") == 0) {
    return widevine::cas::CryptoMode::kAesCtr;
  }
  return widevine::cas::CryptoMode::kDvbCsa2;
}

int main(int argc, char** argv) {
  // Generate ECM.
  widevine::cas::WvCasEcm wv_cas_ecm;
  widevine::cas::WvCasStatus status = wv_cas_ecm.Initialize(
      kContentIvSize, kKeyRotation, GetCryptoMode(kCryptoMode));
  if (status != widevine::cas::OK) {
    std::cerr << "Failed to initialize WV CAS ECM, error: "
              << widevine::cas::GetWvCasStatusMessage(status)
              << std::endl;
  }
  std::string ecm;
  if (kKeyRotation) {
    status = wv_cas_ecm.GenerateEcm(
        kCsaEvenKey, kEvenContentIv8Bytes, kEvenEntitlementKeyId,
        kEvenEntitlementKey, kCsaOddKey, kOddContentIv8Bytes,
        kOddEntitlementKeyId, kOddEntitlementKey, &ecm);
  } else {
    status = wv_cas_ecm.GenerateSingleKeyEcm(kCsaEvenKey, kEvenContentIv8Bytes,
                                             kEvenEntitlementKeyId,
                                             kEvenEntitlementKey, &ecm);
  }
  if (status != widevine::cas::OK) {
    std::cerr << "Failed to generate WV CAS ECM, error: "
              << widevine::cas::GetWvCasStatusMessage(status)
              << std::endl;
    return -1;
  } else {
    std::cout << "ECM size: " << ecm.size() << std::endl;
    std::cout << "ECM bytes: ";
    for (size_t i = 0; i < ecm.size(); i++) {
      printf("'\\x%02x', ", static_cast<uint16_t>(ecm.at(i)));
    }
    std::cout << std::endl;
  }
  // Generate ECM TS Packet.
  uint8_t packet[kTsPacketSize];
  uint8_t continuity_counter;  // not used.
  status = wv_cas_ecm.GenerateTsPacket(ecm, kEcmPid, kTableId,
                                       &continuity_counter, packet);
  if (status != widevine::cas::OK) {
    std::cerr << "Failed to create ECM TS packet" << std::endl;
    return -1;
  } else {
    std::cout << "TS packet bytes: ";
    for (size_t i = 0; i < kTsPacketSize; i++) {
      printf("'\\x%02x', ", static_cast<uint16_t>(packet[i]));
    }
    std::cout << std::endl;
  }
  // Write ECM TS Packet to a file.
    std::ofstream file;
    file.open(kOutputFile, std::ios_base::binary);
    assert(file.is_open());
    file.write(reinterpret_cast<char *>(packet), kTsPacketSize);
    file.close();

  return 0;
}