#pragma once

#include <stdx/concepts.hpp>
#include <stdx/type_traits.hpp>
#include <stdx/utility.hpp>

#include <array>
#include <climits>
#include <cstdint>
#include <limits>
#include <type_traits>

#if __has_include(<bit>)
#include <bit>
#endif

// NOLINTBEGIN(modernize-use-constraints)

namespace stdx {
inline namespace v1 {

// endian

#if __cpp_lib_endian < 201907L
// NOLINTNEXTLINE(performance-enum-size)
enum struct endian : underlying_type_t<decltype(__BYTE_ORDER__)> {
    little = __ORDER_LITTLE_ENDIAN__,
    big = __ORDER_BIG_ENDIAN__,
    native = __BYTE_ORDER__
};
#else
using endian = std::endian;
#endif

// bit_cast

#if __cpp_lib_bit_cast < 201806L
template <typename To, typename From>
[[nodiscard]] constexpr auto bit_cast(From &&from) noexcept -> To {
    return __builtin_bit_cast(To, from);
}
#else
using std::bit_cast;
#endif

// byteswap

#if __cpp_lib_byteswap < 202110L
template <typename T>
[[nodiscard]] constexpr auto
byteswap(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, T> {
    if constexpr (sizeof(T) == sizeof(std::uint16_t)) {
        return __builtin_bswap16(x);
    } else if constexpr (sizeof(T) == sizeof(std::uint32_t)) {
        return __builtin_bswap32(x);
    } else if constexpr (sizeof(T) == sizeof(std::uint64_t)) {
        return __builtin_bswap64(x);
    } else {
        return x;
    }
}
#else
using std::byteswap;
#endif

// bit ops

#if __cpp_lib_bitops < 201907L
template <typename T>
[[nodiscard]] constexpr auto
countl_zero(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, int> {
    if (x == 0) {
        return std::numeric_limits<T>::digits;
    }
    if constexpr (sizeof(T) == sizeof(unsigned int)) {
        return __builtin_clz(x);
    } else if constexpr (sizeof(T) ==
                         sizeof(unsigned long)) { // NOLINT(google-runtime-int)
        return __builtin_clzl(x);
    } else if constexpr (
        sizeof(T) == sizeof(unsigned long long)) { // NOLINT(google-runtime-int)
        return __builtin_clzll(x);
    } else {
        return __builtin_clzll(x) + std::numeric_limits<T>::digits -
               std::numeric_limits<
                   unsigned long long>::digits; // NOLINT(google-runtime-int)
    }
}

template <typename T>
[[nodiscard]] constexpr auto
countr_zero(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, int> {
    if (x == 0) {
        return std::numeric_limits<T>::digits;
    }
    if constexpr (sizeof(T) == sizeof(unsigned int)) {
        return __builtin_ctz(x);
    } else if constexpr (sizeof(T) ==
                         sizeof(unsigned long)) { // NOLINT(google-runtime-int)
        return __builtin_ctzl(x);
    } else {
        return __builtin_ctzll(x);
    }
}

template <typename T>
[[nodiscard]] constexpr auto
countl_one(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, int> {
    return countl_zero(T(~x));
}

template <typename T>
[[nodiscard]] constexpr auto
countr_one(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, int> {
    return countr_zero(T(~x));
}

template <typename T>
[[nodiscard]] constexpr auto
popcount(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, int> {
    if constexpr (sizeof(T) <= sizeof(unsigned int)) {
        return __builtin_popcount(x);
    } else if constexpr (sizeof(T) <=
                         sizeof(unsigned long)) { // NOLINT(google-runtime-int)
        return __builtin_popcountl(x);
    } else {
        return __builtin_popcountll(x);
    }
}

namespace detail {
template <typename T>
[[nodiscard]] constexpr auto
rotl(T x, T s) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, T> {
#ifdef __clang__
    if constexpr (sizeof(T) == sizeof(std::uint8_t)) {
        return __builtin_rotateleft8(x, s);
    } else if constexpr (sizeof(T) == sizeof(std::uint16_t)) {
        return __builtin_rotateleft16(x, s);
    } else if constexpr (sizeof(T) == sizeof(std::uint32_t)) {
        return __builtin_rotateleft32(x, s);
    } else {
        return __builtin_rotateleft64(x, s);
    }
#else
    return static_cast<T>((x << s) |
                          (x >> (std::numeric_limits<T>::digits - s)));
#endif
}
template <typename T>
[[nodiscard]] constexpr auto
rotr(T x, T s) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, T> {
#ifdef __clang__
    if constexpr (sizeof(T) == sizeof(std::uint8_t)) {
        return __builtin_rotateright8(x, s);
    } else if constexpr (sizeof(T) == sizeof(std::uint16_t)) {
        return __builtin_rotateright16(x, s);
    } else if constexpr (sizeof(T) == sizeof(std::uint32_t)) {
        return __builtin_rotateright32(x, s);
    } else {
        return __builtin_rotateright64(x, s);
    }
#else
    return static_cast<T>((x >> s) |
                          (x << (std::numeric_limits<T>::digits - s)));
#endif
}
} // namespace detail

template <typename T>
[[nodiscard]] constexpr auto
rotl(T x, int s) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, T> {
    if (s == 0) {
        return x;
    }
    if (s < 0) {
        return detail::rotr(x, T(-s));
    }
    return detail::rotl(x, T(s));
}

template <typename T>
[[nodiscard]] constexpr auto
rotr(T x, int s) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, T> {
    if (s == 0) {
        return x;
    }
    if (s < 0) {
        return detail::rotl(x, T(-s));
    }
    return detail::rotr(x, T(s));
}
#else
using std::countl_one;
using std::countl_zero;
using std::countr_one;
using std::countr_zero;
using std::popcount;
using std::rotl;
using std::rotr;
#endif

// pow2

#if __cpp_lib_int_pow2 < 202002L
template <typename T>
[[nodiscard]] constexpr auto
has_single_bit(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, bool> {
    return x and not(x & (x - 1));
}

template <typename T>
[[nodiscard]] constexpr auto
bit_width(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, int> {
    return std::numeric_limits<T>::digits - countl_zero(x);
}

template <typename T>
[[nodiscard]] constexpr auto
bit_ceil(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, T> {
    if (x <= 1U) {
        return 1U;
    }
    return T(1U << bit_width(x));
}

template <typename T>
[[nodiscard]] constexpr auto
bit_floor(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, T> {
    if (x == 0) {
        return x;
    }
    return T(1U << (bit_width(x) - 1));
}
#else
using std::bit_ceil;
using std::bit_floor;
using std::bit_width;
using std::has_single_bit;
#endif

template <typename T>
[[nodiscard]] constexpr auto
to_le(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, T> {
    if constexpr (stdx::endian::native == stdx::endian::big) {
        return byteswap(x);
    } else {
        return x;
    }
}

template <typename T>
[[nodiscard]] constexpr auto
to_be(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, T> {
    if constexpr (stdx::endian::native == stdx::endian::little) {
        return byteswap(x);
    } else {
        return x;
    }
}

template <typename T>
[[nodiscard]] constexpr auto
from_le(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, T> {
    if constexpr (stdx::endian::native == stdx::endian::big) {
        return byteswap(x);
    } else {
        return x;
    }
}

template <typename T>
[[nodiscard]] constexpr auto
from_be(T x) noexcept -> std::enable_if_t<std::is_unsigned_v<T>, T> {
    if constexpr (stdx::endian::native == stdx::endian::little) {
        return byteswap(x);
    } else {
        return x;
    }
}

template <typename To>
constexpr auto bit_pack = [](auto... args) {
    static_assert(stdx::always_false_v<To, decltype(args)...>,
                  "bit_pack is undefined for those types");
};

template <>
constexpr inline auto bit_pack<std::uint16_t> =
    [](std::uint8_t hi, std::uint8_t lo) -> std::uint16_t {
    return static_cast<std::uint16_t>((static_cast<std::uint32_t>(hi) << 8u) |
                                      lo);
};

template <>
constexpr inline auto bit_pack<std::uint32_t> =
    stdx::overload{[](std::uint16_t hi, std::uint16_t lo) -> std::uint32_t {
                       return (static_cast<std::uint32_t>(hi) << 16u) | lo;
                   },
                   [](std::uint8_t b0, std::uint8_t b1, std::uint8_t b2,
                      std::uint8_t b3) -> std::uint32_t {
                       return (static_cast<std::uint32_t>(b0) << 24u) |
                              (static_cast<std::uint32_t>(b1) << 16u) |
                              (static_cast<std::uint32_t>(b2) << 8u) | b3;
                   }};

template <>
constexpr inline auto bit_pack<std::uint64_t> =
    stdx::overload{[](std::uint32_t hi, std::uint32_t lo) -> std::uint64_t {
                       return (static_cast<std::uint64_t>(hi) << 32u) | lo;
                   },
                   [](std::uint16_t w0, std::uint16_t w1, std::uint16_t w2,
                      std::uint16_t w3) -> std::uint64_t {
                       return (static_cast<std::uint64_t>(w0) << 48u) |
                              (static_cast<std::uint64_t>(w1) << 32u) |
                              (static_cast<std::uint64_t>(w2) << 16u) | w3;
                   },
                   [](std::uint8_t b0, std::uint8_t b1, std::uint8_t b2,
                      std::uint8_t b3, std::uint8_t b4, std::uint8_t b5,
                      std::uint8_t b6, std::uint8_t b7) -> std::uint64_t {
                       return (static_cast<std::uint64_t>(b0) << 56u) |
                              (static_cast<std::uint64_t>(b1) << 48u) |
                              (static_cast<std::uint64_t>(b2) << 40u) |
                              (static_cast<std::uint64_t>(b3) << 32u) |
                              (static_cast<std::uint64_t>(b4) << 24u) |
                              (static_cast<std::uint64_t>(b5) << 16u) |
                              (static_cast<std::uint64_t>(b6) << 8u) | b7;
                   }};

template <typename To, typename From> constexpr auto bit_unpack(From arg) {
    static_assert(unsigned_integral<To> and unsigned_integral<From>,
                  "bit_unpack is undefined for those types");

    constexpr auto sz = sized<From>{1}.template in<To>();
    auto r = bit_cast<std::array<To, sz>>(to_be(arg));
    for (auto &elem : r) {
        elem = from_be(elem);
    }
    return r;
}

namespace detail {
template <typename T, std::size_t Bit>
constexpr auto
mask_bits() -> std::enable_if_t<Bit <= std::numeric_limits<T>::digits, T> {
    if constexpr (Bit == std::numeric_limits<T>::digits) {
        return std::numeric_limits<T>::max();
    } else {
        return static_cast<T>(T{1} << Bit) - T{1};
    }
}

template <typename T> constexpr auto mask_bits(std::size_t Bit) -> T {
    if (Bit == std::numeric_limits<T>::digits) {
        return std::numeric_limits<T>::max();
    }
    return static_cast<T>(T{1} << Bit) - T{1};
}
} // namespace detail

template <typename T, std::size_t Msb = std::numeric_limits<T>::digits - 1,
          std::size_t Lsb = 0>
[[nodiscard]] constexpr auto bit_mask() noexcept
    -> std::enable_if_t<std::is_unsigned_v<T> and Msb >= Lsb, T> {
    static_assert(Msb < std::numeric_limits<T>::digits);
    return detail::mask_bits<T, Msb + 1>() - detail::mask_bits<T, Lsb>();
}

template <typename T>
[[nodiscard]] constexpr auto bit_mask(std::size_t Msb,
                                      std::size_t Lsb = 0) noexcept
    -> std::enable_if_t<std::is_unsigned_v<T>, T> {
    return detail::mask_bits<T>(Msb + 1) - detail::mask_bits<T>(Lsb);
}

template <typename T> constexpr auto bit_size() -> std::size_t {
    return sizeof(T) * CHAR_BIT;
}

template <std::size_t N> CONSTEVAL auto smallest_uint() {
    if constexpr (N <= std::numeric_limits<std::uint8_t>::digits) {
        return std::uint8_t{};
    } else if constexpr (N <= std::numeric_limits<std::uint16_t>::digits) {
        return std::uint16_t{};
    } else if constexpr (N <= std::numeric_limits<std::uint32_t>::digits) {
        return std::uint32_t{};
    } else {
        return std::uint64_t{};
    }
}

template <std::size_t N> using smallest_uint_t = decltype(smallest_uint<N>());
} // namespace v1
} // namespace stdx

// NOLINTEND(modernize-use-constraints)