#include <stdx/ct_string.hpp>
#include <stdx/utility.hpp>

#include <catch2/catch_test_macros.hpp>

#include <iterator>
#include <string_view>
#include <type_traits>

namespace {
template <typename T, T...> struct string_constant {};
} // namespace

TEST_CASE("construction", "[ct_string]") {
    [[maybe_unused]] constexpr auto s = stdx::ct_string{"ABC"};
}

TEST_CASE("UDL", "[ct_string]") {
    using namespace stdx::ct_string_literals;
    [[maybe_unused]] constexpr auto s = "ABC"_cts;
}

TEST_CASE("empty", "[ct_string]") {
    constexpr auto s1 = stdx::ct_string{""};
    STATIC_REQUIRE(s1.empty());
    constexpr auto s2 = stdx::ct_string{"A"};
    STATIC_REQUIRE(not s2.empty());
}

TEST_CASE("size", "[ct_string]") {
    constexpr auto s = stdx::ct_string{"ABC"};
    STATIC_REQUIRE(s.size() == 3u);
    STATIC_REQUIRE(not s.empty());
}

TEST_CASE("equality", "[ct_string]") {
    constexpr auto s1 = stdx::ct_string{"ABC"};
    constexpr auto s2 = stdx::ct_string{"ABC"};
    constexpr auto s3 = stdx::ct_string{"ABD"};
    STATIC_REQUIRE(s1 == s2);
    STATIC_REQUIRE(s1 != s3);
}

TEST_CASE("explicit length construction", "[ct_string]") {
    constexpr auto s = stdx::ct_string<3u>{"ABC", 2};
    STATIC_REQUIRE(s == stdx::ct_string{"AB"});
}

TEST_CASE("from type", "[ct_string]") {
    using T = string_constant<char, 'A', 'B', 'C'>;
    constexpr auto s = stdx::ct_string_from_type(T{});
    STATIC_REQUIRE(s == stdx::ct_string{"ABC"});
}

TEST_CASE("to type", "[ct_string]") {
    constexpr auto s = stdx::ct_string{"ABC"};
    constexpr auto sc = stdx::ct_string_to_type<s, string_constant>();
    STATIC_REQUIRE(std::is_same_v<decltype(sc),
                                  string_constant<char, 'A', 'B', 'C'> const>);
}

TEST_CASE("to type_t", "[ct_string]") {
    constexpr auto s = stdx::ct_string{"ABC"};
    using sc = stdx::ct_string_to_type_t<s, string_constant>;
    STATIC_REQUIRE(std::is_same_v<sc, string_constant<char, 'A', 'B', 'C'>>);
}

TEST_CASE("to string_view", "[ct_string]") {
    constexpr auto s = stdx::ct_string{"ABC"};
    auto const sv = static_cast<std::string_view>(s);
    CHECK(sv == "ABC");
}

TEST_CASE("string split (character present)", "[ct_string]") {
    constexpr auto s = stdx::ct_string{"A.B"};
    constexpr auto p = stdx::split<s, '.'>();
    STATIC_REQUIRE(p.first == stdx::ct_string{"A"});
    STATIC_REQUIRE(p.second == stdx::ct_string{"B"});
}

TEST_CASE("string split (character not present)", "[ct_string]") {
    constexpr auto s = stdx::ct_string{"A"};
    constexpr auto p = stdx::split<s, '.'>();
    STATIC_REQUIRE(p.first == stdx::ct_string{"A"});
    STATIC_REQUIRE(p.second.empty());
}

TEST_CASE("string concat (lhs empty)", "[ct_string]") {
    constexpr auto s1 = stdx::ct_string{""};
    constexpr auto s2 = stdx::ct_string{"def"};
    STATIC_REQUIRE(s1 + s2 == stdx::ct_string{"def"});
}

TEST_CASE("string concat (rhs empty)", "[ct_string]") {
    constexpr auto s1 = stdx::ct_string{"abc"};
    constexpr auto s2 = stdx::ct_string{""};
    STATIC_REQUIRE(s1 + s2 == stdx::ct_string{"abc"});
}

TEST_CASE("string concat", "[ct_string]") {
    constexpr auto s1 = stdx::ct_string{"abc"};
    constexpr auto s2 = stdx::ct_string{"def"};
    STATIC_REQUIRE(s1 + s2 == stdx::ct_string{"abcdef"});
}

TEST_CASE("ct_string as iterable", "[ct_string]") {
    constexpr auto s = stdx::ct_string{"abc"};
    STATIC_REQUIRE(std::next(std::begin(s), std::size(s)) == std::end(s));

    auto it = std::cbegin(s);
    CHECK(*it++ == 'a');
    CHECK(*it++ == 'b');
    CHECK(*it++ == 'c');
    CHECK(it == std::cend(s));
}

TEST_CASE("ct_string as reverse iterable", "[ct_string]") {
    constexpr auto s = stdx::ct_string{"abc"};
    STATIC_REQUIRE(std::next(std::rbegin(s), std::size(s)) == std::rend(s));

    auto it = std::crbegin(s);
    CHECK(*it++ == 'c');
    CHECK(*it++ == 'b');
    CHECK(*it++ == 'a');
    CHECK(it == std::crend(s));
}

namespace {
template <stdx::ct_string S> constexpr auto to_cx_value() {
    return CX_VALUE(S);
}
} // namespace

TEST_CASE("template argument as CX_VALUE", "[ct_string]") {
    using namespace stdx::ct_string_literals;
    constexpr auto s = to_cx_value<"Hello">();
    STATIC_REQUIRE(s() == "Hello"_cts);
}

TEST_CASE("wrap ct_string in type", "[ct_string]") {
    using namespace stdx::ct_string_literals;
    using S = stdx::cts_t<"Hello">;
    STATIC_REQUIRE(S::value == "Hello"_cts);
}

TEST_CASE("ct (ct_string)", "[ct_string]") {
    using namespace stdx::ct_string_literals;
    constexpr auto v1 = stdx::ct<"Hello">();
    STATIC_REQUIRE(v1 == "Hello"_ctst);
    constexpr auto v2 = stdx::ct<"Hello"_cts>();
    STATIC_REQUIRE(v2 == "Hello"_ctst);
}

namespace {
template <stdx::ct_string> constexpr auto conversion_success = true;
} // namespace

TEST_CASE("cts_t can implicitly convert to ct_string", "[ct_string]") {
    using namespace stdx::ct_string_literals;
    STATIC_REQUIRE(conversion_success<"Hello"_ctst>);
}

TEST_CASE("operator+ works to concat cts_t and ct_string", "[ct_string]") {
    using namespace stdx::ct_string_literals;
    STATIC_REQUIRE("Hello"_ctst + " world"_cts == "Hello world"_cts);
    STATIC_REQUIRE("Hello"_cts + " world"_ctst == "Hello world"_cts);
}

TEST_CASE("is_ct (ct_string)", "[ct_string]") {
    using namespace stdx::ct_string_literals;
    constexpr auto v1 = stdx::ct<"Hello">();
    STATIC_REQUIRE(stdx::is_ct_v<decltype(v1)>);
}

TEST_CASE("CT_WRAP", "[ct_string]") {
    using namespace stdx::ct_string_literals;
    auto x1 = "hello"_cts;
    STATIC_REQUIRE(std::is_same_v<decltype(CT_WRAP(x1)), stdx::ct_string<6>>);
    CHECK(CT_WRAP(x1) == "hello"_cts);

    auto x2 = "hello"_ctst;
    STATIC_REQUIRE(std::is_same_v<decltype(CT_WRAP(x2)), stdx::cts_t<"hello">>);
    STATIC_REQUIRE(CT_WRAP(x2) == "hello"_ctst);

    constexpr static auto x3 = "hello"_cts;
    STATIC_REQUIRE(std::is_same_v<decltype(CT_WRAP(x3)), stdx::cts_t<"hello">>);
    STATIC_REQUIRE(CT_WRAP(x3) == "hello"_ctst);

    []<stdx::ct_string X>() {
        STATIC_REQUIRE(
            std::is_same_v<decltype(CT_WRAP(X)), stdx::cts_t<"hello">>);
        STATIC_REQUIRE(CT_WRAP(X) == "hello"_ctst);
    }.template operator()<"hello">();
}