//
//  matrix_test.cpp
//  matrix
//
//  Created by Sam Jaffe on 6/3/18.
//

#include <gmock/gmock.h>

#include "matrix.hpp"
#include "matrix_helpers.hpp"

using matr2i = math::matrix::matrix<int, 2, 2>;
using matr2 = math::matrix::matrix<double, 2, 2>;

TEST(Matrix, _matrix_equals) {
  using math::matrix::identity;
  EXPECT_THAT((identity<int, 2>()), matr2i({{{1,0},{0,1}}}));
}

TEST(Matrix, _matrix_sum) {
  auto iden = math::matrix::identity<int, 2>();
  auto result = matr2i({{{2,0},{0,2}}});
  EXPECT_THAT(iden + iden, result);
}

TEST(Matrix, _matrix_default_zero) {
  auto zero = matr2i({{{0,0},{0,0}}});
  EXPECT_THAT(matr2i{}, zero);
}

TEST(Matrix, _matrix_subtract) {
  auto zero = matr2i({{{0,0},{0,0}}});
  auto iden = math::matrix::identity<int, 2>();
  EXPECT_THAT(iden-iden, zero);
}

//  TEST(Matrix, _matrix_negate) {
//    auto iden = math::matrix::identity<int, 2>();
//    EXPECT_THAT(-iden, matr2i({{{-1,0},{0,-1}}}));
//  }

TEST(Matrix, _matrix_scaling) {
  auto iden = math::matrix::identity<double, 2>();
  EXPECT_THAT(2*iden, matr2({{{2.0,0.0},{0.0,2.0}}}));
  EXPECT_THAT(iden*2, matr2({{{2.0,0.0},{0.0,2.0}}}));
  EXPECT_THAT(iden/2.0, matr2({{{0.5,0.0},{0.0,0.5}}}));
}

TEST(Matrix, _matrix_multiplication_same_dim) {
  auto A = matr2i({{{1,2},{2,3}}});
  auto B = matr2i({{{1,0},{1,1}}});
  EXPECT_THAT(A*B, matr2i({{{3,2},{5,3}}}));
  EXPECT_THAT(B*A, matr2i({{{1,2},{3,5}}}));
}

TEST(Matrix, _matrix_multiplication_diff_dim) {
  using matr2x2i = math::matrix::matrix<int, 2, 2>;
  using matr2x3i = math::matrix::matrix<int, 2, 3>;
  using matr3x2i = math::matrix::matrix<int, 3, 2>;
  using matr3x3i = math::matrix::matrix<int, 3, 3>;
  auto A = matr3x2i({{{1,0},{0,1},{1,1}}});
  auto B = matr2x3i({{{0,1,0},{1,0,1}}});
  EXPECT_THAT(A*B, matr3x3i({{{0,1,0},{1,0,1},{1,1,1}}}));
  EXPECT_THAT(B*A, matr2x2i({{{0,1},{2,1}}}));
}

TEST(Matrix, _matrix_vector_multiplication) {
  using vec2i = math::vector::vector<int, 2>;
  auto A = matr2i({{{1,0},{1,2}}});
  auto x = vec2i({1,2});
  EXPECT_THAT(A*x, vec2i({1,5}));
}

//  TEST(Matrix, _matrix_composition) {
//    using namespace math::matrix;
//    using vec4 = math::vector::vector<double, 4>;
//    using vec3 = math::vector::vector<double, 3>;
//    auto rot = rotation<4>(math::degree{90}, rotate::X_AXIS);
//    auto mov = translation(vec3{2.0, 2.5, 1.5}});
//    auto scl = scalar(vec3{2.0, math::vector::fill}});
//    vec4 epsilon{0.00001, math::vector::fill};
//    TS_ASSERT_DELTA((mov * scl * rot * vec4{1,2,3,1}}),
//                     (vec4{4.0,-1.5,-4.5,1.0}}),
//                    epsilon);
//  }

TEST(Matrix, _matrix_from_vector) {
  using vec3 = math::vector::vector<double, 3>;
  vec3 v = vec3({1,2,3});
  math::matrix::matrix<double, 3, 1> m{v};
  EXPECT_THAT(m(0,0), v[0]);
  EXPECT_THAT(m(1,0), v[1]);
  EXPECT_THAT(m(2,0), v[2]);
}

TEST(Matrix, _assign_row) {
  matr2i A = math::matrix::identity<int, 2>();
  matr2i const B = 2 * A;
  A[0] = B[0];
  EXPECT_THAT(A, matr2i({{{2,0},{0,1}}}));
}