#include "test_helpers.hpp"
#include "vector2d.hpp"

#include <cmath>
#include <limits>

TEST(Vector2dArith, VectorAddition) {
  Vector2d a(1.0, 2.0), b(3.0, 4.0);
  EXPECT_VEC2_NEAR(a + b, Vector2d(4.0, 6.0));
}

TEST(Vector2dArith, AdditionIsCommutative) {
  Vector2d a(1.5, -3.2), b(-0.7, 4.1);
  EXPECT_VEC2_NEAR(a + b, b + a);
}

TEST(Vector2dArith, AdditionDoesNotMutateOperands) {
  Vector2d a(1.0, 2.0), b(3.0, 4.0);
  (void)(a + b);
  EXPECT_VEC2_NEAR(a, Vector2d(1.0, 2.0));
  EXPECT_VEC2_NEAR(b, Vector2d(3.0, 4.0));
}

TEST(Vector2dArith, VectorSubtraction) {
  Vector2d a(5.0, 7.0), b(2.0, 4.0);
  EXPECT_VEC2_NEAR(a - b, Vector2d(3.0, 3.0));
}

TEST(Vector2dArith, SubtractionIsAntiCommutative) {
  Vector2d a(5.0, 7.0), b(2.0, 4.0);
  Vector2d ab = a - b;
  Vector2d ba = b - a;
  EXPECT_VEC2_NEAR(ab, Vector2d(-ba.x, -ba.y));
}

TEST(Vector2dArith, ScalarSubtractionAppliesToBothComponents) {
  Vector2d a(5.0, 7.0);
  EXPECT_VEC2_NEAR(a - 2.0, Vector2d(3.0, 5.0));
}

TEST(Vector2dArith, ScalarAdditionAppliesToBothComponents) {
  Vector2d a(5.0, 7.0);
  EXPECT_VEC2_NEAR(a + 2.0, Vector2d(7.0, 9.0));
}

TEST(Vector2dArith, ScalarMultiplication) {
  Vector2d a(3.0, -4.0);
  EXPECT_VEC2_NEAR(a * 2.0, Vector2d(6.0, -8.0));
}

TEST(Vector2dArith, ScalarMultiplicationByZero) {
  Vector2d a(3.0, -4.0);
  EXPECT_VEC2_NEAR(a * 0.0, Vector2d(0.0, 0.0));
}

TEST(Vector2dArith, ScalarMultiplicationByNegative) {
  Vector2d a(3.0, -4.0);
  EXPECT_VEC2_NEAR(a * -1.0, Vector2d(-3.0, 4.0));
}

TEST(Vector2dArith, ScalarDivision) {
  Vector2d a(6.0, -8.0);
  EXPECT_VEC2_NEAR(a / 2.0, Vector2d(3.0, -4.0));
}

TEST(Vector2dArith, CompoundAdditionMutatesAndReturns) {
  Vector2d a(1.0, 2.0);
  Vector2d b(3.0, 4.0);
  Vector2d returned = (a += b);
  EXPECT_VEC2_NEAR(a, Vector2d(4.0, 6.0));
  EXPECT_VEC2_NEAR(returned, Vector2d(4.0, 6.0));
  EXPECT_VEC2_NEAR(b, Vector2d(3.0, 4.0));
}

TEST(Vector2dArith, CompoundAdditionAccumulates) {
  Vector2d a(0.0, 0.0);
  for (int i = 0; i < 5; ++i)
    a += Vector2d(1.0, 2.0);
  EXPECT_VEC2_NEAR(a, Vector2d(5.0, 10.0));
}

TEST(Vector2dMutation, ReverseSignReturnsNegated) {
  Vector2d a(3.0, -4.0);
  Vector2d r = a.reverse_sign();
  EXPECT_VEC2_NEAR(r, Vector2d(-3.0, 4.0));
}

TEST(Vector2dMutation, ReverseSignDoesNotMutateOriginal) {
  Vector2d a(3.0, -4.0);
  (void)a.reverse_sign();
  EXPECT_VEC2_NEAR(a, Vector2d(3.0, -4.0));
}

TEST(Vector2dMutation, ResetZerosBothComponents) {
  Vector2d a(3.0, -4.0);
  a.reset();
  EXPECT_DOUBLE_EQ(a.x, 0.0);
  EXPECT_DOUBLE_EQ(a.y, 0.0);
}

TEST(Vector2dNorm, ZeroVectorHasZeroNorm) {
  Vector2d v;
  EXPECT_DOUBLE_EQ(v.norm(), 0.0);
}

TEST(Vector2dNorm, AxisAlignedNorm) {
  EXPECT_DOUBLE_EQ(Vector2d(3.0, 0.0).norm(), 3.0);
  EXPECT_DOUBLE_EQ(Vector2d(0.0, -4.0).norm(), 4.0);
}

TEST(Vector2dNorm, ThreeFourFiveTriangle) {
  Vector2d v(3.0, 4.0);
  EXPECT_NEAR(v.norm(), 5.0, tolerance);
}

TEST(Vector2dNorm, NormIsAlwaysNonNegative) {
  EXPECT_GE(Vector2d(-1.0, -2.0).norm(), 0.0);
  EXPECT_GE(Vector2d(1e-30, 1e-30).norm(), 0.0);
}

TEST(Vector2dDot, OrthogonalVectorsDotIsZero) {
  Vector2d a(1.0, 0.0), b(0.0, 1.0);
  EXPECT_DOUBLE_EQ(a.dot(b), 0.0);
}

TEST(Vector2dDot, ParallelVectorsDotIsProductOfNorms) {
  Vector2d a(2.0, 0.0), b(3.0, 0.0);
  EXPECT_DOUBLE_EQ(a.dot(b), 6.0);
}

TEST(Vector2dDot, AntiParallelDotIsNegative) {
  Vector2d a(1.0, 1.0), b(-1.0, -1.0);
  EXPECT_DOUBLE_EQ(a.dot(b), -2.0);
}

TEST(Vector2dDot, DotIsCommutative) {
  Vector2d a(1.5, -2.5), b(3.0, 4.0);
  EXPECT_DOUBLE_EQ(a.dot(b), b.dot(a));
}

TEST(Vector2dDot, DotWithSelfEqualsNormSquared) {
  Vector2d a(3.0, 4.0);
  EXPECT_NEAR(a.dot(a), a.norm() * a.norm(), tolerance);
}