// Copyright 2016 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "peridot/bin/ledger/storage/impl/btree/encoding.h"

#include <lib/fit/function.h>
#include <lib/fxl/strings/string_printf.h>

#include "gtest/gtest.h"
#include "peridot/bin/ledger/encryption/fake/fake_encryption_service.h"
#include "peridot/bin/ledger/storage/impl/btree/tree_node_generated.h"
#include "peridot/bin/ledger/storage/impl/object_identifier_encoding.h"
#include "peridot/bin/ledger/storage/impl/storage_test_utils.h"
#include "peridot/bin/ledger/storage/public/constants.h"

namespace storage {
namespace btree {
namespace {

// Allows to create correct std::strings with \0 bytes inside from C-style
// string constants.
std::string operator"" _s(const char* str, size_t size) {
  return std::string(str, size);
}

TEST(EncodingTest, EmptyData) {
  uint8_t level = 0u;
  std::vector<Entry> entries;
  std::map<size_t, ObjectIdentifier> children;

  std::string bytes = EncodeNode(level, entries, children);

  uint8_t res_level;
  std::vector<Entry> res_entries;
  std::map<size_t, ObjectIdentifier> res_children;
  EXPECT_TRUE(DecodeNode(bytes, &res_level, &res_entries, &res_children));
  EXPECT_EQ(level, res_level);
  EXPECT_EQ(entries, res_entries);
  EXPECT_EQ(children, res_children);
}

TEST(EncodingTest, SingleEntry) {
  uint8_t level = 1u;
  std::vector<Entry> entries = {
      {"key", MakeObjectIdentifier("object_digest"), KeyPriority::EAGER}};
  std::map<size_t, ObjectIdentifier> children = {
      {0u, MakeObjectIdentifier("child_1")},
      {1u, MakeObjectIdentifier("child_2")}};

  std::string bytes = EncodeNode(level, entries, children);

  uint8_t res_level;
  std::vector<Entry> res_entries;
  std::map<size_t, ObjectIdentifier> res_children;
  EXPECT_TRUE(DecodeNode(bytes, &res_level, &res_entries, &res_children));
  EXPECT_EQ(level, res_level);
  EXPECT_EQ(entries, res_entries);
  EXPECT_EQ(children, res_children);
}

TEST(EncodingTest, MoreEntries) {
  uint8_t level = 5;
  std::vector<Entry> entries = {
      {"key1", MakeObjectIdentifier("abc"), KeyPriority::EAGER},
      {"key2", MakeObjectIdentifier("def"), KeyPriority::LAZY},
      {"key3", MakeObjectIdentifier("geh"), KeyPriority::EAGER},
      {"key4", MakeObjectIdentifier("ijk"), KeyPriority::LAZY}};
  std::map<size_t, ObjectIdentifier> children = {
      {0, MakeObjectIdentifier("child_1")},
      {1, MakeObjectIdentifier("child_2")},
      {2, MakeObjectIdentifier("child_3")},
      {3, MakeObjectIdentifier("child_4")},
      {4, MakeObjectIdentifier("child_5")}};

  std::string bytes = EncodeNode(level, entries, children);

  uint8_t res_level;
  std::vector<Entry> res_entries;
  std::map<size_t, ObjectIdentifier> res_children;
  EXPECT_TRUE(DecodeNode(bytes, &res_level, &res_entries, &res_children));
  EXPECT_EQ(level, res_level);
  EXPECT_EQ(entries, res_entries);
  EXPECT_EQ(children, res_children);
}

TEST(EncodingTest, SparsedEntriesWithBeginAndEnd) {
  uint8_t level = 5;
  std::vector<Entry> entries = {
      {"key1", MakeObjectIdentifier("abc"), KeyPriority::EAGER},
      {"key2", MakeObjectIdentifier("def"), KeyPriority::LAZY},
      {"key3", MakeObjectIdentifier("geh"), KeyPriority::EAGER},
      {"key4", MakeObjectIdentifier("ijk"), KeyPriority::LAZY}};
  std::map<size_t, ObjectIdentifier> children = {
      {0, MakeObjectIdentifier("child_1")},
      {2, MakeObjectIdentifier("child_2")},
      {4, MakeObjectIdentifier("child_3")}};

  std::string bytes = EncodeNode(level, entries, children);

  uint8_t res_level;
  std::vector<Entry> res_entries;
  std::map<size_t, ObjectIdentifier> res_children;
  EXPECT_TRUE(DecodeNode(bytes, &res_level, &res_entries, &res_children));
  EXPECT_EQ(level, res_level);
  EXPECT_EQ(entries, res_entries);
  EXPECT_EQ(children, res_children);
}

TEST(EncodingTest, SparsedEntriesWithoutBeginAndEnd) {
  uint8_t level = 5;
  std::vector<Entry> entries = {
      {"key1", MakeObjectIdentifier("abc"), KeyPriority::EAGER},
      {"key2", MakeObjectIdentifier("def"), KeyPriority::LAZY},
      {"key3", MakeObjectIdentifier("geh"), KeyPriority::EAGER},
      {"key4", MakeObjectIdentifier("ijk"), KeyPriority::LAZY}};
  std::map<size_t, ObjectIdentifier> children = {
      {1, MakeObjectIdentifier("child_1")},
      {3, MakeObjectIdentifier("child_2")}};

  std::string bytes = EncodeNode(level, entries, children);

  uint8_t res_level;
  std::vector<Entry> res_entries;
  std::map<size_t, ObjectIdentifier> res_children;
  EXPECT_TRUE(DecodeNode(bytes, &res_level, &res_entries, &res_children));
  EXPECT_EQ(level, res_level);
  EXPECT_EQ(entries, res_entries);
  EXPECT_EQ(children, res_children);
}

TEST(EncodingTest, ZeroByte) {
  uint8_t level = 13;
  std::vector<Entry> entries = {
      {"k\0ey"_s, MakeObjectIdentifier("\0a\0\0"_s), KeyPriority::EAGER}};
  std::map<size_t, ObjectIdentifier> children = {
      {0u, MakeObjectIdentifier("ch\0ld_1"_s)},
      {1u, MakeObjectIdentifier("child_\0"_s)}};

  std::string bytes = EncodeNode(level, entries, children);

  uint8_t res_level;
  std::vector<Entry> res_entries;
  std::map<size_t, ObjectIdentifier> res_children;
  EXPECT_TRUE(DecodeNode(bytes, &res_level, &res_entries, &res_children));
  EXPECT_EQ(level, res_level);
  EXPECT_EQ(entries, res_entries);
  EXPECT_EQ(children, res_children);
}

std::string ToString(flatbuffers::FlatBufferBuilder* builder) {
  return std::string(reinterpret_cast<const char*>(builder->GetBufferPointer()),
                     builder->GetSize());
}

TEST(EncodingTest, Errors) {
  flatbuffers::FlatBufferBuilder builder;

  auto create_children = [&builder](size_t size) {
    std::vector<flatbuffers::Offset<ChildStorage>> children;

    for (size_t i = 0; i < size; ++i) {
      children.push_back(CreateChildStorage(
          builder, 1,
          ToObjectIdentifierStorage(
              &builder, MakeObjectIdentifier(fxl::StringPrintf("c%lu", i)))));
    }
    return builder.CreateVector(children);
  };

  // An empty string is not a valid serialization.
  EXPECT_FALSE(CheckValidTreeNodeSerialization(""));

  // 2 children without entries is not a valid serialization.
  builder.Finish(CreateTreeNodeStorage(
      builder,
      builder.CreateVector(std::vector<flatbuffers::Offset<EntryStorage>>()),
      create_children(2)));
  EXPECT_FALSE(CheckValidTreeNodeSerialization(ToString(&builder)));

  // A single child with index 1 is not a valid serialization.
  builder.Clear();
  builder.Finish(CreateTreeNodeStorage(
      builder,
      builder.CreateVector(std::vector<flatbuffers::Offset<EntryStorage>>()),
      create_children(1)));
  EXPECT_FALSE(CheckValidTreeNodeSerialization(ToString(&builder)));

  // 2 children with the same index is not a valid serialization.
  builder.Clear();
  builder.Finish(CreateTreeNodeStorage(
      builder,
      builder.CreateVector(
          1,
          static_cast<std::function<flatbuffers::Offset<EntryStorage>(size_t)>>(
              [&](size_t i) {
                return CreateEntryStorage(
                    builder, convert::ToFlatBufferVector(&builder, "hello"),
                    ToObjectIdentifierStorage(&builder,
                                              MakeObjectIdentifier("world")),
                    KeyPriorityStorage::KeyPriorityStorage_EAGER);
              })),
      create_children(2)));
  EXPECT_FALSE(CheckValidTreeNodeSerialization(ToString(&builder)));

  // 2 entries not sorted.
  builder.Clear();
  builder.Finish(CreateTreeNodeStorage(
      builder,
      builder.CreateVector(
          2,
          static_cast<std::function<flatbuffers::Offset<EntryStorage>(size_t)>>(
              [&](size_t i) {
                return CreateEntryStorage(
                    builder, convert::ToFlatBufferVector(&builder, "hello"),
                    ToObjectIdentifierStorage(&builder,
                                              MakeObjectIdentifier("world")),
                    KeyPriorityStorage::KeyPriorityStorage_EAGER);
              })),
      create_children(0)));
  EXPECT_FALSE(CheckValidTreeNodeSerialization(ToString(&builder)));
}

}  // namespace
}  // namespace btree
}  // namespace storage