#include <cxxtest/TestSuite.h>

#include "vector.hpp"

class vector_TestSuite : public CxxTest::TestSuite {
public:
  using vec2i = math::vector::raw_vector<2, int>;
  using vec3  = math::vector::raw_vector<3, double>;
  using vec3i = math::vector::raw_vector<3, int>;
  using vec4i = math::vector::raw_vector<4, int>;

  void test_vector_equals() const {
    TS_ASSERT_EQUALS(iota3i(), (vec3i{1, 2, 3}));
  }
  
  void test_vector_notequals() const {
    TS_ASSERT_DIFFERS(iota3i(), (vec3i{0, 2, 3}));
  }
  
  void test_vector_elems() const {
    math::vector::raw_vector<3, int> viota = iota3i();
    TS_ASSERT_EQUALS(viota[0], 1);
    TS_ASSERT_EQUALS(viota[1], 2);
    TS_ASSERT_EQUALS(viota[2], 3);
  }
  
  void test_vector_oob() const {
    TS_ASSERT_THROWS((iota<3, int>()).at(3), std::out_of_range);
  }
  
  void test_default_zero() const {
    TS_ASSERT_EQUALS(vec3i(), (vec3i{0,0,0}));
  }
  
  void test_extends_with_zero() const {
    TS_ASSERT_EQUALS(vec4i(iota3i()), (vec4i{1,2,3,0}));
  }
  
  void test_vec2_cross() const {
    TS_ASSERT_EQUALS((vec2i{1,1}.cross(vec2i{-1,1})), (vec3i{0,0,2}));
  }
  
  void test_vec3_cross() const {
    TS_ASSERT_EQUALS((vec3i{1,1,2}.cross(vec3i{-1,1,1})), (vec3i{-1,-3,2}));
  }
  
  void test_vector_addition_vector() const {
    TS_ASSERT_EQUALS((vec2i{1,0} + vec2i{0,1}), (vec2i{1,1}))
  }
  
  void test_vector_subtraction_vector() const {
    TS_ASSERT_EQUALS((vec2i{1,0} - vec2i{0,1}), (vec2i{1,-1}))
  }
  
  void test_vector_multiplication_vector() const {
    TS_ASSERT_EQUALS((vec2i{1,0} * vec2i{2,1}), (vec2i{2,0}))
  }
  
  void test_vector_divides_vector() const {
    TS_ASSERT_EQUALS((vec2i{6,4} / vec2i{2,1}), (vec2i{3,4}))
  }
  
  void test_vector_addition_value() const {
    TS_ASSERT_EQUALS((vec2i{1,0} + 1), (vec2i{2,1}))
  }
  
  void test_vector_subtraction_value() const {
    TS_ASSERT_EQUALS((vec2i{1,0} - 1), (vec2i{0,-1}))
  }
  
  void test_vector_multiplication_value() const {
    TS_ASSERT_EQUALS((vec2i{1,0} * 3), (vec2i{3,0}))
  }
  
  void test_vector_divides_value() const {
    TS_ASSERT_EQUALS((vec2i{6,4} / 2), (vec2i{3,2}))
  }
  
  void test_value_addition_vector() const {
    TS_ASSERT_EQUALS(1+iota2i(), (vec2i{2,3}));
  }
  
  void test_value_subtraction_vector() const {
    TS_ASSERT_EQUALS(4-iota2i(), (vec2i{3,2}));
  }
  
  void test_value_multiplication_vector() const {
    TS_ASSERT_EQUALS(2*iota2i(), (vec2i{2,4}));
  }
  
  void test_value_divides_vector() const {
    TS_ASSERT_EQUALS(4/iota2i(), (vec2i{4,2}));
  }
  
  void test_length_of_vector() const {
    TS_ASSERT_EQUALS(iota3i().lengthSquared(), 14);
    TS_ASSERT_DELTA(iota3i().length(), std::sqrt(14), 0.00001);
  }
  
  void test_distance_of_vector() const {
    TS_ASSERT_EQUALS((iota3i().distanceSquared(vec3i{3, 1, -1})), 21);
    TS_ASSERT_DELTA((iota3i().distance(vec3i{3, 1, -1})), std::sqrt(21), 0.00001);
  }
  
  void test_dot_product() const {
    TS_ASSERT_EQUALS((iota3i().dot(vec3i{3, 0, -1})), 0);
  }
  
  void test_unit_vector() const {
    double sq = std::sqrt(14);
    vec3 epsilon{0.00001, math::vector::fill};
    TS_ASSERT_DELTA(iota3i().unit(), (vec3{1/sq, 2/sq, 3/sq}), epsilon);
  }
  
  void test_type_shift() const {
    TS_ASSERT_EQUALS((vec3i(vec3{1.0, 2.3, 3.9})), iota3i());
  }
  
  void test_swap() const {
    vec2i a{1, 2}; const vec2i ac = a;
    vec2i b{5, 7}; const vec2i bc = b;
    a.swap(b);
    TS_ASSERT_EQUALS(a, bc);
    TS_ASSERT_EQUALS(b, ac);
  }
  
  void test_negate_vector() const {
    TS_ASSERT_EQUALS(-iota3i(), (vec3i{-1,-2,-3}));
  }
  
  void test_absolute_value() const {
    TS_ASSERT_EQUALS(iota3i(), std::abs(-iota3i()));
  }
  
private:
  
  template <size_t N, typename T> math::vector::raw_vector<N, T> iota() const {
    math::vector::raw_vector<N, T> rval;
    for (size_t i = 0; i < N; ++i) rval[i] = static_cast<T>(i+1);
    return rval;
  }
  
  vec2i iota2i() const { return iota<2, int>(); }
  vec3i iota3i() const { return iota<3, int>(); }
};