// Copyright 2016 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#pragma once

#include <stdint.h>
#include <type_traits>

namespace fbl {
namespace tests {

namespace internal {

// A templated implementation of a linear feedback shift register for various
// core state sizes.  With proper selection of the generator, the LFSR will be a
// maximum-cycle LFSR meaning that it will cycle through all of its core states
// (except for all zeros) exactly once before repeating.
template <typename CoreType, CoreType generator>
class Lfsr {
 public:
  static_assert(std::is_unsigned_v<CoreType>, "LFSR core type must be an unsigned integer!");

  constexpr explicit Lfsr(CoreType initial_core) : core_(initial_core) {}

  template <typename T>
  void SetCore(T val) {
    static_assert(std::is_unsigned_v<T>, "LFSR initializer type must be an unsigned integer!");
    core_ = static_cast<CoreType>(val);
  }

  CoreType PeekCore() const { return core_; }

  CoreType GetNext() {
    CoreType ret = 0u;
    CoreType flag = 1u;

    for (size_t i = 0; i < (sizeof(size_t) << 3); ++i) {
      bool bit = core_ & 1u;
      core_ = static_cast<CoreType>(core_ >> 1u);
      if (bit) {
        core_ ^= generator;
        ret |= flag;
      }

      flag = static_cast<CoreType>(flag << 1u);
    }

    return ret;
  }

 private:
  CoreType core_;
};

}  // namespace internal

// User-facing implementation of LFSRs of various sizes with pre-selected
// maximum-cycle generators.
template <typename T, typename Enable = void>
class Lfsr;

// MAKE_LFSR
//
// Temporary macro which deals with the boilerplate declaration of an LFSR of a
// particular core size with a particular generator, exposing the constructor in
// the process.
#define MAKE_LFSR(_bits, _gen)                                                                    \
  template <typename T>                                                                           \
  class Lfsr<T, std::enable_if_t<std::is_unsigned_v<T> && ((sizeof(T) << 3) == _bits)>>           \
      : public internal::Lfsr<uint##_bits##_t, _gen> {                                            \
   public:                                                                                        \
    using CoreType = uint##_bits##_t;                                                             \
                                                                                                  \
    template <typename U>                                                                         \
    constexpr explicit Lfsr(U initial_core)                                                       \
        : internal::Lfsr<CoreType, _gen>(static_cast<CoreType>(initial_core)) {                   \
      static_assert(std::is_unsigned_v<U>, "LFSR initializer type must be an unsigned integer!"); \
    }                                                                                             \
                                                                                                  \
    constexpr Lfsr() : internal::Lfsr<CoreType, _gen>(1u) {}                                      \
  }

MAKE_LFSR(8, 0xB8);
MAKE_LFSR(16, 0xB400);
MAKE_LFSR(32, 0xA3000000);
MAKE_LFSR(64, 0xD800000000000000);

#undef MAKE_LFSR

}  // namespace tests
}  // namespace fbl