//
// Copyright (C) 2015 The Android Open Source Project
//
// 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.
//

// THIS CODE IS GENERATED.

#include "attestation/common/print_common_proto.h"

#include <string>

#include <base/strings/string_number_conversions.h>
#include <base/strings/stringprintf.h>

namespace attestation {

std::string GetProtoDebugString(KeyType value) {
  return GetProtoDebugStringWithIndent(value, 0);
}

std::string GetProtoDebugStringWithIndent(KeyType value, int indent_size) {
  if (value == KEY_TYPE_RSA) {
    return "KEY_TYPE_RSA";
  }
  if (value == KEY_TYPE_ECC) {
    return "KEY_TYPE_ECC";
  }
  return "<unknown>";
}

std::string GetProtoDebugString(KeyUsage value) {
  return GetProtoDebugStringWithIndent(value, 0);
}

std::string GetProtoDebugStringWithIndent(KeyUsage value, int indent_size) {
  if (value == KEY_USAGE_SIGN) {
    return "KEY_USAGE_SIGN";
  }
  if (value == KEY_USAGE_DECRYPT) {
    return "KEY_USAGE_DECRYPT";
  }
  return "<unknown>";
}

std::string GetProtoDebugString(CertificateProfile value) {
  return GetProtoDebugStringWithIndent(value, 0);
}

std::string GetProtoDebugStringWithIndent(CertificateProfile value,
                                          int indent_size) {
  if (value == ENTERPRISE_MACHINE_CERTIFICATE) {
    return "ENTERPRISE_MACHINE_CERTIFICATE";
  }
  if (value == ENTERPRISE_USER_CERTIFICATE) {
    return "ENTERPRISE_USER_CERTIFICATE";
  }
  if (value == CONTENT_PROTECTION_CERTIFICATE) {
    return "CONTENT_PROTECTION_CERTIFICATE";
  }
  if (value == CONTENT_PROTECTION_CERTIFICATE_WITH_STABLE_ID) {
    return "CONTENT_PROTECTION_CERTIFICATE_WITH_STABLE_ID";
  }
  if (value == CAST_CERTIFICATE) {
    return "CAST_CERTIFICATE";
  }
  if (value == GFSC_CERTIFICATE) {
    return "GFSC_CERTIFICATE";
  }
  return "<unknown>";
}

std::string GetProtoDebugString(const Quote& value) {
  return GetProtoDebugStringWithIndent(value, 0);
}

std::string GetProtoDebugStringWithIndent(const Quote& value, int indent_size) {
  std::string indent(indent_size, ' ');
  std::string output =
      base::StringPrintf("[%s] {\n", value.GetTypeName().c_str());

  if (value.has_quote()) {
    output += indent + "  quote: ";
    base::StringAppendF(
        &output, "%s",
        base::HexEncode(value.quote().data(), value.quote().size()).c_str());
    output += "\n";
  }
  if (value.has_quoted_data()) {
    output += indent + "  quoted_data: ";
    base::StringAppendF(
        &output, "%s",
        base::HexEncode(value.quoted_data().data(), value.quoted_data().size())
            .c_str());
    output += "\n";
  }
  if (value.has_quoted_pcr_value()) {
    output += indent + "  quoted_pcr_value: ";
    base::StringAppendF(&output, "%s",
                        base::HexEncode(value.quoted_pcr_value().data(),
                                        value.quoted_pcr_value().size())
                            .c_str());
    output += "\n";
  }
  if (value.has_pcr_source_hint()) {
    output += indent + "  pcr_source_hint: ";
    base::StringAppendF(&output, "%s",
                        base::HexEncode(value.pcr_source_hint().data(),
                                        value.pcr_source_hint().size())
                            .c_str());
    output += "\n";
  }
  output += indent + "}\n";
  return output;
}

std::string GetProtoDebugString(const EncryptedData& value) {
  return GetProtoDebugStringWithIndent(value, 0);
}

std::string GetProtoDebugStringWithIndent(const EncryptedData& value,
                                          int indent_size) {
  std::string indent(indent_size, ' ');
  std::string output =
      base::StringPrintf("[%s] {\n", value.GetTypeName().c_str());

  if (value.has_wrapped_key()) {
    output += indent + "  wrapped_key: ";
    base::StringAppendF(
        &output, "%s",
        base::HexEncode(value.wrapped_key().data(), value.wrapped_key().size())
            .c_str());
    output += "\n";
  }
  if (value.has_iv()) {
    output += indent + "  iv: ";
    base::StringAppendF(
        &output, "%s",
        base::HexEncode(value.iv().data(), value.iv().size()).c_str());
    output += "\n";
  }
  if (value.has_mac()) {
    output += indent + "  mac: ";
    base::StringAppendF(
        &output, "%s",
        base::HexEncode(value.mac().data(), value.mac().size()).c_str());
    output += "\n";
  }
  if (value.has_encrypted_data()) {
    output += indent + "  encrypted_data: ";
    base::StringAppendF(&output, "%s",
                        base::HexEncode(value.encrypted_data().data(),
                                        value.encrypted_data().size())
                            .c_str());
    output += "\n";
  }
  if (value.has_wrapping_key_id()) {
    output += indent + "  wrapping_key_id: ";
    base::StringAppendF(&output, "%s",
                        base::HexEncode(value.wrapping_key_id().data(),
                                        value.wrapping_key_id().size())
                            .c_str());
    output += "\n";
  }
  output += indent + "}\n";
  return output;
}

std::string GetProtoDebugString(const SignedData& value) {
  return GetProtoDebugStringWithIndent(value, 0);
}

std::string GetProtoDebugStringWithIndent(const SignedData& value,
                                          int indent_size) {
  std::string indent(indent_size, ' ');
  std::string output =
      base::StringPrintf("[%s] {\n", value.GetTypeName().c_str());

  if (value.has_data()) {
    output += indent + "  data: ";
    base::StringAppendF(
        &output, "%s",
        base::HexEncode(value.data().data(), value.data().size()).c_str());
    output += "\n";
  }
  if (value.has_signature()) {
    output += indent + "  signature: ";
    base::StringAppendF(&output, "%s", base::HexEncode(value.signature().data(),
                                                       value.signature().size())
                                           .c_str());
    output += "\n";
  }
  output += indent + "}\n";
  return output;
}

std::string GetProtoDebugString(const EncryptedIdentityCredential& value) {
  return GetProtoDebugStringWithIndent(value, 0);
}

std::string GetProtoDebugStringWithIndent(
    const EncryptedIdentityCredential& value,
    int indent_size) {
  std::string indent(indent_size, ' ');
  std::string output =
      base::StringPrintf("[%s] {\n", value.GetTypeName().c_str());

  if (value.has_asym_ca_contents()) {
    output += indent + "  asym_ca_contents: ";
    base::StringAppendF(&output, "%s",
                        base::HexEncode(value.asym_ca_contents().data(),
                                        value.asym_ca_contents().size())
                            .c_str());
    output += "\n";
  }
  if (value.has_sym_ca_attestation()) {
    output += indent + "  sym_ca_attestation: ";
    base::StringAppendF(&output, "%s",
                        base::HexEncode(value.sym_ca_attestation().data(),
                                        value.sym_ca_attestation().size())
                            .c_str());
    output += "\n";
  }
  output += indent + "}\n";
  return output;
}

}  // namespace attestation