#include "u8.hh"

#include <gtest/gtest.h>
#include <iterator>
#include <vector>

TEST(u8, empty) {
  std::vector<uint8_t> empty;
  auto it = empty.begin();
  auto ret = u8::read(it, empty.end());
  ASSERT_FALSE(ret.has_value());
  EXPECT_EQ(u::ReadError::End, ret.error());

  auto ret_replace = u8::read_replace(it, empty.end(), false);
  ASSERT_FALSE(ret_replace.has_value());
  EXPECT_EQ(u::ReadErrorReplace::End, ret_replace.error());

  EXPECT_FALSE(u8::write(it, empty.end(), 0x40));

  EXPECT_FALSE(u8::skip(it, empty.end()));
}

TEST(u8, examples) {
  {
    std::vector<uint8_t> literal{0x57};
    auto it = literal.begin();
    auto ret = u8::read(it, literal.end());
    ASSERT_TRUE(ret.has_value());
    EXPECT_EQ(0x57, *ret);
    EXPECT_EQ(it, literal.end());

    it = literal.begin();
    EXPECT_TRUE(u8::skip(it, literal.end()));
    EXPECT_EQ(it, literal.end());
  }
  {
    std::vector<uint8_t> literal{0xce, 0x92};
    auto it = literal.begin();
    auto ret = u8::read(it, literal.end());
    ASSERT_TRUE(ret.has_value());
    EXPECT_EQ(0x392, *ret);
    EXPECT_EQ(it, literal.end());

    it = literal.begin();
    EXPECT_TRUE(u8::skip(it, literal.end()));
    EXPECT_EQ(it, literal.end());
  }
  {
    std::vector<uint8_t> literal{0xec, 0x9c, 0x84};
    auto it = literal.begin();
    auto ret = u8::read(it, literal.end());
    ASSERT_TRUE(ret.has_value());
    EXPECT_EQ(0xc704, *ret);
    EXPECT_EQ(it, literal.end());

    it = literal.begin();
    EXPECT_TRUE(u8::skip(it, literal.end()));
    EXPECT_EQ(it, literal.end());
  }
  {
    std::vector<uint8_t> literal{0xf0, 0x90, 0x8d, 0x85};
    auto it = literal.begin();
    auto ret = u8::read(it, literal.end());
    ASSERT_TRUE(ret.has_value());
    EXPECT_EQ(0x10345, *ret);
    EXPECT_EQ(it, literal.end());

    it = literal.begin();
    auto ret_replace = u8::read_replace(it, literal.end(), false);
    ASSERT_TRUE(ret_replace.has_value());
    EXPECT_EQ(0x10345, *ret_replace);
    EXPECT_EQ(it, literal.end());

    it = literal.begin();
    EXPECT_TRUE(u8::skip(it, literal.end()));
    EXPECT_EQ(it, literal.end());
  }
  {
    std::vector<uint8_t> literal(1, 0x0);
    auto it = literal.begin();
    EXPECT_TRUE(u8::write(it, literal.end(), 0x57));
    EXPECT_EQ(0x57, literal[0]);
    EXPECT_EQ(it, literal.end());
  }
  {
    std::vector<uint8_t> literal(2, 0x0);
    auto it = literal.begin();
    EXPECT_TRUE(u8::write(it, literal.end(), 0x392));
    EXPECT_EQ(0xce, literal[0]);
    EXPECT_EQ(0x92, literal[1]);
    EXPECT_EQ(it, literal.end());
  }
  {
    std::vector<uint8_t> literal(3, 0x0);
    auto it = literal.begin();
    EXPECT_TRUE(u8::write(it, literal.end(), 0xc704));
    EXPECT_EQ(0xec, literal[0]);
    EXPECT_EQ(0x9c, literal[1]);
    EXPECT_EQ(0x84, literal[2]);
    EXPECT_EQ(it, literal.end());
  }
  {
    std::vector<uint8_t> literal(4, 0x0);
    auto it = literal.begin();
    EXPECT_TRUE(u8::write(it, literal.end(), 0x10345));
    EXPECT_EQ(0xf0, literal[0]);
    EXPECT_EQ(0x90, literal[1]);
    EXPECT_EQ(0x8d, literal[2]);
    EXPECT_EQ(0x85, literal[3]);
    EXPECT_EQ(it, literal.end());
  }
}

TEST(u8, overlong) {
  {
    std::vector<uint8_t> literal{0xc0, 0x80};
    auto it = literal.begin();
    auto ret = u8::read(it, literal.end());
    ASSERT_FALSE(ret.has_value());
    EXPECT_EQ(u::ReadError::Invalid, ret.error());
  }
}

TEST(u8, incomplete) {
  {
    std::vector<uint8_t> literal{0xce};
    auto it = literal.begin();
    auto ret = u8::read(it, literal.end());
    ASSERT_FALSE(ret.has_value());
    EXPECT_EQ(u::ReadError::Incomplete, ret.error());
  }
  {
    std::vector<uint8_t> literal{0xec};
    auto it = literal.begin();
    auto ret = u8::read(it, literal.end());
    ASSERT_FALSE(ret.has_value());
    EXPECT_EQ(u::ReadError::Incomplete, ret.error());
  }
  {
    std::vector<uint8_t> literal{0xec, 0x9c};
    auto it = literal.begin();
    auto ret = u8::read(it, literal.end());
    ASSERT_FALSE(ret.has_value());
    EXPECT_EQ(u::ReadError::Incomplete, ret.error());

    it = literal.begin();
    auto ret_replace = u8::read_replace(it, literal.end(), false);
    ASSERT_FALSE(ret_replace.has_value());
    EXPECT_EQ(u::ReadErrorReplace::Incomplete, ret_replace.error());

    it = literal.begin();
    ret_replace = u8::read_replace(it, literal.end(), true);
    ASSERT_TRUE(ret_replace.has_value());
    EXPECT_EQ(0xfffd, ret_replace.value());
  }
  {
    std::vector<uint8_t> literal{0xf0};
    auto it = literal.begin();
    auto ret = u8::read(it, literal.end());
    ASSERT_FALSE(ret.has_value());
    EXPECT_EQ(u::ReadError::Incomplete, ret.error());
  }
  {
    std::vector<uint8_t> literal{0xf0, 0x90};
    auto it = literal.begin();
    auto ret = u8::read(it, literal.end());
    ASSERT_FALSE(ret.has_value());
    EXPECT_EQ(u::ReadError::Incomplete, ret.error());
  }
  {
    std::vector<uint8_t> literal{0xf0, 0x90, 0x8d};
    auto it = literal.begin();
    auto ret = u8::read(it, literal.end());
    ASSERT_FALSE(ret.has_value());
    EXPECT_EQ(u::ReadError::Incomplete, ret.error());
  }
}

TEST(u8, invalid) {
  {
    std::vector<uint8_t> literal{0xf0, 0xf0, 0xf0, 0xf0};
    auto it = literal.begin();
    auto ret = u8::read(it, literal.end());
    ASSERT_FALSE(ret.has_value());
    EXPECT_EQ(u::ReadError::Invalid, ret.error());
    it = literal.begin();
    auto ret_replace = u8::read_replace(it, literal.end(), false);
    ASSERT_TRUE(ret_replace.has_value());
    EXPECT_EQ(0xfffd, *ret_replace);
    EXPECT_EQ(it, std::next(literal.begin()));
  }
  {
    std::vector<uint8_t> literal{0xa0};
    auto it = literal.begin();
    auto ret = u8::read(it, literal.end());
    ASSERT_FALSE(ret.has_value());
    EXPECT_EQ(u::ReadError::Invalid, ret.error());
    it = literal.begin();
    auto ret_replace = u8::read_replace(it, literal.end(), false);
    ASSERT_TRUE(ret_replace.has_value());
    EXPECT_EQ(0xfffd, *ret_replace);
    EXPECT_EQ(it, std::next(literal.begin()));
  }
  {
    std::vector<uint8_t> literal{0xce, 0xff};
    auto it = literal.begin();
    auto ret = u8::read(it, literal.end());
    ASSERT_FALSE(ret.has_value());
    EXPECT_EQ(u::ReadError::Invalid, ret.error());
    it = literal.begin();
    auto ret_replace = u8::read_replace(it, literal.end(), false);
    ASSERT_TRUE(ret_replace.has_value());
    EXPECT_EQ(0xfffd, *ret_replace);
    EXPECT_EQ(it, std::next(literal.begin()));
  }
  {
    std::vector<uint8_t> literal{0xec, 0xff, 0x84};
    auto it = literal.begin();
    auto ret = u8::read(it, literal.end());
    ASSERT_FALSE(ret.has_value());
    EXPECT_EQ(u::ReadError::Invalid, ret.error());
    it = literal.begin();
    auto ret_replace = u8::read_replace(it, literal.end(), false);
    ASSERT_TRUE(ret_replace.has_value());
    EXPECT_EQ(0xfffd, *ret_replace);
    EXPECT_EQ(it, std::next(literal.begin()));
  }
  {
    std::vector<uint8_t> literal{0xec, 0x9c, 0xff};
    auto it = literal.begin();
    auto ret = u8::read(it, literal.end());
    ASSERT_FALSE(ret.has_value());
    EXPECT_EQ(u::ReadError::Invalid, ret.error());
    it = literal.begin();
    auto ret_replace = u8::read_replace(it, literal.end(), false);
    ASSERT_TRUE(ret_replace.has_value());
    EXPECT_EQ(0xfffd, *ret_replace);
    EXPECT_EQ(it, std::next(literal.begin()));
  }
  {
    std::vector<uint8_t> literal{0xf0, 0xff, 0x8d, 0x85};
    auto it = literal.begin();
    auto ret = u8::read(it, literal.end());
    ASSERT_FALSE(ret.has_value());
    EXPECT_EQ(u::ReadError::Invalid, ret.error());
    it = literal.begin();
    auto ret_replace = u8::read_replace(it, literal.end(), false);
    ASSERT_TRUE(ret_replace.has_value());
    EXPECT_EQ(0xfffd, *ret_replace);
    EXPECT_EQ(it, std::next(literal.begin()));
  }
  {
    std::vector<uint8_t> literal{0xf0, 0x90, 0xff, 0x85};
    auto it = literal.begin();
    auto ret = u8::read(it, literal.end());
    ASSERT_FALSE(ret.has_value());
    EXPECT_EQ(u::ReadError::Invalid, ret.error());
    it = literal.begin();
    auto ret_replace = u8::read_replace(it, literal.end(), false);
    ASSERT_TRUE(ret_replace.has_value());
    EXPECT_EQ(0xfffd, *ret_replace);
    EXPECT_EQ(it, std::next(literal.begin()));
  }
  {
    std::vector<uint8_t> literal{0xf0, 0x90, 0x8d, 0xff};
    auto it = literal.begin();
    auto ret = u8::read(it, literal.end());
    ASSERT_FALSE(ret.has_value());
    EXPECT_EQ(u::ReadError::Invalid, ret.error());
    it = literal.begin();
    auto ret_replace = u8::read_replace(it, literal.end(), false);
    ASSERT_TRUE(ret_replace.has_value());
    EXPECT_EQ(0xfffd, *ret_replace);
    EXPECT_EQ(it, std::next(literal.begin()));
  }
}