// -*- mode: c++; c-basic-offset: 2; -*-

#include "common.hh"
#include "test.hh"
#include "test_package.hh"

#include <memory>
#include <sstream>
#include <unordered_map>
#include <unordered_set>
#include <vector>

#include "packages.hh"

namespace {

class Delegate : public PackagesReader::Delegate {
public:
  struct Entry {
    Package package;
    std::string data;

    Entry(Package const& package)
      : package(package) {
    }
  };

  std::vector<Entry> packages;
  bool good;

  Delegate()
    : good(true) {
  }

  void package(Package const& package) override {
    if (open_.find(package.id) != open_.end()) {
      std::cerr << "Duplicate id" << std::endl;
      good = false;
      return;
    }
    if (closed_.count(package.id) > 0) {
      std::cerr << "Duplicate id" << std::endl;
      good = false;
      return;
    }
    open_[package.id] = packages.size();
    packages.emplace_back(package);
  }

  void data(uint32_t id, char const* data, size_t size, bool last) override {
    auto it = open_.find(id);
    if (it == open_.end()) {
      if (closed_.count(id)) {
        std::cerr << "Data after last == true" << std::endl;
      } else {
        std::cerr << "Data for unknown package" << std::endl;
      }
      good = false;
      return;
    }
    packages[it->second].data.append(data, size);
    if (last) {
      open_.erase(it);
      closed_.emplace(id);
    }
  }

private:
  std::unordered_map<uint32_t, size_t> open_;
  std::unordered_set<uint32_t> closed_;
};

bool test_sanity() {
  Package pkg1;

  setup(&pkg1);

  std::stringstream stream;
  auto writer = std::unique_ptr<PackagesWriter>(
      PackagesWriter::create(&stream));
  writer->write(pkg1, "Hello World!");
  writer->flush();

  Delegate delegate;
  ASSERT_EQ(PackagesReader::GOOD, PackagesReader::read(stream, &delegate));
  ASSERT_TRUE(delegate.good);
  ASSERT_EQ(static_cast<size_t>(1), delegate.packages.size());
  ASSERT_TRUE(pkg_eq(pkg1, delegate.packages[0].package));
  ASSERT_EQ("Hello World!", delegate.packages[0].data);

  return true;
}

bool test_empty() {
  std::stringstream stream;
  delete PackagesWriter::create(&stream);
  ASSERT_TRUE(!stream.str().empty());
  Delegate delegate;
  ASSERT_EQ(PackagesReader::GOOD, PackagesReader::read(stream, &delegate));
  ASSERT_TRUE(delegate.good);
  ASSERT_EQ(static_cast<size_t>(0), delegate.packages.size());
  return true;
}

}  // namespace

int main(void) {
  BEFORE;
  RUN(test_sanity());
  RUN(test_empty());
  AFTER;
}