/*
 *
 * Copyright 2018 gRPC authors.
 *
 * 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 <stdbool.h>
#include <stdio.h>
#include <stdlib.h>

#include "src/core/tsi/alts/handshaker/transport_security_common_api.h"

const size_t kMaxRpcVersionMajor = 3;
const size_t kMaxRpcVersionMinor = 2;
const size_t kMinRpcVersionMajor = 2;
const size_t kMinRpcVersionMinor = 1;

static bool grpc_gcp_rpc_protocol_versions_equal(
    grpc_gcp_rpc_protocol_versions* l_versions,
    grpc_gcp_rpc_protocol_versions* r_versions) {
  GPR_ASSERT(l_versions != nullptr && r_versions != nullptr);
  if ((l_versions->has_max_rpc_version ^ r_versions->has_max_rpc_version) |
      (l_versions->has_min_rpc_version ^ r_versions->has_min_rpc_version)) {
    return false;
  }
  if (l_versions->has_max_rpc_version) {
    if ((l_versions->max_rpc_version.major !=
         r_versions->max_rpc_version.major) ||
        (l_versions->max_rpc_version.minor !=
         r_versions->max_rpc_version.minor)) {
      return false;
    }
  }
  if (l_versions->has_min_rpc_version) {
    if ((l_versions->min_rpc_version.major !=
         r_versions->min_rpc_version.major) ||
        (l_versions->min_rpc_version.minor !=
         r_versions->min_rpc_version.minor)) {
      return false;
    }
  }
  return true;
}

static void test_success() {
  grpc_gcp_rpc_protocol_versions version;
  grpc_gcp_rpc_protocol_versions decoded_version;
  GPR_ASSERT(grpc_gcp_rpc_protocol_versions_set_max(
      &version, kMaxRpcVersionMajor, kMaxRpcVersionMinor));
  GPR_ASSERT(grpc_gcp_rpc_protocol_versions_set_min(
      &version, kMinRpcVersionMajor, kMinRpcVersionMinor));
  /* Serializes to raw bytes. */
  size_t encoded_length =
      grpc_gcp_rpc_protocol_versions_encode_length(&version);
  uint8_t* encoded_bytes = static_cast<uint8_t*>(gpr_malloc(encoded_length));
  GPR_ASSERT(grpc_gcp_rpc_protocol_versions_encode_to_raw_bytes(
      &version, encoded_bytes, encoded_length));
  grpc_slice encoded_slice;
  /* Serializes to grpc slice. */
  GPR_ASSERT(grpc_gcp_rpc_protocol_versions_encode(&version, &encoded_slice));
  /* Checks serialized raw bytes and serialized grpc slice have same content. */
  GPR_ASSERT(encoded_length == GRPC_SLICE_LENGTH(encoded_slice));
  GPR_ASSERT(memcmp(encoded_bytes, GRPC_SLICE_START_PTR(encoded_slice),
                    encoded_length) == 0);
  /* Deserializes and compares with the original version. */
  GPR_ASSERT(
      grpc_gcp_rpc_protocol_versions_decode(encoded_slice, &decoded_version));
  GPR_ASSERT(grpc_gcp_rpc_protocol_versions_equal(&version, &decoded_version));
  grpc_slice_unref(encoded_slice);
  gpr_free(encoded_bytes);
}

static void test_failure() {
  grpc_gcp_rpc_protocol_versions version, decoded_version;
  grpc_slice encoded_slice;
  /* Test for invalid arguments. */
  GPR_ASSERT(!grpc_gcp_rpc_protocol_versions_set_max(
      nullptr, kMaxRpcVersionMajor, kMaxRpcVersionMinor));
  GPR_ASSERT(!grpc_gcp_rpc_protocol_versions_set_min(
      nullptr, kMinRpcVersionMajor, kMinRpcVersionMinor));
  GPR_ASSERT(grpc_gcp_rpc_protocol_versions_encode_length(nullptr) == 0);
  GPR_ASSERT(grpc_gcp_rpc_protocol_versions_set_max(
      &version, kMaxRpcVersionMajor, kMaxRpcVersionMinor));
  GPR_ASSERT(grpc_gcp_rpc_protocol_versions_set_min(
      &version, kMinRpcVersionMajor, kMinRpcVersionMinor));
  size_t encoded_length =
      grpc_gcp_rpc_protocol_versions_encode_length(&version);
  uint8_t* encoded_bytes = static_cast<uint8_t*>(gpr_malloc(encoded_length));
  GPR_ASSERT(!grpc_gcp_rpc_protocol_versions_encode_to_raw_bytes(
      nullptr, encoded_bytes, encoded_length));
  GPR_ASSERT(!grpc_gcp_rpc_protocol_versions_encode_to_raw_bytes(
      &version, nullptr, encoded_length));
  GPR_ASSERT(!grpc_gcp_rpc_protocol_versions_encode_to_raw_bytes(
      &version, encoded_bytes, 0));
  GPR_ASSERT(!grpc_gcp_rpc_protocol_versions_encode(nullptr, &encoded_slice));
  GPR_ASSERT(!grpc_gcp_rpc_protocol_versions_encode(&version, nullptr));
  GPR_ASSERT(!grpc_gcp_rpc_protocol_versions_decode(encoded_slice, nullptr));
  /* Test for nanopb decode. */
  GPR_ASSERT(grpc_gcp_rpc_protocol_versions_encode(&version, &encoded_slice));
  grpc_slice bad_slice = grpc_slice_split_head(
      &encoded_slice, GRPC_SLICE_LENGTH(encoded_slice) - 1);
  grpc_slice_unref(encoded_slice);
  GPR_ASSERT(
      !grpc_gcp_rpc_protocol_versions_decode(bad_slice, &decoded_version));
  grpc_slice_unref(bad_slice);
  gpr_free(encoded_bytes);
}

static void test_copy() {
  grpc_gcp_rpc_protocol_versions src;
  grpc_gcp_rpc_protocol_versions des;
  GPR_ASSERT(grpc_gcp_rpc_protocol_versions_set_max(&src, kMaxRpcVersionMajor,
                                                    kMaxRpcVersionMinor));
  GPR_ASSERT(grpc_gcp_rpc_protocol_versions_set_min(&src, kMinRpcVersionMajor,
                                                    kMinRpcVersionMinor));
  GPR_ASSERT(grpc_gcp_rpc_protocol_versions_copy(&src, &des));
  GPR_ASSERT(grpc_gcp_rpc_protocol_versions_equal(&src, &des));
}

static void test_check_success() {
  grpc_gcp_rpc_protocol_versions v1;
  grpc_gcp_rpc_protocol_versions v2;
  grpc_gcp_rpc_protocol_versions_version highest_common_version;
  /* test equality. */
  GPR_ASSERT(grpc_gcp_rpc_protocol_versions_set_max(&v1, kMaxRpcVersionMajor,
                                                    kMaxRpcVersionMinor));
  GPR_ASSERT(grpc_gcp_rpc_protocol_versions_set_min(&v1, kMaxRpcVersionMajor,
                                                    kMaxRpcVersionMinor));
  GPR_ASSERT(grpc_gcp_rpc_protocol_versions_set_max(&v2, kMaxRpcVersionMajor,
                                                    kMaxRpcVersionMinor));
  GPR_ASSERT(grpc_gcp_rpc_protocol_versions_set_min(&v2, kMaxRpcVersionMajor,
                                                    kMaxRpcVersionMinor));
  GPR_ASSERT(grpc_gcp_rpc_protocol_versions_check(
                 (const grpc_gcp_rpc_protocol_versions*)&v1,
                 (const grpc_gcp_rpc_protocol_versions*)&v2,
                 &highest_common_version) == 1);
  GPR_ASSERT(grpc_core::internal::grpc_gcp_rpc_protocol_version_compare(
                 &highest_common_version, &v1.max_rpc_version) == 0);

  /* test inequality. */
  GPR_ASSERT(grpc_gcp_rpc_protocol_versions_set_max(&v1, kMaxRpcVersionMajor,
                                                    kMaxRpcVersionMinor));
  GPR_ASSERT(grpc_gcp_rpc_protocol_versions_set_min(&v1, kMinRpcVersionMinor,
                                                    kMinRpcVersionMinor));
  GPR_ASSERT(grpc_gcp_rpc_protocol_versions_set_max(&v2, kMaxRpcVersionMajor,
                                                    kMinRpcVersionMinor));
  GPR_ASSERT(grpc_gcp_rpc_protocol_versions_set_min(&v2, kMinRpcVersionMajor,
                                                    kMaxRpcVersionMinor));
  GPR_ASSERT(grpc_gcp_rpc_protocol_versions_check(
                 (const grpc_gcp_rpc_protocol_versions*)&v1,
                 (const grpc_gcp_rpc_protocol_versions*)&v2,
                 &highest_common_version) == 1);
  GPR_ASSERT(grpc_core::internal::grpc_gcp_rpc_protocol_version_compare(
                 &highest_common_version, &v2.max_rpc_version) == 0);
}

static void test_check_failure() {
  grpc_gcp_rpc_protocol_versions v1;
  grpc_gcp_rpc_protocol_versions v2;
  grpc_gcp_rpc_protocol_versions_version highest_common_version;

  GPR_ASSERT(grpc_gcp_rpc_protocol_versions_set_max(&v1, kMinRpcVersionMajor,
                                                    kMinRpcVersionMinor));
  GPR_ASSERT(grpc_gcp_rpc_protocol_versions_set_min(&v1, kMinRpcVersionMajor,
                                                    kMinRpcVersionMinor));
  GPR_ASSERT(grpc_gcp_rpc_protocol_versions_set_max(&v2, kMaxRpcVersionMajor,
                                                    kMaxRpcVersionMinor));
  GPR_ASSERT(grpc_gcp_rpc_protocol_versions_set_min(&v2, kMaxRpcVersionMajor,
                                                    kMaxRpcVersionMinor));
  GPR_ASSERT(grpc_gcp_rpc_protocol_versions_check(
                 (const grpc_gcp_rpc_protocol_versions*)&v1,
                 (const grpc_gcp_rpc_protocol_versions*)&v2,
                 &highest_common_version) == 0);
}

int main(int argc, char** argv) {
  /* Run tests. */
  test_success();
  test_failure();
  test_copy();
  test_check_success();
  test_check_failure();
  return 0;
}