#include "Facade.h"
#include "Internal.h"

#include <nanobench.h>

void monotonicallyIncreasing() {
  constexpr int kWindow = 1000;
  ankerl::nanobench::Bench bench;
  Facade facade{kWindow + 1};

  bench.minEpochIterations(kWindow * 10);

  bench.warmup(kWindow).run("monotonically increasing", [&] {
    const int64_t remove = __builtin_bswap64(facade.getVersion() - kWindow);
    const int64_t next = __builtin_bswap64(facade.getVersion());
    weaselab::VersionedMap::Mutation mutations[] = {
        {(const uint8_t *)&remove, nullptr, 8, 0,
         weaselab::VersionedMap::Clear},
        {(const uint8_t *)&next, (const uint8_t *)&next, 8, 8,
         weaselab::VersionedMap::Set},
    };
    facade.addMutations(mutations, sizeof(mutations) / sizeof(mutations[0]),
                        facade.getVersion() + 1);
    facade.setOldestVersion(facade.getVersion() - kWindow);
  });

  const auto v = facade.getVersion() - kWindow / 2;
  const auto begin = facade.versioned.begin(v);
  const auto end = facade.versioned.end(v);
  auto iter = begin;

  bench.run("deref", [&] { bench.doNotOptimizeAway(*iter); });

  iter = begin;
  bench.run("++iter", [&] {
    ++iter;
    if (iter == end) {
      iter = begin;
    }
  });

  iter = end;
  bench.run("--iter", [&] {
    --iter;
    if (iter == begin) {
      iter = end;
    }
  });

  bench.run("begin", [&] { facade.versioned.begin(v); });

  bench.run("begin (firstGeq)", [&] {
    weaselab::VersionedMap::Key key{nullptr, 0};
    weaselab::VersionedMap::Iterator iter;
    facade.versioned.firstGeq(&key, &v, &iter, 1);
  });

  bench.run("end", [&] { facade.versioned.end(v); });
}

void bulkFirstGeq() {
  constexpr int kNumKeys = 100000;
  constexpr int kNumQueries = 100;
  ankerl::nanobench::Bench bench;
  bench.batch(kNumQueries);

  // Initialize `versionedMap`
  weaselab::VersionedMap versionedMap{0};
  for (int64_t i = 0; i < kNumKeys; ++i) {
    const auto bigEndian = __builtin_bswap64(i);
    weaselab::VersionedMap::Mutation m;
    m.param1 = (const uint8_t *)&bigEndian;
    m.param1Len = sizeof(bigEndian);
    m.param2 = (const uint8_t *)&bigEndian;
    m.param2Len = sizeof(bigEndian);
    m.type = weaselab::VersionedMap::Set;
    versionedMap.addMutations(&m, 1, i + 1);
  }

  // Prepare queries
  Arena arena;
  auto *keys = new (arena) weaselab::VersionedMap::Key[kNumQueries];
  auto *versions = new (arena) int64_t[kNumQueries];
  for (int64_t i = 0; i < kNumQueries; ++i) {
    int64_t key = i * kNumKeys / kNumQueries;
    static_assert(kNumKeys >= kNumQueries);
    versions[i] = kNumKeys - i;
    const auto bigEndian = __builtin_bswap64(key);
    uint8_t *k = new (arena) uint8_t[sizeof(bigEndian)];
    memcpy(k, &bigEndian, sizeof(bigEndian));
    keys[i].p = k;
    keys[i].len = sizeof(bigEndian);
  }

  // Bench
  bench.run("bulkFirstGeq", [&] {
    weaselab::VersionedMap::Iterator iterators[kNumQueries];
    versionedMap.firstGeq(keys, versions, iterators, kNumQueries);
  });
}

int main() {
  monotonicallyIncreasing();
  bulkFirstGeq();
}