#include <stdx/utility.hpp>

#include <catch2/catch_template_test_macros.hpp>
#include <catch2/catch_test_macros.hpp>

#include <array>
#include <cstdint>
#include <string_view>
#include <type_traits>

TEST_CASE("forward_like", "[utility]") {
    STATIC_REQUIRE(std::is_same_v<stdx::forward_like_t<int, float>, float &&>);
    STATIC_REQUIRE(
        std::is_same_v<stdx::forward_like_t<int const, float>, float const &&>);

    STATIC_REQUIRE(
        std::is_same_v<stdx::forward_like_t<int &&, float>, float &&>);
    STATIC_REQUIRE(std::is_same_v<stdx::forward_like_t<int const &&, float>,
                                  float const &&>);

    STATIC_REQUIRE(std::is_same_v<stdx::forward_like_t<int &, float>, float &>);
    STATIC_REQUIRE(std::is_same_v<stdx::forward_like_t<int const &, float>,
                                  float const &>);
}

TEST_CASE("as_unsigned (changed)", "[utility]") {
    STATIC_REQUIRE(std::is_same_v<decltype(stdx::as_unsigned(std::int8_t{})),
                                  std::uint8_t>);
    STATIC_REQUIRE(std::is_same_v<decltype(stdx::as_unsigned(std::int16_t{})),
                                  std::uint16_t>);
    STATIC_REQUIRE(std::is_same_v<decltype(stdx::as_unsigned(std::int32_t{})),
                                  std::uint32_t>);
    STATIC_REQUIRE(std::is_same_v<decltype(stdx::as_unsigned(std::int64_t{})),
                                  std::uint64_t>);
    STATIC_REQUIRE(stdx::as_unsigned(std::int8_t{17}) == 17);
}

TEMPLATE_TEST_CASE("as_unsigned (unchanged)", "[utility]", std::uint8_t,
                   std::uint16_t, std::uint32_t, std::uint64_t) {
    STATIC_REQUIRE(
        std::is_same_v<decltype(stdx::as_unsigned(TestType{})), TestType>);
    STATIC_REQUIRE(stdx::as_unsigned(TestType{17}) == 17);
}

TEST_CASE("as_signed (changed)", "[utility]") {
    STATIC_REQUIRE(
        std::is_same_v<decltype(stdx::as_signed(std::uint8_t{})), std::int8_t>);
    STATIC_REQUIRE(std::is_same_v<decltype(stdx::as_signed(std::uint16_t{})),
                                  std::int16_t>);
    STATIC_REQUIRE(std::is_same_v<decltype(stdx::as_signed(std::uint32_t{})),
                                  std::int32_t>);
    STATIC_REQUIRE(std::is_same_v<decltype(stdx::as_signed(std::uint64_t{})),
                                  std::int64_t>);
    STATIC_REQUIRE(stdx::as_signed(std::uint8_t{17}) == 17);
}

TEMPLATE_TEST_CASE("as_signed (unchanged)", "[utility]", std::int8_t,
                   std::int16_t, std::int32_t, std::int64_t) {
    STATIC_REQUIRE(
        std::is_same_v<decltype(stdx::as_signed(TestType{})), TestType>);
    STATIC_REQUIRE(stdx::as_signed(TestType{17}) == 17);
}

TEMPLATE_TEST_CASE("sized<T> in (uint8_t zero/one/two case)", "[utility]",
                   std::uint16_t, std::uint32_t, std::uint64_t) {
    STATIC_REQUIRE(stdx::sized<std::uint8_t>{0}.in<TestType>() == 0);
    STATIC_REQUIRE(stdx::sized<std::uint8_t>{1}.in<TestType>() == 1);
    STATIC_REQUIRE(stdx::sized<std::uint8_t>{2}.in<TestType>() == 1);
}

TEMPLATE_TEST_CASE("sized<T> in (uint16_t zero/one/two case)", "[utility]",
                   std::uint32_t, std::uint64_t) {
    STATIC_REQUIRE(stdx::sized<std::uint16_t>{0}.in<TestType>() == 0);
    STATIC_REQUIRE(stdx::sized<std::uint16_t>{1}.in<TestType>() == 1);
    STATIC_REQUIRE(stdx::sized<std::uint16_t>{2}.in<TestType>() == 1);
}

TEMPLATE_TEST_CASE("sized<T> in (uint32_t zero/one/two case)", "[utility]",
                   std::uint64_t) {
    STATIC_REQUIRE(stdx::sized<std::uint32_t>{0}.in<TestType>() == 0);
    STATIC_REQUIRE(stdx::sized<std::uint32_t>{1}.in<TestType>() == 1);
    STATIC_REQUIRE(stdx::sized<std::uint32_t>{2}.in<TestType>() == 1);
}

TEMPLATE_TEST_CASE("sized<T> in (same type)", "[utility]", std::uint8_t,
                   std::uint16_t, std::uint32_t, std::uint64_t) {
    STATIC_REQUIRE(stdx::sized<TestType>{3}.template in<TestType>() == 3);
}

TEMPLATE_TEST_CASE("sized<T> in (exact case)", "[utility]", std::uint16_t,
                   std::uint32_t, std::uint64_t) {
    STATIC_REQUIRE(
        stdx::sized<std::uint8_t>{3 * sizeof(TestType)}.in<TestType>() == 3);
}

TEMPLATE_TEST_CASE("sized<T> in defaults to bytes", "[utility]", std::uint16_t,
                   std::uint32_t, std::uint64_t) {
    STATIC_REQUIRE(stdx::sized<TestType>{3}.in() == 3 * sizeof(TestType));
}

TEMPLATE_TEST_CASE("sized<T> in (downsize)", "[utility]", std::uint8_t,
                   std::uint16_t, std::uint32_t) {
    STATIC_REQUIRE(stdx::sized<std::uint64_t>{3}.in<TestType>() ==
                   3 * sizeof(std::uint64_t) / sizeof(TestType));
}

TEST_CASE("sized<T> in (upsize uint8_t)", "[utility]") {
    STATIC_REQUIRE(stdx::sized<std::uint8_t>{3}.in<std::uint16_t>() == 2);
    STATIC_REQUIRE(stdx::sized<std::uint8_t>{17}.in<std::uint16_t>() == 9);

    STATIC_REQUIRE(stdx::sized<std::uint8_t>{5}.in<std::uint32_t>() == 2);
    STATIC_REQUIRE(stdx::sized<std::uint8_t>{17}.in<std::uint32_t>() == 5);

    STATIC_REQUIRE(stdx::sized<std::uint8_t>{9}.in<std::uint64_t>() == 2);
    STATIC_REQUIRE(stdx::sized<std::uint8_t>{17}.in<std::uint64_t>() == 3);
}

TEST_CASE("sized<T> in (upsize uint16_t)", "[utility]") {
    STATIC_REQUIRE(stdx::sized<std::uint16_t>{3}.in<std::uint32_t>() == 2);
    STATIC_REQUIRE(stdx::sized<std::uint16_t>{17}.in<std::uint32_t>() == 9);

    STATIC_REQUIRE(stdx::sized<std::uint16_t>{5}.in<std::uint64_t>() == 2);
    STATIC_REQUIRE(stdx::sized<std::uint16_t>{17}.in<std::uint64_t>() == 5);
}

TEST_CASE("sized<T> in (upsize uint32_t)", "[utility]") {
    STATIC_REQUIRE(stdx::sized<std::uint32_t>{3}.in<std::uint64_t>() == 2);
    STATIC_REQUIRE(stdx::sized<std::uint32_t>{17}.in<std::uint64_t>() == 9);
}

TEST_CASE("sized<T> aliases", "[utility]") {
    STATIC_REQUIRE(stdx::sized8{1}.in<std::uint64_t>() == 1);
    STATIC_REQUIRE(stdx::sized16{1}.in<std::uint64_t>() == 1);
    STATIC_REQUIRE(stdx::sized32{1}.in<std::uint64_t>() == 1);
    STATIC_REQUIRE(stdx::sized64{1}.in<std::uint64_t>() == 1);
}

TEST_CASE("sized<T> in (downsize not divisible)", "[utility]") {
    using T = std::array<char, 3>;
    STATIC_REQUIRE(sizeof(T) == 3);
    STATIC_REQUIRE(stdx::sized<std::uint32_t>{2}.in<T>() == 3);
}

TEST_CASE("sized<T> in (upsize not divisible)", "[utility]") {
    using T = std::array<char, 3>;
    STATIC_REQUIRE(sizeof(T) == 3);
    STATIC_REQUIRE(stdx::sized<T>{3}.in<std::uint32_t>() == 3);
}

TEST_CASE("sized<T> in (downsize, mod > 1)", "[utility]") {
    using T = std::array<char, 6>;
    using U = std::array<char, 4>;
    STATIC_REQUIRE(stdx::sized<T>{1}.in<U>() == 2);
}

TEST_CASE("sized<T> in (upsize, mod > 1)", "[utility]") {
    using T = std::array<char, 6>;
    using U = std::array<char, 4>;
    STATIC_REQUIRE(stdx::sized<U>{2}.in<T>() == 2);
}

TEST_CASE("terse size conversion with UDLs", "[utility]") {
    using namespace stdx::literals;
    STATIC_REQUIRE(1_z8->z8 == 1);
    STATIC_REQUIRE(2_z8->z16 == 1);
    STATIC_REQUIRE(4_z8->z32 == 1);
    STATIC_REQUIRE(8_z8->z64 == 1);

    STATIC_REQUIRE(1_z16->z8 == 2);
    STATIC_REQUIRE(1_z32->z8 == 4);
    STATIC_REQUIRE(1_z64->z8 == 8);

    STATIC_REQUIRE(1_z64->in<std::uint16_t> == 4);
    STATIC_REQUIRE(1_z64->in<std::uint32_t> == 2);
}

TEST_CASE("CX_VALUE structural value", "[utility]") {
    auto x = CX_VALUE(42);
    STATIC_REQUIRE(x() == 42);
    auto y = CX_VALUE(17, 42);
    STATIC_REQUIRE(y() == 42);
}

TEST_CASE("CX_VALUE non-structural value", "[utility]") {
    auto x = CX_VALUE(std::string_view{"Hello"});
    STATIC_REQUIRE(x() == std::string_view{"Hello"});
}

TEST_CASE("CX_VALUE type", "[utility]") {
    auto x = CX_VALUE(int);
    STATIC_REQUIRE(std::is_same_v<decltype(x()), stdx::type_identity<int>>);
    auto y = CX_VALUE(std::pair<int, int>);
    STATIC_REQUIRE(std::is_same_v<decltype(y()),
                                  stdx::type_identity<std::pair<int, int>>>);
}

namespace {
template <std::size_t S> constexpr auto cx_value_test_nttp() {
    return CX_VALUE(S);
}

template <typename T> constexpr auto cx_value_test_type() {
    return CX_VALUE(T);
}
} // namespace

TEST_CASE("CX_VALUE on NTTP", "[utility]") {
    auto x = cx_value_test_nttp<42>();
    STATIC_REQUIRE(x() == 42);
}

TEST_CASE("CX_VALUE on type template argument", "[utility]") {
    auto x = cx_value_test_type<int>();
    STATIC_REQUIRE(std::is_same_v<decltype(x()), stdx::type_identity<int>>);
}

namespace {
struct alignas(16) over_aligned {};
} // namespace

TEST_CASE("is_aligned_with (integral)", "[utility]") {
    STATIC_REQUIRE(stdx::is_aligned_with<std::uint8_t>(0b1111));

    STATIC_REQUIRE(stdx::is_aligned_with<std::uint16_t>(0b1110));
    STATIC_REQUIRE(not stdx::is_aligned_with<std::uint16_t>(0b1111));

    STATIC_REQUIRE(stdx::is_aligned_with<std::uint32_t>(0b1100));
    STATIC_REQUIRE(not stdx::is_aligned_with<std::uint32_t>(0b1110));

    STATIC_REQUIRE(stdx::is_aligned_with<std::uint64_t>(0b1000));
    STATIC_REQUIRE(not stdx::is_aligned_with<std::uint64_t>(0b1100));

    STATIC_REQUIRE(stdx::is_aligned_with<over_aligned>(0b1'0000));
    STATIC_REQUIRE(not stdx::is_aligned_with<over_aligned>(0b1000));
}

TEST_CASE("is_aligned_with (pointer)", "[utility]") {
    std::int32_t i;
    auto p = &i;
    auto pc = reinterpret_cast<std::int8_t *>(p);
    ++pc;

    CHECK(stdx::is_aligned_with<std::uint8_t>(pc));
    CHECK(not stdx::is_aligned_with<std::uint16_t>(pc));

    CHECK(stdx::is_aligned_with<std::uint8_t>(p));
    CHECK(stdx::is_aligned_with<std::uint16_t>(p));
    CHECK(stdx::is_aligned_with<std::uint32_t>(p));
}

#if __cplusplus >= 202002L

TEST_CASE("ct (integral)", "[utility]") {
    constexpr auto vs = stdx::ct<42>();
    STATIC_REQUIRE(
        std::is_same_v<decltype(vs), std::integral_constant<int, 42> const>);
    constexpr auto vu = stdx::ct<42u>();
    STATIC_REQUIRE(
        std::is_same_v<decltype(vu),
                       std::integral_constant<unsigned int, 42> const>);
}

TEST_CASE("ct (integral constant)", "[utility]") {
    constexpr auto vs = stdx::ct<std::integral_constant<int, 42>{}>();
    STATIC_REQUIRE(
        std::is_same_v<decltype(vs), std::integral_constant<int, 42> const>);
}

TEST_CASE("ct (bool)", "[utility]") {
    constexpr auto v = stdx::ct<true>();
    STATIC_REQUIRE(std::is_same_v<decltype(v), std::bool_constant<true> const>);
}

TEST_CASE("ct (char)", "[utility]") {
    constexpr auto v = stdx::ct<'A'>();
    STATIC_REQUIRE(
        std::is_same_v<decltype(v), std::integral_constant<char, 'A'> const>);
}

namespace {
enum struct E { A, B, C };
}

TEST_CASE("ct (enum)", "[utility]") {
    constexpr auto v = stdx::ct<E::A>();
    STATIC_REQUIRE(
        std::is_same_v<decltype(v), std::integral_constant<E, E::A> const>);
}

TEST_CASE("ct (type)", "[utility]") {
    constexpr auto v = stdx::ct<int>();
    STATIC_REQUIRE(std::is_same_v<decltype(v), stdx::type_identity<int> const>);
}

TEST_CASE("is_ct", "[utility]") {
    constexpr auto x1 = stdx::ct<42>();
    STATIC_REQUIRE(stdx::is_ct_v<decltype(x1)>);
    constexpr auto x2 = stdx::ct<int>();
    STATIC_REQUIRE(stdx::is_ct_v<decltype(x2)>);
}

TEST_CASE("CT_WRAP", "[utility]") {
    auto x1 = 17;
    STATIC_REQUIRE(std::is_same_v<decltype(CT_WRAP(x1)), int>);
    CHECK(CT_WRAP(x1) == 17);

    auto x2 = stdx::ct<17>();
    STATIC_REQUIRE(
        std::is_same_v<decltype(CT_WRAP(x2)), std::integral_constant<int, 17>>);
    STATIC_REQUIRE(CT_WRAP(x2).value == 17);

    auto const x3 = 17;
    STATIC_REQUIRE(
        std::is_same_v<decltype(CT_WRAP(x3)), std::integral_constant<int, 17>>);
    STATIC_REQUIRE(CT_WRAP(x3).value == 17);

    constexpr static auto x4 = 17;
    STATIC_REQUIRE(
        std::is_same_v<decltype(CT_WRAP(x4)), std::integral_constant<int, 17>>);
    STATIC_REQUIRE(CT_WRAP(x4).value == 17);

    []<auto X>() {
        STATIC_REQUIRE(std::is_same_v<decltype(CT_WRAP(X)),
                                      std::integral_constant<int, 17>>);
        STATIC_REQUIRE(CT_WRAP(X).value == 17);
    }.template operator()<17>();
}

TEST_CASE("CX_WRAP integer runtime arg", "[utility]") {
    auto x = 17;
    STATIC_REQUIRE(std::is_same_v<decltype(CX_WRAP(x)), int>);
    CHECK(CX_WRAP(x) == 17);
}

TEST_CASE("CX_WRAP string_view runtime arg", "[utility]") {
    auto x = std::string_view{"hello"};
    STATIC_REQUIRE(std::is_same_v<decltype(CX_WRAP(x)), std::string_view>);
    CHECK(CX_WRAP(x) == std::string_view{"hello"});
}

namespace {
auto at_init_time() { return 17; }
auto nc_var = at_init_time();
} // namespace

TEST_CASE("CX_WRAP static runtime arg", "[utility]") {
    STATIC_REQUIRE(std::is_same_v<decltype(CX_WRAP(nc_var)), decltype(nc_var)>);
    CHECK(CX_WRAP(nc_var) == 17);
}

namespace {
constexpr auto at_compile_time() { return 17; }
constexpr auto c_var = at_compile_time();
} // namespace

TEST_CASE("CX_WRAP static constexpr arg", "[utility]") {
    STATIC_REQUIRE(stdx::is_cx_value_v<decltype(CX_WRAP(c_var))>);
    STATIC_REQUIRE(CX_WRAP(c_var)() == 17);
}

TEST_CASE("CX_WRAP const integral type", "[utility]") {
    auto const x = 17;
    STATIC_REQUIRE(stdx::is_cx_value_v<decltype(CX_WRAP(x))>);
    STATIC_REQUIRE(CX_WRAP(x)() == 17);
}

TEST_CASE("CX_WRAP constexpr integral type", "[utility]") {
    constexpr auto x = 17;
    STATIC_REQUIRE(stdx::is_cx_value_v<decltype(CX_WRAP(x))>);
    STATIC_REQUIRE(CX_WRAP(x)() == 17);
}

TEST_CASE("CX_WRAP constexpr non-structural type", "[utility]") {
    constexpr static auto x = std::string_view{"hello"};
    STATIC_REQUIRE(stdx::is_cx_value_v<decltype(CX_WRAP(x))>);
    STATIC_REQUIRE(CX_WRAP(x)() == std::string_view{"hello"});
}

TEST_CASE("CX_WRAP integer literal", "[utility]") {
    STATIC_REQUIRE(stdx::is_cx_value_v<decltype(CX_WRAP(17))>);
    STATIC_REQUIRE(CX_WRAP(17)() == 17);
}

TEST_CASE("CX_WRAP string literal", "[utility]") {
    STATIC_REQUIRE(stdx::is_cx_value_v<decltype(CX_WRAP("hello"))>);
    STATIC_REQUIRE(CX_WRAP("hello")() == std::string_view{"hello"});
}

TEST_CASE("CX_WRAP existing CX_VALUE", "[utility]") {
    auto x = CX_VALUE(17);
    STATIC_REQUIRE(stdx::is_cx_value_v<decltype(CX_WRAP(x))>);
    STATIC_REQUIRE(CX_WRAP(x)() == 17);
}

TEST_CASE("CX_WRAP template argument", "[utility]") {
    []<int x> {
        STATIC_REQUIRE(stdx::is_cx_value_v<decltype(CX_WRAP(x))>);
        STATIC_REQUIRE(CX_WRAP(x)() == 17);
    }.template operator()<17>();
}

TEST_CASE("CX_WRAP type argument", "[utility]") {
    STATIC_REQUIRE(
        std::is_same_v<decltype(CX_WRAP(int)), stdx::type_identity<int>>);
}

TEST_CASE("CX_WRAP empty type argument", "[utility]") {
    using X = std::integral_constant<int, 17>;
    STATIC_REQUIRE(
        std::is_same_v<decltype(CX_WRAP(X)), stdx::type_identity<X>>);
}

TEST_CASE("CX_WRAP integral_constant arg", "[utility]") {
    auto x = std::integral_constant<int, 17>{};
    STATIC_REQUIRE(std::is_same_v<decltype(CX_WRAP(x)), decltype(x)>);
    CHECK(CX_WRAP(x)() == 17);
}

#ifdef __clang__
namespace {
struct expression_test {
    auto f(int x) -> int { return x; }
};
} // namespace

TEST_CASE("CX_WRAP non-constexpr expression", "[utility]") {
    auto x = 17;
    STATIC_REQUIRE(
        std::is_same_v<decltype(CX_WRAP(expression_test{}.f(x))), int>);
    CHECK(CX_WRAP(expression_test{}.f(x)) == 17);
}
#endif

#endif

STDX_PRAGMA(diagnostic push)
#ifdef __clang__
STDX_PRAGMA(diagnostic ignored "-Wunknown-warning-option")
STDX_PRAGMA(diagnostic ignored "-Wc++26-extensions")
#endif
#if __cpp_structured_bindings >= 202411L
namespace {
template <std::size_t N> constexpr auto sum() {
    auto [... Is] = stdx::make_index_sequence<N>{};
    constexpr auto sum = (0 + ... + decltype(Is)::value);
    return sum;
}
} // namespace

TEST_CASE("destructurable integer_sequence", "[utility]") {
    STATIC_CHECK(sum<4>() == 6);
}
#endif
STDX_PRAGMA(diagnostic pop)