// Copyright 2018-2022 David Robillard <d@drobilla.net>
// SPDX-License-Identifier: GPL-2.0-or-later

#undef NDEBUG

#include "test_utils.hpp"

#include "chilbert/BoundedBitVec.hpp"
#include "chilbert/DynamicBitVec.hpp"
#include "chilbert/SmallBitVec.hpp"
#include "chilbert/StaticBitVec.hpp"
#include "chilbert/detail/operations.hpp"
#include "chilbert/operators.hpp"

#include <cassert>
#include <cstddef>
#include <cstdlib>

template<class T, size_t N>
void
test_and(Context& ctx)
{
  const T a = make_random_bitvec<T, N>(ctx);
  const T b = make_random_bitvec<T, N>(ctx);
  T       r = a;
  assert((a & b) == (r &= b));

  for (size_t i = 0; i < N; ++i) {
    assert(r.test(i) == (a.test(i) && b.test(i)));
  }
}

template<class T, size_t N>
void
test_or(Context& ctx)
{
  const T a = make_random_bitvec<T, N>(ctx);
  const T b = make_random_bitvec<T, N>(ctx);
  T       r = a;
  assert((a | b) == (r |= b));

  for (size_t i = 0; i < N; ++i) {
    assert(r.test(i) == (a.test(i) || b.test(i)));
  }
}

template<class T, size_t N>
void
test_xor(Context& ctx)
{
  const T a = make_random_bitvec<T, N>(ctx);
  const T b = make_random_bitvec<T, N>(ctx);
  T       r = a;
  assert((a ^ b) == (r ^= b));

  for (size_t i = 0; i < N; ++i) {
    assert(r.test(i) == (a.test(i) != b.test(i)));
  }
}

template<class T, size_t N>
void
test_not(Context& ctx)
{
  const T v = make_random_bitvec<T, N>(ctx);
  const T r = ~v;

  for (size_t i = 0; i < N; ++i) {
    assert(r.test(i) == !v.test(i));
  }
}

template<class T, size_t N>
void
test_flip_one(Context&)
{
  T v = make_zero_bitvec<T, N>();
  for (size_t i = 0; i < N; ++i) {
    assert(v.none());
    v.flip(i);
    for (size_t j = 0; j < N; ++j) {
      assert(v.test(j) == (j == i));
    }

    v.flip(i);
    assert(v.none());
  }
}

template<class T, size_t N>
void
test_flip_all(Context& ctx)
{
  const T a = make_random_bitvec<T, N>(ctx);
  T       r = a;
  r.flip();
  for (size_t i = 0; i < N; ++i) {
    assert(r.test(i) == !a.test(i));
  }
}

template<class T, size_t N>
void
test_none(Context&)
{
  T v = make_zero_bitvec<T, N>();
  assert(v.none());
  v.set();
  assert(v.none() == (N == 0));
  if (N > 1) {
    v.reset(N / 2);
    assert(!v.none());
    v.reset();
    v.set(N / 2);
    assert(!v.none());
  }
}

template<class T, size_t N>
void
test_set_reset_one(Context&)
{
  T v = make_zero_bitvec<T, N>();
  for (size_t i = 0; i < N; ++i) {
    assert(v.none());
    v.set(i);
    for (size_t j = 0; j < N; ++j) {
      assert(v.test(j) == (j == i));
    }

    v.reset(i);
    assert(v.none());
  }
}

template<class T, size_t N>
void
test_set_all(Context&)
{
  T v = make_zero_bitvec<T, N>();
  v.set();
  for (size_t i = 0; i < N; ++i) {
    assert(v.test(i));
  }
}

template<class T, size_t N>
void
test_reset_all(Context&)
{
  T v = make_zero_bitvec<T, N>();
  v.set();
  v.reset();
  for (size_t i = 0; i < N; ++i) {
    assert(!v.test(i));
  }
}

template<class T, size_t N>
void
test_left_shift(Context& ctx)
{
  for (size_t s = 0; s < N; ++s) {
    const T v = make_random_bitvec<T, N>(ctx);
    T       r = v;
    assert((v << s) == (r <<= s));

    for (size_t i = 0; i < s; ++i) {
      assert(!r.test(i));
    }

    for (size_t i = s; i < N; ++i) {
      assert(r.test(i) == v.test(i - s));
    }
  }
}

template<class T, size_t N>
void
test_right_shift(Context& ctx)
{
  for (size_t s = 0; s < N; ++s) {
    const T v = make_random_bitvec<T, N>(ctx);
    T       r = v;
    assert((v >> s) == (r >>= s));

    for (size_t i = N - 1; i > N - s - 1; --i) {
      assert(!r.test(i));
    }

    for (size_t i = 0; i <= N - s - 1; ++i) {
      assert(r.test(i) == v.test(i + s));
    }
  }
}

template<class T, size_t N>
void
test_left_rotate(Context& ctx)
{
  const T v = make_random_bitvec<T, N>(ctx);
  for (size_t bits = 0; bits <= N; ++bits) {
    T r = v;
    r.rotl(bits);

    if (N > 0) {
      for (size_t i = 0; i < N; ++i) {
        assert(r.test((i + bits) % N) == v.test(i));
      }
    }
  }
}

template<class T, size_t N>
void
test_right_rotate(Context& ctx)
{
  const T v = make_random_bitvec<T, N>(ctx);
  for (size_t bits = 0; bits <= N; ++bits) {
    T r = v;
    r.rotr(bits);

    if (N > 0) {
      for (size_t i = 0; i < N; ++i) {
        assert(r.test(i) == v.test((i + bits) % N));
      }
    }
  }
}

template<class T, size_t N>
void
test_find_first(Context&)
{
  T v = make_zero_bitvec<T, N>();
  for (size_t i = 0; i < N; ++i) {
    v.reset();
    v.set(i);
    for (size_t j = i + 1; j < N; ++j) {
      v.set(j, static_cast<bool>(rand() % 2));
    }
    assert(size_t(v.find_first()) == i + 1);
  }
}

template<class T, size_t N>
void
test_gray_code(Context& ctx)
{
  const T v = make_random_bitvec<T, N>(ctx);
  T       r = v;
  chilbert::detail::gray_code(r);

  if (N > 0) {
    assert(N == 1 || r == (v ^ (v >> 1)));

    T s = r;
    chilbert::detail::gray_code_inv(s);
    assert(s == v);
  }
}

template<class T, size_t N>
void
test_comparison(Context&)
{
  T a = make_zero_bitvec<T, N>();
  T b = make_zero_bitvec<T, N>();

  for (size_t bit = 1; bit < N; ++bit) {
    chilbert::detail::set_bit(a, bit, 1);

    for (size_t i = 0; i < bit; ++i) {
      chilbert::detail::set_bit(a, i, rand() % 2 == 0);
      chilbert::detail::set_bit(b, i, rand() % 2 == 0);
    }

    assert(b < a);
  }
}

template<class T, size_t N>
void
test_iteration(Context&)
{
  T      v     = make_zero_bitvec<T, N>();
  size_t count = 0;
  for (const auto bit : v) {
    assert(!bit);
    ++count;
  }
  assert(count == N);

  v.flip();
  count = 0;
  for (const auto bit : v) {
    assert(bit);
    ++count;
  }
  assert(count == N);
}

template<class T, size_t N>
void
test(Context& ctx)
{
  test_and<T, N>(ctx);
  test_or<T, N>(ctx);
  test_xor<T, N>(ctx);
  test_not<T, N>(ctx);
  test_flip_one<T, N>(ctx);
  test_flip_all<T, N>(ctx);
  test_none<T, N>(ctx);
  test_set_reset_one<T, N>(ctx);
  test_set_all<T, N>(ctx);
  test_reset_all<T, N>(ctx);
  test_left_shift<T, N>(ctx);
  test_right_shift<T, N>(ctx);
  test_left_rotate<T, N>(ctx);
  test_right_rotate<T, N>(ctx);
  test_find_first<T, N>(ctx);
  test_gray_code<T, N>(ctx);
  test_comparison<T, N>(ctx);
  test_iteration<T, N>(ctx);
}

int
main()
{
  Context ctx;

  // test<chilbert::SmallBitVec, 0>(ctx);
  test<chilbert::SmallBitVec, 1>(ctx);
  test<chilbert::SmallBitVec, 31>(ctx);
  test<chilbert::SmallBitVec, 32>(ctx);
  test<chilbert::SmallBitVec, 33>(ctx);
  test<chilbert::SmallBitVec, 63>(ctx);
  test<chilbert::SmallBitVec, 64>(ctx);

#ifdef _MSC_VER
#  pragma message("DynamicBitVec rotl and rotr are broken on MSVC")
#else
  test<chilbert::DynamicBitVec, 0>(ctx);
  test<chilbert::DynamicBitVec, 1>(ctx);
  test<chilbert::DynamicBitVec, 31>(ctx);
  test<chilbert::DynamicBitVec, 32>(ctx);
  test<chilbert::DynamicBitVec, 33>(ctx);
  test<chilbert::DynamicBitVec, 63>(ctx);
  test<chilbert::DynamicBitVec, 64>(ctx);
  test<chilbert::DynamicBitVec, 65>(ctx);
  test<chilbert::DynamicBitVec, 997>(ctx);
#endif

  test<chilbert::StaticBitVec<0>, 0>(ctx);
  test<chilbert::StaticBitVec<1>, 1>(ctx);
  test<chilbert::StaticBitVec<31>, 31>(ctx);
  test<chilbert::StaticBitVec<32>, 32>(ctx);
  test<chilbert::StaticBitVec<33>, 33>(ctx);
  test<chilbert::StaticBitVec<63>, 63>(ctx);
  test<chilbert::StaticBitVec<64>, 64>(ctx);
  test<chilbert::StaticBitVec<65>, 65>(ctx);
  test<chilbert::StaticBitVec<997>, 997>(ctx);

  test<chilbert::BoundedBitVec<0>, 0>(ctx);
  test<chilbert::BoundedBitVec<1>, 1>(ctx);
  test<chilbert::BoundedBitVec<31>, 31>(ctx);
  test<chilbert::BoundedBitVec<32>, 32>(ctx);
  test<chilbert::BoundedBitVec<64>, 33>(ctx);
  test<chilbert::BoundedBitVec<64>, 63>(ctx);
  test<chilbert::BoundedBitVec<64>, 64>(ctx);
  test<chilbert::BoundedBitVec<128>, 65>(ctx);
  test<chilbert::BoundedBitVec<997>, 997>(ctx);
  test<chilbert::BoundedBitVec<2048>, 997>(ctx);

  return 0;
}