#ifndef HASH_RIPEMD_BASE_2019_04_09_H
  #define HASH_RIPEMD_BASE_2019_04_09_H

  #include <ALCryptoLib/math/utils/math_utils.h>
  #include <ALCryptoLib/stream/hash/hash_md_base.h>

  #if(__cplusplus >= 201703L)
  namespace al::crypto::stream::hash {
  #else
  namespace al { namespace crypto { namespace stream { namespace hash {
  #endif

  template<const std::size_t ResultBitCount>
  class hash_ripemd_base
    : public al::crypto::stream::hash::hash_md_base<ResultBitCount,
                                                    ResultBitCount,
                                                    std::uint32_t,
                                                    64U,
                                                    64U>
  {
  private:
    using base_class_type =
      al::crypto::stream::hash::hash_md_base<ResultBitCount,
                                             ResultBitCount,
                                             std::uint32_t,
                                             64U,
                                             64U>;

  public:
    ~hash_ripemd_base() override = default;

  protected:
    static constexpr auto K1  = static_cast<std::uint32_t>(UINT32_C(0x00000000));
    static constexpr auto K2  = static_cast<std::uint32_t>(UINT32_C(0x5A827999));
    static constexpr auto K3  = static_cast<std::uint32_t>(UINT32_C(0x6ED9EBA1));
    static constexpr auto K4  = static_cast<std::uint32_t>(UINT32_C(0x8F1BBCDC));
    static constexpr auto K5  = static_cast<std::uint32_t>(UINT32_C(0xA953FD4E));
    static constexpr auto KK1 = static_cast<std::uint32_t>(UINT32_C(0x50A28BE6));
    static constexpr auto KK2 = static_cast<std::uint32_t>(UINT32_C(0x5C4DD124));
    static constexpr auto KK3 = static_cast<std::uint32_t>(UINT32_C(0x6D703EF3));
    static constexpr auto KK4 = static_cast<std::uint32_t>(UINT32_C(0x7A6D76E9));
    static constexpr auto KK5 = static_cast<std::uint32_t>(UINT32_C(0x00000000));

    std::uint32_t aa { }; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes,misc-non-private-member-variables-in-classes)
    std::uint32_t bb { }; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes,misc-non-private-member-variables-in-classes)
    std::uint32_t cc { }; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes,misc-non-private-member-variables-in-classes)
    std::uint32_t dd { }; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes,misc-non-private-member-variables-in-classes)

    std::uint32_t aaa { }; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes,misc-non-private-member-variables-in-classes)
    std::uint32_t bbb { }; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes,misc-non-private-member-variables-in-classes)
    std::uint32_t ccc { }; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes,misc-non-private-member-variables-in-classes)
    std::uint32_t ddd { }; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes,misc-non-private-member-variables-in-classes)

    hash_ripemd_base() = default;

    hash_ripemd_base(const hash_ripemd_base& other) = default;
    hash_ripemd_base(hash_ripemd_base&& other) noexcept = default;

    auto operator=(const hash_ripemd_base& other) -> hash_ripemd_base& = default;
    auto operator=(hash_ripemd_base&& other) noexcept -> hash_ripemd_base& = default;

    template<const std::uint_fast8_t s,
             const std::uint32_t     k,
             typename round_function_type>
    static void roundx(      std::uint32_t& a,
                       const std::uint32_t& b,
                             std::uint32_t& c,
                       const std::uint32_t& d,
                       const std::uint32_t& x,
                       round_function_type round_function)
    {
      a =
        static_cast<std::uint32_t>
        (
          al::crypto::math::utils::rotl(a + static_cast<std::uint32_t>(round_function(b, c, d) + static_cast<std::uint32_t>(x + k)), s)
        );
    }

    // Basic functions F(), G(), H(), I().
    static auto F(const std::uint32_t x, const std::uint32_t y, const std::uint32_t z) -> std::uint32_t { return static_cast<std::uint32_t>(static_cast<std::uint32_t>(x ^ y) ^ z); }
    static auto G(const std::uint32_t x, const std::uint32_t y, const std::uint32_t z) -> std::uint32_t { return static_cast<std::uint32_t>(static_cast<std::uint32_t>(x & y) | (static_cast<std::uint32_t>(~x) & z)); }
    static auto H(const std::uint32_t x, const std::uint32_t y, const std::uint32_t z) -> std::uint32_t { return static_cast<std::uint32_t>(static_cast<std::uint32_t>(x | static_cast<std::uint32_t>(~y)) ^ z); }
    static auto I(const std::uint32_t x, const std::uint32_t y, const std::uint32_t z) -> std::uint32_t { return static_cast<std::uint32_t>(static_cast<std::uint32_t>(x & z) | static_cast<std::uint32_t>(y & static_cast<std::uint32_t>(~z))); }

    virtual void swap_left_right(std::uint32_t&, std::uint32_t&) const { } // NOLINT(hicpp-named-parameter,readability-named-parameter)
  };

  #if(__cplusplus >= 201703L)
  } // namespace al::crypto::stream::hash
  #else
  } // namespace hash
  } // namespace stream
  } // namespace crypto
  } // namespace al
  #endif

#endif // HASH_RIPEMD_BASE_2019_04_09_H