#include <SFML/System/Vector3.hpp>

#include <catch2/catch_template_test_macros.hpp>

#include <SystemUtil.hpp>
#include <type_traits>

TEMPLATE_TEST_CASE("[System] sf::Vector3", "", int, float)
{
    SECTION("Type traits")
    {
        STATIC_CHECK(std::is_trivially_copy_constructible_v<sf::Vector3<TestType>>);
        STATIC_CHECK(std::is_trivially_copy_assignable_v<sf::Vector3<TestType>>);
        STATIC_CHECK(std::is_trivially_move_constructible_v<sf::Vector3<TestType>>);
        STATIC_CHECK(std::is_trivially_move_assignable_v<sf::Vector3<TestType>>);
    }

    SECTION("Construction")
    {
        SECTION("Default constructor")
        {
            constexpr sf::Vector3<TestType> vector;
            STATIC_CHECK(vector.x == 0);
            STATIC_CHECK(vector.y == 0);
            STATIC_CHECK(vector.z == 0);
        }

        SECTION("(x, y, z) coordinate constructor")
        {
            constexpr sf::Vector3<TestType> vector(1, 2, 3);
            STATIC_CHECK(vector.x == 1);
            STATIC_CHECK(vector.y == 2);
            STATIC_CHECK(vector.z == 3);
        }

        SECTION("Conversion operator")
        {
            STATIC_CHECK(!std::is_convertible_v<sf::Vector3f, sf::Vector3i>);

            constexpr sf::Vector3f sourceVector(1.0f, 2.0f, 3.0f);
            constexpr sf::Vector3i vector(sourceVector);

            STATIC_CHECK(vector.x == static_cast<int>(sourceVector.x));
            STATIC_CHECK(vector.y == static_cast<int>(sourceVector.y));
            STATIC_CHECK(vector.z == static_cast<int>(sourceVector.z));
        }
    }

    SECTION("Unary operations")
    {
        SECTION("-vector")
        {
            constexpr sf::Vector3<TestType> vector(1, 2, 3);
            constexpr sf::Vector3<TestType> negatedVector = -vector;

            STATIC_CHECK(negatedVector.x == -1);
            STATIC_CHECK(negatedVector.y == -2);
            STATIC_CHECK(negatedVector.z == -3);
        }
    }

    SECTION("Arithmetic operations between two vectors")
    {
        sf::Vector3<TestType>           firstVector(2, 5, 6);
        constexpr sf::Vector3<TestType> secondVector(8, 3, 7);

        SECTION("vector += vector")
        {
            firstVector += secondVector;

            CHECK(firstVector.x == 10);
            CHECK(firstVector.y == 8);
            CHECK(firstVector.z == 13);
        }

        SECTION("vector -= vector")
        {
            firstVector -= secondVector;

            CHECK(firstVector.x == -6);
            CHECK(firstVector.y == 2);
            CHECK(firstVector.z == -1);
        }

        SECTION("vector + vector")
        {
            const sf::Vector3<TestType> result = firstVector + secondVector;

            CHECK(result.x == 10);
            CHECK(result.y == 8);
            CHECK(result.z == 13);
        }

        SECTION("vector - vector")
        {
            const sf::Vector3<TestType> result = firstVector - secondVector;

            CHECK(result.x == -6);
            CHECK(result.y == 2);
            CHECK(result.z == -1);
        }
    }

    SECTION("Arithmetic operations between vector and scalar value")
    {
        sf::Vector3<TestType> vector(26, 12, 6);
        constexpr TestType    scalar = 2;

        SECTION("vector * scalar")
        {
            const sf::Vector3<TestType> result = vector * scalar;

            CHECK(result.x == 52);
            CHECK(result.y == 24);
            CHECK(result.z == 12);
        }

        SECTION("scalar * vector")
        {
            const sf::Vector3<TestType> result = scalar * vector;

            CHECK(result.x == 52);
            CHECK(result.y == 24);
            CHECK(result.z == 12);
        }

        SECTION("vector *= scalar")
        {
            vector *= scalar;

            CHECK(vector.x == 52);
            CHECK(vector.y == 24);
            CHECK(vector.z == 12);
        }

        SECTION("vector / scalar")
        {
            const sf::Vector3<TestType> result = vector / scalar;

            CHECK(result.x == 13);
            CHECK(result.y == 6);
            CHECK(result.z == 3);
        }

        SECTION("vector /= scalar")
        {
            vector /= scalar;

            CHECK(vector.x == 13);
            CHECK(vector.y == 6);
            CHECK(vector.z == 3);
        }
    }

    SECTION("Comparison operations (two equal and one different vector)")
    {
        constexpr sf::Vector3<TestType> firstEqualVector(1, 5, 6);
        constexpr sf::Vector3<TestType> secondEqualVector(1, 5, 6);
        constexpr sf::Vector3<TestType> differentVector(6, 9, 7);

        SECTION("vector == vector")
        {
            STATIC_CHECK(firstEqualVector == secondEqualVector);
            STATIC_CHECK_FALSE(firstEqualVector == differentVector);
        }

        SECTION("vector != vector")
        {
            STATIC_CHECK(firstEqualVector != differentVector);
            STATIC_CHECK_FALSE(firstEqualVector != secondEqualVector);
        }
    }

    SECTION("Structured bindings")
    {
        sf::Vector3<TestType> vector(1, 2, 3); // NOLINT(misc-const-correctness)

        SECTION("destructure by value")
        {
            auto [x, y, z] = vector;

            CHECK(x == 1);
            CHECK(y == 2);
            CHECK(z == 3);

            STATIC_CHECK(std::is_same_v<decltype(x), decltype(vector.x)>);

            x = 3;

            CHECK(x == 3);
            CHECK(vector.x == 1);
        }

        SECTION("destructure by ref")
        {
            auto& [x, y, z] = vector;

            CHECK(x == 1);
            CHECK(y == 2);
            CHECK(z == 3);

            STATIC_CHECK(std::is_same_v<decltype(x), decltype(vector.x)>);

            x = 3;

            CHECK(x == 3);
            CHECK(vector.x == 3);
        }
    }

    SECTION("Length and normalization")
    {
        constexpr sf::Vector3f v(2.4f, 3.0f, 5.2f);

        CHECK(v.length() == Approx(6.46529f));
        CHECK(v.lengthSquared() == Approx(41.79997f));
        CHECK(v.normalized() == Approx(sf::Vector3f(0.37121f, 0.46401f, 0.80429f)));
    }

    SECTION("Products and quotients")
    {
        constexpr sf::Vector3f v(2.4f, 3.0f, 5.2f);
        constexpr sf::Vector3f w(-0.7f, -2.2f, -4.8f);

        CHECK(v.dot(w) == Approx(-33.24f));
        CHECK(w.dot(v) == Approx(-33.24f));

        CHECK(v.cross(w) == Approx(sf::Vector3f(-2.96f, 7.88f, -3.18f)));
        CHECK(w.cross(v) == Approx(sf::Vector3f(2.96f, -7.88f, 3.18f)));

        CHECK(v.componentWiseMul(w) == Approx(sf::Vector3f(-1.68f, -6.6f, -24.96f)));
        CHECK(w.componentWiseMul(v) == Approx(sf::Vector3f(-1.68f, -6.6f, -24.96f)));
        CHECK(v.componentWiseDiv(w) == Approx(sf::Vector3f(-3.428571f, -1.363636f, -1.0833333f)));
        CHECK(w.componentWiseDiv(v) == Approx(sf::Vector3f(-0.291666f, -0.733333f, -0.9230769f)));
    }
}
