// =====================================================================================================================
//  fennec, a free and open source game engine
//  Copyright © 2025  Medusa Slockbower
//
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================


#ifndef TEST_VECTOR_H
#define TEST_VECTOR_H

#include <iostream>

#include <fennec/lang/types.h>
#include <fennec/math/vector.h>

#include "../test.h"

namespace fennec
{

namespace test
{

inline void fennec_test_vector()
{
	fennec_test_section(component_count);

	fennec_test_spacer(1);

	fennec_test_run((component_count_v<bool_t&>   == 1), true);
	fennec_test_run((component_count_v<int_t&>    == 1), true);
	fennec_test_run((component_count_v<uint_t&>   == 1), true);
	fennec_test_run((component_count_v<float_t&>  == 1), true);
	fennec_test_run((component_count_v<double_t&> == 1), true);

	fennec_test_spacer(1);

	fennec_test_run((component_count_v<const bool_t&>   == 1), true);
	fennec_test_run((component_count_v<const int_t&>    == 1), true);
	fennec_test_run((component_count_v<const uint_t&>   == 1), true);
	fennec_test_run((component_count_v<const float_t&>  == 1), true);
	fennec_test_run((component_count_v<const double_t&> == 1), true);

	fennec_test_spacer(1);

	fennec_test_run((component_count_v<volatile bool_t&>   == 1), true);
	fennec_test_run((component_count_v<volatile int_t&>    == 1), true);
	fennec_test_run((component_count_v<volatile uint_t&>   == 1), true);
	fennec_test_run((component_count_v<volatile float_t&>  == 1), true);
	fennec_test_run((component_count_v<volatile double_t&> == 1), true);

	fennec_test_spacer(1);

	fennec_test_run((component_count_v<const volatile bool_t&>   == 1), true);
	fennec_test_run((component_count_v<const volatile int_t&>    == 1), true);
	fennec_test_run((component_count_v<const volatile uint_t&>   == 1), true);
	fennec_test_run((component_count_v<const volatile float_t&>  == 1), true);
	fennec_test_run((component_count_v<const volatile double_t&> == 1), true);

	fennec_test_spacer(1);

	fennec_test_run((component_count_v<bvec2>        == 2), true);
	fennec_test_run((component_count_v<bvec3>        == 3), true);
	fennec_test_run((component_count_v<bvec4>        == 4), true);
	fennec_test_run((component_count_v<bvec2&>       == 2), true);
	fennec_test_run((component_count_v<bvec3&>       == 3), true);
	fennec_test_run((component_count_v<bvec4&>       == 4), true);
	fennec_test_run((component_count_v<bvec2&&>      == 2), true);
	fennec_test_run((component_count_v<bvec3&&>      == 3), true);
	fennec_test_run((component_count_v<bvec4&&>      == 4), true);
	fennec_test_run((component_count_v<const bvec2&> == 2), true);
	fennec_test_run((component_count_v<const bvec3&> == 3), true);
	fennec_test_run((component_count_v<const bvec4&> == 4), true);

	fennec_test_spacer(1);

	fennec_test_run((component_count_v<ivec2>        == 2), true);
	fennec_test_run((component_count_v<ivec3>        == 3), true);
	fennec_test_run((component_count_v<ivec4>        == 4), true);
	fennec_test_run((component_count_v<ivec2&>       == 2), true);
	fennec_test_run((component_count_v<ivec3&>       == 3), true);
	fennec_test_run((component_count_v<ivec4&>       == 4), true);
	fennec_test_run((component_count_v<ivec2&&>      == 2), true);
	fennec_test_run((component_count_v<ivec3&&>      == 3), true);
	fennec_test_run((component_count_v<ivec4&&>      == 4), true);
	fennec_test_run((component_count_v<const ivec2&> == 2), true);
	fennec_test_run((component_count_v<const ivec3&> == 3), true);
	fennec_test_run((component_count_v<const ivec4&> == 4), true);

	fennec_test_spacer(1);

	fennec_test_run((component_count_v<uvec2>        == 2), true);
	fennec_test_run((component_count_v<uvec3>        == 3), true);
	fennec_test_run((component_count_v<uvec4>        == 4), true);
	fennec_test_run((component_count_v<uvec2&>       == 2), true);
	fennec_test_run((component_count_v<uvec3&>       == 3), true);
	fennec_test_run((component_count_v<uvec4&>       == 4), true);
	fennec_test_run((component_count_v<uvec2&&>      == 2), true);
	fennec_test_run((component_count_v<uvec3&&>      == 3), true);
	fennec_test_run((component_count_v<uvec4&&>      == 4), true);
	fennec_test_run((component_count_v<const uvec2&> == 2), true);
	fennec_test_run((component_count_v<const uvec3&> == 3), true);
	fennec_test_run((component_count_v<const uvec4&> == 4), true);

	fennec_test_spacer(1);

	fennec_test_run((component_count_v<vec2>        == 2), true);
	fennec_test_run((component_count_v<vec3>        == 3), true);
	fennec_test_run((component_count_v<vec4>        == 4), true);
	fennec_test_run((component_count_v<vec2&>       == 2), true);
	fennec_test_run((component_count_v<vec3&>       == 3), true);
	fennec_test_run((component_count_v<vec4&>       == 4), true);
	fennec_test_run((component_count_v<vec2&&>      == 2), true);
	fennec_test_run((component_count_v<vec3&&>      == 3), true);
	fennec_test_run((component_count_v<vec4&&>      == 4), true);
	fennec_test_run((component_count_v<const vec2&> == 2), true);
	fennec_test_run((component_count_v<const vec3&> == 3), true);
	fennec_test_run((component_count_v<const vec4&> == 4), true);

	fennec_test_spacer(1);

	fennec_test_run((component_count_v<dvec2>        == 2), true);
	fennec_test_run((component_count_v<dvec3>        == 3), true);
	fennec_test_run((component_count_v<dvec4>        == 4), true);
	fennec_test_run((component_count_v<dvec2&>       == 2), true);
	fennec_test_run((component_count_v<dvec3&>       == 3), true);
	fennec_test_run((component_count_v<dvec4&>       == 4), true);
	fennec_test_run((component_count_v<dvec2&&>      == 2), true);
	fennec_test_run((component_count_v<dvec3&&>      == 3), true);
	fennec_test_run((component_count_v<dvec4&&>      == 4), true);
	fennec_test_run((component_count_v<const dvec2&> == 2), true);
	fennec_test_run((component_count_v<const dvec3&> == 3), true);
	fennec_test_run((component_count_v<const dvec4&> == 4), true);

	fennec_test_spacer(2);

	fennec_test_section(vec2 constructors);

	fennec_test_spacer(1);

	fennec_test_run(vec2(),                         vec2(0.0f, 0.0f));
	fennec_test_run(vec2(1.0f),                     vec2(1.0f, 1.0f));
	fennec_test_run(vec2(),                         vec2(0.0, 0.0));
	fennec_test_run(vec2(1.0),                      vec2(1.0, 1.0));
	fennec_test_run(vec2(),                         vec2(0, 0));
	fennec_test_run(vec2(1),                        vec2(1, 1));
	fennec_test_run(vec2(fennec::copy(vec2(1.0f))), vec2(1.0f));
	fennec_test_run(vec2(fennec::move(vec2(1.0f))), vec2(1.0f));

	fennec_test_spacer(2);

	fennec_test_section(vec2 swizzles);

	fennec_test_spacer(1);

	fennec_test_run(vec2(vec2(0, 1).xx), vec2(0, 0));
	fennec_test_run(vec2(vec2(0, 1).xy), vec2(0, 1));
	fennec_test_run(vec2(vec2(0, 1).yx), vec2(1, 0));
	fennec_test_run(vec2(vec2(0, 1).yy), vec2(1, 1));

	fennec_test_spacer(2);

	fennec_test_section(vec3 constructors);

	fennec_test_spacer(1);

	fennec_test_run(vec3(),                      vec3(0.0f, 0.0f, 0.0f));
	fennec_test_run(vec3(1.0f),                  vec3(1.0f, 1.0f, 1.0f));
	fennec_test_run(vec3(),                      vec3(0.0, 0.0, 0.0));
	fennec_test_run(vec3(1.0),                   vec3(1.0, 1.0, 1.0));
	fennec_test_run(vec3(),                      vec3(0, 0, 0));
	fennec_test_run(vec3(1),                     vec3(1, 1, 1));
	fennec_test_run(vec3(fennec::copy(vec3(1))), vec3(1));
	fennec_test_run(vec3(fennec::move(vec3(1))), vec3(1));

	fennec_test_spacer(2);

	fennec_test_section(vec3 swizzles);

	fennec_test_spacer(1);

	fennec_test_run(vec3(vec3(0, 1, 2).xxx), vec3(0, 0, 0));
	fennec_test_run(vec3(vec3(0, 1, 2).xxy), vec3(0, 0, 1));
	fennec_test_run(vec3(vec3(0, 1, 2).xxz), vec3(0, 0, 2));

	fennec_test_run(vec3(vec3(0, 1, 2).xyx), vec3(0, 1, 0));
	fennec_test_run(vec3(vec3(0, 1, 2).xyy), vec3(0, 1, 1));
	fennec_test_run(vec3(vec3(0, 1, 2).xyz), vec3(0, 1, 2));

	fennec_test_run(vec3(vec3(0, 1, 2).xzx), vec3(0, 2, 0));
	fennec_test_run(vec3(vec3(0, 1, 2).xzy), vec3(0, 2, 1));
	fennec_test_run(vec3(vec3(0, 1, 2).xzz), vec3(0, 2, 2));

	fennec_test_spacer(1);

	fennec_test_run(vec3(vec3(0, 1, 2).yxx), vec3(1, 0, 0));
	fennec_test_run(vec3(vec3(0, 1, 2).yxy), vec3(1, 0, 1));
	fennec_test_run(vec3(vec3(0, 1, 2).yxz), vec3(1, 0, 2));

	fennec_test_run(vec3(vec3(0, 1, 2).yyx), vec3(1, 1, 0));
	fennec_test_run(vec3(vec3(0, 1, 2).yyy), vec3(1, 1, 1));
	fennec_test_run(vec3(vec3(0, 1, 2).yyz), vec3(1, 1, 2));

	fennec_test_run(vec3(vec3(0, 1, 2).yzx), vec3(1, 2, 0));
	fennec_test_run(vec3(vec3(0, 1, 2).yzy), vec3(1, 2, 1));
	fennec_test_run(vec3(vec3(0, 1, 2).yzz), vec3(1, 2, 2));

	fennec_test_spacer(1);

	fennec_test_run(vec3(vec3(0, 1, 2).zxx), vec3(2, 0, 0));
	fennec_test_run(vec3(vec3(0, 1, 2).zxy), vec3(2, 0, 1));
	fennec_test_run(vec3(vec3(0, 1, 2).zxz), vec3(2, 0, 2));

	fennec_test_run(vec3(vec3(0, 1, 2).zyx), vec3(2, 1, 0));
	fennec_test_run(vec3(vec3(0, 1, 2).zyy), vec3(2, 1, 1));
	fennec_test_run(vec3(vec3(0, 1, 2).zyz), vec3(2, 1, 2));

	fennec_test_run(vec3(vec3(0, 1, 2).zzx), vec3(2, 2, 0));
	fennec_test_run(vec3(vec3(0, 1, 2).zzy), vec3(2, 2, 1));
	fennec_test_run(vec3(vec3(0, 1, 2).zzz), vec3(2, 2, 2));

	fennec_test_spacer(2);

	fennec_test_section(scalar-vector operations);

	fennec_test_spacer(1);

	fennec_test_run(2.0 * vec2(1, 2),       vec2(2, 4));
	fennec_test_run(2.0 * vec3(1, 2, 3),    vec3(2, 4, 6));
	fennec_test_run(2.0 * vec4(1, 2, 3, 4), vec4(2, 4, 6, 8));

	fennec_test_spacer(2);

	fennec_test_run(2.0 / vec2(1, 2),       vec2(2.0, 1.0));
	fennec_test_run(2.0 / vec3(1, 2, 4),    vec3(2.0, 1.0, 0.5));
	fennec_test_run(2.0 / vec4(1, 2, 4, 8), vec4(2.0, 1.0, 0.5, 0.25));

	fennec_test_spacer(2);

	fennec_test_section(vector-vector operations);

	fennec_test_spacer(1);

	fennec_test_run(vec2(1, 2)       + vec2(1, 2),       vec2(2, 4));
	fennec_test_run(vec3(1, 2, 3)    + vec3(1, 2, 3),    vec3(2, 4, 6));
	fennec_test_run(vec4(1, 2, 3, 4) + vec4(1, 2, 3, 4), vec4(2, 4, 6, 8));

	fennec_test_spacer(1);

	fennec_test_run(vec2(1, 2)       - vec2(1, 2),       vec2(0, 0));
	fennec_test_run(vec3(1, 2, 3)    - vec3(1, 2, 3),    vec3(0, 0, 0));
	fennec_test_run(vec4(1, 2, 3, 4) - vec4(1, 2, 3, 4), vec4(0, 0, 0, 0));

	fennec_test_spacer(1);

	fennec_test_run(vec2(1, 2)       * vec2(1, 2),       vec2(1, 4));
	fennec_test_run(vec3(1, 2, 3)    * vec3(1, 2, 3),    vec3(1, 4, 9));
	fennec_test_run(vec4(1, 2, 3, 4) * vec4(1, 2, 3, 4), vec4(1, 4, 9, 16));

	fennec_test_spacer(1);

	fennec_test_run(vec2(1, 2)       / vec2(1, 2),       vec2(1, 1));
	fennec_test_run(vec3(1, 2, 4)    / vec3(1, 2, 4),    vec3(1, 1, 1));
	fennec_test_run(vec4(1, 2, 4, 8) / vec4(1, 2, 4, 8), vec4(1, 1, 1, 1));

	fennec_test_spacer(1);

	fennec_test_run(ivec2(1, 2)       % ivec2(1, 2),       ivec2(0, 0));
	fennec_test_run(ivec3(1, 2, 4)    % ivec3(1, 2, 4),    ivec3(0, 0, 0));
	fennec_test_run(ivec4(1, 2, 4, 8) % ivec4(1, 2, 4, 8), ivec4(0, 0, 0, 0));


}

}

}

#endif //TEST_VECTOR_H