/*
 * Copyright 2014 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.
 */

#include "securemessage/secure_message_wrapper.h"

#include "securemessage.pb.h"
#include "securemessage/util.h"

namespace securemessage {

std::unique_ptr<string> SecureMessageWrapper::ParseHeaderIv(
    const string& header_and_body_bytes) {
  HeaderAndBody header_and_body;
  header_and_body.ParseFromString(header_and_body_bytes);
  if (header_and_body.has_header() && header_and_body.header().has_iv()) {
    return std::unique_ptr<string>(new string(
        header_and_body.header().iv()));
  } else {
    return nullptr;
  }
}

std::unique_ptr<string> SecureMessageWrapper::ParseHeader(
    const string& header_and_body_bytes) {
  HeaderAndBody header_and_body;
  header_and_body.ParseFromString(header_and_body_bytes);
  if (header_and_body.has_header()) {
    return std::unique_ptr<string>(new string(
        header_and_body.header().SerializeAsString()));
  } else {
    return nullptr;
  }
}

std::unique_ptr<string> SecureMessageWrapper::ParseInternalHeader(
    const string& header_and_body_bytes) {
  HeaderAndBodyInternal header_and_body;
  header_and_body.ParseFromString(header_and_body_bytes);
  if (header_and_body.has_header()) {
    return std::unique_ptr<string>(
        new string(header_and_body.header()));
  } else {
    return nullptr;
  }
}

std::unique_ptr<string> SecureMessageWrapper::ParseBody(
    const string& header_and_body_bytes) {
  HeaderAndBody header_and_body;
  header_and_body.ParseFromString(header_and_body_bytes);
  if (header_and_body.has_body()) {
    return std::unique_ptr<string>(new string(
        header_and_body.body()));
  } else {
    return nullptr;
  }
}

std::unique_ptr<string> SecureMessageWrapper::BuildHeaderAndBody(
    const string& header_bytes, const string& body_bytes) {
  HeaderAndBody header_and_body;
  Header* header = header_and_body.mutable_header();
  header->ParseFromString(header_bytes);
  header_and_body.set_body(body_bytes);

  return std::unique_ptr<string>(new string(
      header_and_body.SerializeAsString()));
}

int SecureMessageWrapper::GetSignatureScheme(const string& header_bytes) {
  Header header;
  header.ParseFromString(header_bytes);
  return header.signature_scheme();
}

int SecureMessageWrapper::GetEncryptionScheme(const string& header_bytes) {
  Header header;
  header.ParseFromString(header_bytes);
  return header.encryption_scheme();
}

bool SecureMessageWrapper::HasDecryptionKeyId(const string& header_bytes) {
  Header header;
  header.ParseFromString(header_bytes);
  return header.has_decryption_key_id();
}

bool SecureMessageWrapper::HasVerificationKeyId(const string& header_bytes) {
  Header header;
  header.ParseFromString(header_bytes);
  return header.has_verification_key_id();
}

uint32_t SecureMessageWrapper::GetAssociatedDataLength(
    const string& header_bytes) {
  Header header;
  header.ParseFromString(header_bytes);
  return header.associated_data_length();
}

int SecureMessageWrapper::GetSigScheme(CryptoOps::SigType sig_type) {
  switch (sig_type) {
    case CryptoOps::SigType::ECDSA_P256_SHA256:
      return securemessage::ECDSA_P256_SHA256;
    case CryptoOps::SigType::HMAC_SHA256:
      return securemessage::HMAC_SHA256;
    case CryptoOps::SigType::RSA2048_SHA256:
      return securemessage::RSA2048_SHA256;
    case CryptoOps::SigType::SIG_TYPE_END:
      Util::LogErrorAndAbort("wrong sigtype");
      return 0;
  }

  // This should never happen and is undefined behavior if it does.
  Util::LogErrorAndAbort("wrong sigtype");
  return 0;
}

int SecureMessageWrapper::GetEncScheme(CryptoOps::EncType enc_type) {
  switch (enc_type) {
    case CryptoOps::EncType::AES_256_CBC:
      return securemessage::AES_256_CBC;
    case CryptoOps::EncType::NONE:
      return securemessage::NONE;
    case CryptoOps::EncType::ENC_TYPE_END:
      Util::LogErrorAndAbort("wrong enctype");
  }

  // This should never happen and is undefined behavior if it does.
  Util::LogErrorAndAbort("wrong enctype");
  abort();
}

}  // namespace securemessage