// Copyright 2021 The Fuchsia Authors
//
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file or at
// https://opensource.org/licenses/MIT

#include <lib/unittest/unittest.h>
#include <string-file.h>

#include "ktl/array.h"
#include "ktl/string_view.h"

namespace {

constexpr char kVal = static_cast<char>(-1);

bool WriteOnEmptyBufferIsOk() {
  BEGIN_TEST;
  constexpr ktl::string_view kInput = "12345";

  StringFile sfile(ktl::span<char>{});
  EXPECT_EQ(sfile.Write(kInput), static_cast<int>(kInput.size()));

  END_TEST;
}

bool WriteEmptyStringViewIsOk() {
  BEGIN_TEST;
  ktl::array<char, 1> buffer = {};

  StringFile sfile(buffer);

  EXPECT_EQ(sfile.Write({}), 0);

  auto writen_view = std::move(sfile).take();
  ASSERT_FALSE(writen_view.empty());
  ASSERT_EQ(buffer.front(), '\0');

  END_TEST;
}

bool WriteStringViewThatFitsInBuffer() {
  BEGIN_TEST;
  constexpr ktl::string_view kInput = "12345";
  ktl::array<char, kInput.length() + 1> buffer = {};

  StringFile sfile(buffer);

  EXPECT_EQ(sfile.Write(kInput), static_cast<int>(kInput.size()));

  auto writen_view = std::move(sfile).take();

  EXPECT_TRUE(memcmp(writen_view.data(), kInput.data(), kInput.size()) == 0);
  ASSERT_TRUE(writen_view.data() == buffer.data());

  END_TEST;
}

bool WriteTruncateStringViewThatDoesntFitsInBuffer() {
  BEGIN_TEST;
  constexpr ktl::string_view kInput = "12345";
  // We would reserve last char for '\0'
  ktl::array<char, kInput.length()> buffer = {};

  StringFile sfile(buffer);

  EXPECT_EQ(sfile.Write(kInput), static_cast<int>(kInput.size()));

  auto writen_view = std::move(sfile).take();

  ASSERT_EQ(writen_view.size(), kInput.size());
  EXPECT_TRUE(memcmp(writen_view.data(), kInput.data(), writen_view.size() - 1) == 0);
  ASSERT_EQ(buffer.back(), '\0');
  ASSERT_TRUE(writen_view.data() == buffer.data());

  END_TEST;
}

bool WriteManyTimes() {
  BEGIN_TEST;
  constexpr ktl::string_view kInput = "12345";
  // We would reserve last char for '\0'
  ktl::array<char, kInput.length()> buffer = {kVal, kVal, kVal, kVal, kVal};

  StringFile sfile(buffer);

  EXPECT_EQ(sfile.Write(kInput.substr(0, 2)), 2);
  EXPECT_TRUE(memcmp(buffer.data(), kInput.data(), 2) == 0);

  EXPECT_EQ(sfile.Write(kInput.substr(2, 1)), 1);
  EXPECT_TRUE(memcmp(buffer.data() + 2, kInput.data() + 2, 1) == 0);

  EXPECT_EQ(sfile.Write(kInput.substr(3, 2)), 2);
  EXPECT_TRUE(memcmp(buffer.data() + 3, kInput.data() + 3, 1) == 0);

  ASSERT_EQ(buffer.back(), kVal);

  auto writen_view = std::move(sfile).take();

  ASSERT_EQ(writen_view.size(), kInput.size());
  EXPECT_TRUE(memcmp(writen_view.data(), kInput.data(), writen_view.size() - 1) == 0);
  ASSERT_EQ(buffer.back(), '\0');
  ASSERT_TRUE(writen_view.data() == buffer.data());

  END_TEST;
}

bool TakeAddsNullCharacter() {
  BEGIN_TEST;
  constexpr ktl::string_view kInput = "12345";
  // We would reserve last char for '\0'
  ktl::array<char, kInput.length()> buffer = {kVal, kVal, kVal, kVal, kVal};

  StringFile sfile(buffer);

  EXPECT_EQ(sfile.Write(kInput), static_cast<int>(kInput.size()));
  // Write should not have set the last character set yet.
  ASSERT_EQ(buffer.back(), kVal);

  auto writen_view = std::move(sfile).take();
  ASSERT_EQ(buffer.back(), '\0');

  ASSERT_EQ(writen_view.size(), kInput.size());
  EXPECT_TRUE(memcmp(writen_view.data(), kInput.data(), writen_view.size() - 1) == 0);
  ASSERT_TRUE(writen_view.data() == buffer.data());

  END_TEST;
}

bool TakeOnEmptyBufferIsEmpty() {
  BEGIN_TEST;

  StringFile sfile(ktl::span<char>{});
  auto writen_view = std::move(sfile).take();
  ASSERT_TRUE(writen_view.empty());

  END_TEST;
}

bool AvailableUsedSpace() {
  BEGIN_TEST;

  auto Validate = [](const StringFile& file, const char* buffer, size_t capacity,
                     size_t written) -> bool {
    BEGIN_TEST;

    const size_t effective_capacity = (capacity > 0) ? capacity - 1 : 0;
    const size_t expected_used = ktl::min(written, effective_capacity);
    const size_t expected_avail = effective_capacity - expected_used;
    const char* const expected_used_base = (expected_used > 0) ? buffer : nullptr;
    const char* const expected_avail_base = (expected_avail > 0) ? buffer + expected_used : nullptr;

    ASSERT_EQ(expected_used, file.used_region().size());
    ASSERT_EQ(expected_avail, file.available_region().size());

    ktl::span<char> used_region = file.used_region();
    ASSERT_EQ(expected_used_base, used_region.data());
    ASSERT_EQ(expected_used, used_region.size());

    ktl::span<char> available_region = file.available_region();
    ASSERT_EQ(expected_avail_base, available_region.data());
    ASSERT_EQ(expected_avail, available_region.size());

    END_TEST;
  };

  // Empty files should always report no space remaining, and no space used.
  StringFile empty_file(ktl::span<char>{});
  ASSERT_TRUE(Validate(empty_file, nullptr, 0, 0));

  // Writing to the file with no buffer should not change anything.
  empty_file.Write(ktl::string_view("x"));
  ASSERT_TRUE(Validate(empty_file, nullptr, 0, 1));

  // Repeat the tests, but now with a file backed by a non-empty buffer.
  char buffer[4];
  StringFile sfile(ktl::span<char>{buffer, sizeof(buffer)});
  for (size_t i = 0; i < sizeof(buffer); ++i) {
    ASSERT_TRUE(Validate(sfile, buffer, sizeof(buffer), i));
    sfile.Write(ktl::string_view("x"));
    ASSERT_TRUE(Validate(sfile, buffer, sizeof(buffer), i + 1));
  }

  END_TEST;
}

bool Skip() {
  BEGIN_TEST;

  char buffer[10]{0};

  // Skip a part of the start of the file, but overwrite the end.
  {
    memset(buffer, 'x', ktl::size(buffer));
    StringFile sfile{ktl::span<char>(buffer, ktl::size(buffer))};

    sfile.Skip(3);
    sfile.Write("123456789abcde");

    constexpr const char* expected_str = "xxx123456";
    ktl::span<char> actual_str = std::move(sfile).take();
    ASSERT_EQ(ktl::size(buffer), actual_str.size());
    ASSERT_EQ(ktl::size(buffer), strlen(expected_str) + 1);
    ASSERT_BYTES_EQ(reinterpret_cast<const uint8_t*>(expected_str),
                    reinterpret_cast<const uint8_t*>(actual_str.data()), ktl::size(buffer));
  }

  // Skip some of the middle of a file.
  {
    memset(buffer, 'x', ktl::size(buffer));
    StringFile sfile{ktl::span<char>(buffer, ktl::size(buffer))};

    sfile.Write("123");
    sfile.Skip(3);
    sfile.Write("456789abcde");

    constexpr const char* expected_str = "123xxx456";
    ktl::span<char> actual_str = std::move(sfile).take();
    ASSERT_EQ(ktl::size(buffer), actual_str.size());
    ASSERT_EQ(ktl::size(buffer), strlen(expected_str) + 1);
    ASSERT_BYTES_EQ(reinterpret_cast<const uint8_t*>(expected_str),
                    reinterpret_cast<const uint8_t*>(actual_str.data()), ktl::size(buffer));
  }

  // Attempt to skip past the end of a file.
  {
    memset(buffer, 'x', ktl::size(buffer));
    StringFile sfile{ktl::span<char>(buffer, ktl::size(buffer))};

    sfile.Write("123456");
    sfile.Skip(30);
    sfile.Write("789abcde");

    constexpr const char* expected_str = "123456xxx";
    ktl::span<char> actual_str = std::move(sfile).take();
    ASSERT_EQ(ktl::size(buffer), actual_str.size());
    ASSERT_EQ(ktl::size(buffer), strlen(expected_str) + 1);
    ASSERT_BYTES_EQ(reinterpret_cast<const uint8_t*>(expected_str),
                    reinterpret_cast<const uint8_t*>(actual_str.data()), ktl::size(buffer));
  }

  END_TEST;
}

bool StringViewConversion() {
  BEGIN_TEST;

  auto Validate = [](const StringFile& file, const ktl::string_view expected) -> bool {
    BEGIN_TEST;

    ktl::string_view sv;

    // Test the |as_string_view| method.
    sv = file.as_string_view();
    ASSERT_EQ(expected.size(), sv.size());
    if (!expected.size()) {
      ASSERT_NULL(sv.data());
    } else {
      ASSERT_BYTES_EQ(reinterpret_cast<const uint8_t*>(expected.data()),
                      reinterpret_cast<const uint8_t*>(sv.data()), expected.size());
    }

    // Same test, but used the explicit conversion operator instead.
    sv = static_cast<ktl::string_view>(file);
    ASSERT_EQ(expected.size(), sv.size());
    if (!expected.size()) {
      ASSERT_NULL(sv.data());
    } else {
      ASSERT_BYTES_EQ(reinterpret_cast<const uint8_t*>(expected.data()),
                      reinterpret_cast<const uint8_t*>(sv.data()), expected.size());
    }

    END_TEST;
  };

  {
    // A file with no buffer should always yield an empty string view.
    StringFile empty_file(ktl::span<char>({}));
    ASSERT_TRUE(Validate(empty_file, {}));

    // Attempting to write to the file should not change this.
    empty_file.Write("12345");
    ASSERT_TRUE(Validate(empty_file, {}));
  }

  {
    constexpr ktl::string_view kPattern{"1234"};
    char buffer[10]{0};
    StringFile sfile({buffer, sizeof(buffer)});

    ASSERT_TRUE(Validate(sfile, {}));
    sfile.Write(kPattern);
    ASSERT_TRUE(Validate(sfile, {"1234"}));
    sfile.Write(kPattern);
    ASSERT_TRUE(Validate(sfile, {"12341234"}));
    sfile.Write(kPattern);
    ASSERT_TRUE(Validate(sfile, {"123412341"}));
    sfile.Write(kPattern);
    ASSERT_TRUE(Validate(sfile, {"123412341"}));
  }

  END_TEST;
}

}  // namespace

UNITTEST_START_TESTCASE(string_file_tests)
UNITTEST("StringFile::Write - With Empty Buffer", WriteOnEmptyBufferIsOk)
UNITTEST("StringFile::Write - With Empty Input", WriteEmptyStringViewIsOk)
UNITTEST("StringFile::Write - Input fits in buffer", WriteStringViewThatFitsInBuffer)
UNITTEST("StringFile::Write - Input does not fit in buffer",
         WriteTruncateStringViewThatDoesntFitsInBuffer)
UNITTEST("StringFile::Write - Multiple Calls are correct", WriteManyTimes)
UNITTEST("StringFile::take - Adds Null Character", TakeAddsNullCharacter)
UNITTEST("StringFile::take - Empty Buffer", TakeOnEmptyBufferIsEmpty)
UNITTEST("StringFile avail/used space", AvailableUsedSpace)
UNITTEST("StringFile::Skip", Skip)
UNITTEST("StringFile string_view conversion", StringViewConversion)
UNITTEST_END_TESTCASE(string_file_tests, "string_file", "StringFile tests")