#include "common.hh"

#include <algorithm>
#include <gtest/gtest.h>

#include "buffer.hh"

TEST(buffer, fixed) {
  auto buf = Buffer::fixed(10);
  EXPECT_TRUE(buf->empty());
  EXPECT_FALSE(buf->full());
  size_t avail;
  buf->rbuf(0, avail);
  EXPECT_EQ(0, avail);
  buf->wbuf(1, avail);
  EXPECT_GE(avail, 1);
  auto* wptr = buf->wbuf(100, avail);
  EXPECT_EQ(10, avail);
  avail = std::min(static_cast<size_t>(5), avail);
  std::fill_n(wptr, avail, 'A');
  buf->wcommit(avail);
  EXPECT_FALSE(buf->empty());
  EXPECT_FALSE(buf->full());
  auto* rptr = buf->rbuf(0, avail);
  EXPECT_EQ(5, avail);
  for (size_t i = 0; i < avail; ++i)
    EXPECT_EQ('A', rptr[i]) << i;
  buf->rcommit(2);
  wptr = buf->wbuf(7, avail);
  EXPECT_EQ(7, avail);
  avail = std::min(static_cast<size_t>(7), avail);
  std::fill_n(wptr, avail, 'B');
  buf->wcommit(avail);
  EXPECT_FALSE(buf->empty());
  EXPECT_TRUE(buf->full());
  rptr = buf->rbuf(0, avail);
  EXPECT_EQ(10, avail);
  for (size_t i = 0; i < avail; ++i)
    EXPECT_EQ(i < 3 ? 'A' : 'B', rptr[i]) << i;
  buf->rcommit(5);
  EXPECT_FALSE(buf->empty());
  EXPECT_FALSE(buf->full());
  wptr = buf->wbuf(5, avail);
  EXPECT_EQ(5, avail);
  avail = std::min(static_cast<size_t>(5), avail);
  std::fill_n(wptr, avail, 'C');
  buf->wcommit(avail);
  EXPECT_FALSE(buf->empty());
  EXPECT_TRUE(buf->full());
  rptr = buf->rbuf(0, avail);
  if (avail == 10) {
    for (size_t i = 0; i < avail; ++i)
      EXPECT_EQ(i < 5 ? 'B' : 'C', rptr[i]) << i;
    buf->rcommit(10);
  } else {
    EXPECT_EQ(5, avail);
    for (size_t i = 0; i < avail; ++i)
      EXPECT_EQ('B', rptr[i]) << i;
    buf->rcommit(5);
    rptr = buf->rbuf(0, avail);
    EXPECT_EQ(5, avail);
    for (size_t i = 0; i < avail; ++i)
      EXPECT_EQ('C', rptr[i]) << i;
    buf->rcommit(5);
  }
  buf->rcommit(0);
  EXPECT_TRUE(buf->empty());
  EXPECT_FALSE(buf->full());

  buf->wbuf(10, avail);
  EXPECT_EQ(10, avail);
  buf->wcommit(10);
  buf->wbuf(10, avail);
  EXPECT_EQ(0, avail);
  buf->wcommit(0);
  buf->clear();
  buf->wbuf(10, avail);
  EXPECT_EQ(10, avail);
}

TEST(buffer, growing) {
  auto buf = Buffer::growing(5, 50);
  EXPECT_TRUE(buf->empty());
  EXPECT_FALSE(buf->full());
  size_t avail;
  buf->rbuf(0, avail);
  EXPECT_EQ(0, avail);
  buf->wbuf(1, avail);
  EXPECT_GE(avail, 1);
  auto* wptr = buf->wbuf(100, avail);
  EXPECT_EQ(50, avail);
  avail = std::min(static_cast<size_t>(5), avail);
  std::fill_n(wptr, avail, 'A');
  buf->wcommit(avail);
  EXPECT_FALSE(buf->empty());
  EXPECT_FALSE(buf->full());
  auto* rptr = buf->rbuf(0, avail);
  EXPECT_EQ(5, avail);
  for (size_t i = 0; i < avail; ++i)
    EXPECT_EQ('A', rptr[i]) << i;
  buf->rcommit(2);
  wptr = buf->wbuf(7, avail);
  EXPECT_GE(avail, 7);
  avail = std::min(static_cast<size_t>(7), avail);
  std::fill_n(wptr, avail, 'B');
  buf->wcommit(avail);
  EXPECT_FALSE(buf->empty());
  EXPECT_FALSE(buf->full());
  rptr = buf->rbuf(0, avail);
  EXPECT_EQ(10, avail);
  for (size_t i = 0; i < avail; ++i)
    EXPECT_EQ(i < 3 ? 'A' : 'B', rptr[i]) << i;
  buf->rcommit(5);
  EXPECT_FALSE(buf->empty());
  EXPECT_FALSE(buf->full());
  wptr = buf->wbuf(5, avail);
  EXPECT_GE(avail, 5);
  avail = std::min(static_cast<size_t>(5), avail);
  std::fill_n(wptr, avail, 'C');
  buf->wcommit(avail);
  EXPECT_FALSE(buf->empty());
  EXPECT_FALSE(buf->full());
  rptr = buf->rbuf(0, avail);
  EXPECT_EQ(10, avail);
  for (size_t i = 0; i < avail; ++i)
    EXPECT_EQ(i < 5 ? 'B' : 'C', rptr[i]) << i;
  buf->rcommit(10);
  buf->rcommit(0);
  EXPECT_TRUE(buf->empty());
  EXPECT_FALSE(buf->full());

  buf->wbuf(50, avail);
  EXPECT_EQ(50, avail);
  buf->wcommit(50);
  buf->wbuf(50, avail);
  EXPECT_EQ(0, avail);
  buf->wcommit(0);
  buf->clear();
  buf->wbuf(5, avail);
  EXPECT_GE(avail, 5);
  buf->wcommit(5);
  buf->rbuf(0, avail);
  EXPECT_EQ(5, avail);
  buf->rcommit(3);
  buf->wbuf(3, avail);
  EXPECT_GE(avail, 3);
}

TEST(buffer, fixed_want) {
  auto buf = Buffer::fixed(10);

  size_t avail;
  auto* wptr = buf->wbuf(10, avail);
  ASSERT_EQ(10, avail);
  std::fill_n(wptr, 10, 'a');
  buf->wcommit(10);

  auto* rptr = buf->rbuf(0, avail);
  ASSERT_EQ(10, avail);
  for (size_t i = 0; i < avail; ++i)
    EXPECT_EQ('a', rptr[i]) << i;
  buf->rcommit(5);

  wptr = buf->wbuf(5, avail);
  ASSERT_EQ(5, avail);
  std::fill_n(wptr, 5, 'b');
  buf->wcommit(5);

  buf->rbuf(0, avail);
  ASSERT_EQ(5, avail);

  buf->rbuf(10, avail);
  ASSERT_EQ(10, avail);
  for (size_t i = 0; i < avail; ++i)
    EXPECT_EQ(i < 5 ? 'a' : 'b', rptr[i]) << i;
  buf->rcommit(10);

  EXPECT_TRUE(buf->empty());

  wptr = buf->wbuf(10, avail);
  ASSERT_EQ(10, avail);
  std::fill_n(wptr, 10, 'a');
  buf->wcommit(10);

  buf->rcommit(5);

  wptr = buf->wbuf(3, avail);
  ASSERT_EQ(5, avail);
  std::fill_n(wptr, 3, 'b');
  buf->wcommit(3);

  buf->rbuf(0, avail);
  ASSERT_EQ(5, avail);

  buf->rbuf(10, avail);
  ASSERT_EQ(8, avail);
  for (size_t i = 0; i < avail; ++i)
    EXPECT_EQ(i < 5 ? 'a' : 'b', rptr[i]) << i;
  buf->rcommit(8);
}

TEST(buffer, read) {
  auto buf = Buffer::fixed(10);
  size_t avail;
  auto* wptr = buf->wbuf(10, avail);
  ASSERT_EQ(10, avail);
  std::fill_n(wptr, 5, 'a');
  std::fill_n(wptr + 5, 5, 'b');
  buf->wcommit(10);

  char tmp[5];
  size_t got = Buffer::read(buf.get(), tmp, 0);
  EXPECT_EQ(0, got);
  got = Buffer::read(buf.get(), tmp, 5);
  ASSERT_EQ(5, got);
  for (size_t i = 0; i < 5; ++i)
    EXPECT_EQ('a', tmp[i]) << i;

  got = Buffer::read(buf.get(), tmp, 3);
  ASSERT_EQ(3, got);
  got = Buffer::read(buf.get(), tmp + 3, 10);
  ASSERT_EQ(2, got);
  for (size_t i = 0; i < 5; ++i)
    EXPECT_EQ('b', tmp[i]) << i;

  got = Buffer::read(buf.get(), tmp, 5);
  EXPECT_EQ(0, got);
}

TEST(buffer, write) {
  char tmp[10];
  std::fill_n(tmp, 5, 'a');
  std::fill_n(tmp + 5, 5, 'b');

  auto buf = Buffer::growing(5, 10);
  auto got = Buffer::write(buf.get(), tmp, 0);
  EXPECT_EQ(0, got);
  got = Buffer::write(buf.get(), tmp, 2);
  EXPECT_EQ(2, got);
  got = Buffer::write(buf.get(), tmp + 2, 5);
  EXPECT_EQ(5, got);
  got = Buffer::write(buf.get(), tmp + 7, 10);
  EXPECT_EQ(3, got);

  char tmp2[10];
  got = Buffer::read(buf.get(), tmp2, 10);
  EXPECT_EQ(10, got);

  for (size_t i = 0; i < 10; ++i)
    EXPECT_EQ(tmp[i], tmp2[i]) << i;
}

TEST(buffer, growing_full) {
  char tmp[10];
  std::fill_n(tmp, 10, 'x');
  auto buf = Buffer::growing(5, 10);
  Buffer::write(buf.get(), tmp, 10);
  EXPECT_TRUE(buf->full());
  char tmp2[1];
  auto got = Buffer::read(buf.get(), tmp2, 1);
  EXPECT_EQ('x', tmp2[0]);
  EXPECT_EQ(1, got);
  EXPECT_FALSE(buf->full());
}

TEST(buffer, null) {
  auto buf = Buffer::null();
  EXPECT_FALSE(buf->full());
  EXPECT_TRUE(buf->empty());
  size_t avail;
  buf->rbuf(1, avail);
  EXPECT_EQ(0, avail);
  auto* ptr = buf->wbuf(65536, avail);
  ASSERT_GE(avail, 1);
  ptr[0] = 'x';
  buf->wcommit(1);
  EXPECT_TRUE(buf->empty());
  buf->rbuf(1, avail);
  EXPECT_EQ(0, avail);
  buf->rcommit(0);
  buf->clear();
}