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

#ifndef TEST_UTILS_HPP
#define TEST_UTILS_HPP

#include "chilbert/DynamicBitVec.hpp"
#include "chilbert/SmallBitVec.hpp"

#include <cstddef>
#include <cstdint>
#include <random>

/// Test context
struct Context {
  std::random_device                    rng;
  std::uniform_int_distribution<size_t> dist{0, SIZE_MAX};
};

/// Return a bit vector of type T with N zero bits
template<class T, size_t N>
T
make_zero_bitvec()
{
  T v(N);
  v.reset();
  return v;
}

/// Return a bit vector of type T with N random bits
template<class T, size_t N>
T
make_random_bitvec(Context& ctx)
{
  T v(N);
  for (size_t i = 0; i < N; ++i) {
    v.set(i, ctx.dist(ctx.rng) & 1U);
  }
  return v;
}

/// Return a random number in [min, max)
static inline size_t
rand_between(Context& ctx, const size_t min, const size_t max)
{
  assert(max >= min);
  const size_t r = (max == min) ? min : ctx.dist(ctx.rng) % (max - min) + min;
  assert(r >= min && r < max);
  return r;
}

/// Return an array of D precisions each at most Max and with sum at most N
template<size_t N, size_t D, size_t Max = 64>
std::array<size_t, D>
make_random_precisions(Context& ctx)
{
  std::array<size_t, D> ms{};

  size_t bits_left = N;
  for (size_t i = 0; i < D; ++i) {
    ms[i] = rand_between(ctx, 1, std::min(Max, bits_left / (D - i) + 1));
    bits_left -= ms[i];
  }

  return ms;
}

/// Return a `D`-dimensional point with `M` bits of precision per dimension
template<size_t M, size_t D>
std::array<uint64_t, D>
make_random_point(Context& ctx)
{
  std::array<uint64_t, D> p{};
  for (size_t i = 0; i < D; ++i) {
    p[i] = rand_between(ctx, 0, (1UL << M) - 1);
  }
  return p;
}

#endif