// -*- 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;
    struct timespec end;

    Entry(Package const& package, struct timespec end)
      : package(package), end(end) {
    }
  };

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

  Delegate()
    : good(true) {
  }

  void package(Package const& package, struct timespec end) 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, end);
  }

  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;
  struct timespec end;

  setup(&pkg1);
  end = pkg1.timestamp;
  end.tv_sec += 12;

  std::stringstream stream;
  auto writer = std::unique_ptr<PackagesWriter>(
      PackagesWriter::create(&stream));
  writer->write(pkg1, "Hello World!", end);
  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);
  ASSERT_EQ(end.tv_sec, delegate.packages[0].end.tv_sec);
  ASSERT_EQ(end.tv_nsec, delegate.packages[0].end.tv_nsec);

  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;
}

static const uint8_t OLD[] = {
  0x54, 0x50, 0x50, 0x01, 0x00, 0x00, 0x00, 0x02,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x82,
  0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x01, 0x4f, 0x42, 0x24, 0x0b, 0x3c, 0xe3,
  0x00, 0x00, 0x8c, 0x80, 0x00, 0x50, 0x00, 0x09,
  0x31, 0x32, 0x37, 0x2e, 0x30, 0x2e, 0x30, 0x2e,
  0x31, 0x00, 0x0f, 0x77, 0x77, 0x77, 0x2e, 0x73,
  0x70, 0x61, 0x77, 0x6e, 0x65, 0x64, 0x2e, 0x62,
  0x69, 0x7a, 0x48, 0x45, 0x41, 0x44, 0x20, 0x2f,
  0x20, 0x48, 0x54, 0x54, 0x50, 0x2f, 0x31, 0x2e,
  0x31, 0x0d, 0x0a, 0x48, 0x6f, 0x73, 0x74, 0x3a,
  0x20, 0x77, 0x77, 0x77, 0x2e, 0x73, 0x70, 0x61,
  0x77, 0x6e, 0x65, 0x64, 0x2e, 0x62, 0x69, 0x7a,
  0x0d, 0x0a, 0x55, 0x73, 0x65, 0x72, 0x2d, 0x41,
  0x67, 0x65, 0x6e, 0x74, 0x3a, 0x20, 0x63, 0x75,
  0x72, 0x6c, 0x2f, 0x37, 0x2e, 0x35, 0x34, 0x2e,
  0x31, 0x0d, 0x0a, 0x41, 0x63, 0x63, 0x65, 0x70,
  0x74, 0x3a, 0x20, 0x2a, 0x2f, 0x2a, 0x0d, 0x0a,
  0x0d, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x01, 0x08, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x01, 0x4f, 0x42, 0x24, 0xcf,
  0xea, 0x31, 0x00, 0x00, 0x00, 0x50, 0x8c, 0x80,
  0x00, 0x0f, 0x77, 0x77, 0x77, 0x2e, 0x73, 0x70,
  0x61, 0x77, 0x6e, 0x65, 0x64, 0x2e, 0x62, 0x69,
  0x7a, 0x00, 0x09, 0x31, 0x32, 0x37, 0x2e, 0x30,
  0x2e, 0x30, 0x2e, 0x31, 0x48, 0x54, 0x54, 0x50,
  0x2f, 0x31, 0x2e, 0x31, 0x20, 0x32, 0x30, 0x30,
  0x20, 0x4f, 0x4b, 0x0d, 0x0a, 0x43, 0x6f, 0x6e,
  0x74, 0x65, 0x6e, 0x74, 0x2d, 0x54, 0x79, 0x70,
  0x65, 0x3a, 0x20, 0x74, 0x65, 0x78, 0x74, 0x2f,
  0x68, 0x74, 0x6d, 0x6c, 0x0d, 0x0a, 0x41, 0x63,
  0x63, 0x65, 0x70, 0x74, 0x2d, 0x52, 0x61, 0x6e,
  0x67, 0x65, 0x73, 0x3a, 0x20, 0x62, 0x79, 0x74,
  0x65, 0x73, 0x0d, 0x0a, 0x45, 0x54, 0x61, 0x67,
  0x3a, 0x20, 0x22, 0x31, 0x39, 0x30, 0x38, 0x30,
  0x37, 0x34, 0x30, 0x34, 0x39, 0x22, 0x0d, 0x0a,
  0x4c, 0x61, 0x73, 0x74, 0x2d, 0x4d, 0x6f, 0x64,
  0x69, 0x66, 0x69, 0x65, 0x64, 0x3a, 0x20, 0x53,
  0x61, 0x74, 0x2c, 0x20, 0x32, 0x31, 0x20, 0x41,
  0x70, 0x72, 0x20, 0x32, 0x30, 0x31, 0x32, 0x20,
  0x30, 0x39, 0x3a, 0x34, 0x32, 0x3a, 0x34, 0x36,
  0x20, 0x47, 0x4d, 0x54, 0x0d, 0x0a, 0x43, 0x6f,
  0x6e, 0x74, 0x65, 0x6e, 0x74, 0x2d, 0x4c, 0x65,
  0x6e, 0x67, 0x74, 0x68, 0x3a, 0x20, 0x38, 0x30,
  0x0d, 0x0a, 0x44, 0x61, 0x74, 0x65, 0x3a, 0x20,
  0x57, 0x65, 0x64, 0x2c, 0x20, 0x30, 0x39, 0x20,
  0x41, 0x75, 0x67, 0x20, 0x32, 0x30, 0x31, 0x37,
  0x20, 0x31, 0x38, 0x3a, 0x34, 0x30, 0x3a, 0x33,
  0x33, 0x20, 0x47, 0x4d, 0x54, 0x0d, 0x0a, 0x53,
  0x65, 0x72, 0x76, 0x65, 0x72, 0x3a, 0x20, 0x6c,
  0x69, 0x67, 0x68, 0x74, 0x74, 0x70, 0x64, 0x2f,
  0x31, 0x2e, 0x34, 0x2e, 0x33, 0x33, 0x0d, 0x0a,
  0x0d, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00,
};

bool test_upgrade() {
  std::stringstream stream;
  stream.write(reinterpret_cast<char const*>(OLD), sizeof(OLD));
  Delegate delegate;
  ASSERT_EQ(PackagesReader::GOOD, PackagesReader::read(stream, &delegate));
  ASSERT_TRUE(delegate.good);
  ASSERT_EQ(static_cast<size_t>(2), delegate.packages.size());
  ASSERT_EQ(static_cast<uint32_t>(1), delegate.packages[0].package.id);
  ASSERT_EQ(0x014f42, delegate.packages[0].package.timestamp.tv_sec);
  ASSERT_EQ(0x240b3ce3, delegate.packages[0].package.timestamp.tv_nsec);
  ASSERT_EQ(35968, delegate.packages[0].package.source_port);
  ASSERT_EQ("127.0.0.1", delegate.packages[0].package.source_host);
  ASSERT_EQ(80, delegate.packages[0].package.target_port);
  ASSERT_EQ("www.spawned.biz", delegate.packages[0].package.target_host);
  ASSERT_EQ(delegate.packages[0].package.timestamp.tv_sec,
            delegate.packages[0].end.tv_sec);
  ASSERT_EQ(delegate.packages[0].package.timestamp.tv_nsec,
            delegate.packages[0].end.tv_nsec);

  ASSERT_EQ(static_cast<uint32_t>(2), delegate.packages[1].package.id);
  ASSERT_EQ(0x014f42, delegate.packages[1].package.timestamp.tv_sec);
  ASSERT_EQ(0x24cfea31, delegate.packages[1].package.timestamp.tv_nsec);
  ASSERT_EQ(80, delegate.packages[1].package.source_port);
  ASSERT_EQ("www.spawned.biz", delegate.packages[1].package.source_host);
  ASSERT_EQ(35968, delegate.packages[1].package.target_port);
  ASSERT_EQ("127.0.0.1", delegate.packages[1].package.target_host);
  ASSERT_EQ(delegate.packages[1].package.timestamp.tv_sec,
            delegate.packages[1].end.tv_sec);
  ASSERT_EQ(delegate.packages[1].package.timestamp.tv_nsec,
            delegate.packages[1].end.tv_nsec);
return true;
}

}  // namespace

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