#include "Facade.h"

#include <nanobench.h>

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

  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(
        std::max<int64_t>(0, 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); });
}

int main() { monotonicallyIncreasing(); }