#pragma region CPL License
/*10
Nuclex Native Framework
Copyright (C) 2002-2015 Nuclex Development Labs

This library is free software; you can redistribute it and/or
modify it under the terms of the IBM Common Public License as
published by the IBM Corporation; either version 1.0 of the
License, or (at your option) any later version.

This library 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
IBM Common Public License for more details.

You should have received a copy of the IBM Common Public
License along with this library
*/
#pragma endregion // CPL License

// If the library is compiled as a DLL, this ensures symbols are exported
#define NUCLEX_GEOMETRY_SOURCE 1

#include "Nuclex/Geometry/Vector2.h"

#include <cmath> // for std::sqrt()

#include <gtest/gtest.h>

namespace Nuclex { namespace Geometry {

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, ParameterConstructorAssignsValues) {
    EXPECT_EQ(12.34f, Vector2<float>(12.34f, 56.78f).X);
    EXPECT_EQ(56.78f, Vector2<float>(12.34f, 56.78f).Y);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, VectorsCanBeInitializedToAngles) {
    const float Tolerance = 1.e-007f;

    Vector2<float> right = Vector2<float>::FromAngle(0.0f);
    EXPECT_NEAR(1.0f, right.X, Tolerance);
    EXPECT_NEAR(0.0f, right.Y, Tolerance);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, AngleInitializedVectorsGoCounterClockwise) {
    const float Tolerance = 1.e-007f;

    Vector2<float> up = Vector2<float>::FromAngle(Math<float>::Pi / 2.0f);
    EXPECT_NEAR(0.0f, up.X, Tolerance);
    EXPECT_NEAR(1.0f, up.Y, Tolerance);

    Vector2<float> left = Vector2<float>::FromAngle(Math<float>::Pi);
    EXPECT_NEAR(-1.0f, left.X, Tolerance);
    EXPECT_NEAR(0.0f, left.Y, Tolerance);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, ZeroIsInitializedToAllZeroes) {
    EXPECT_EQ(0.0f, Vector2<float>::Zero.X);
    EXPECT_EQ(0.0f, Vector2<float>::Zero.Y);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, OneIsInitializedToAllOnes) {
    EXPECT_EQ(1.0f, Vector2<float>::One.X);
    EXPECT_EQ(1.0f, Vector2<float>::One.Y);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, LeftIsPointingTowardsNegativeX) {
    EXPECT_EQ(-1.0f, Vector2<float>::Left.X);
    EXPECT_EQ(0.0f, Vector2<float>::Left.Y);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, RightIsPointingTowardsPositiveX) {
    EXPECT_EQ(1.0f, Vector2<float>::Right.X);
    EXPECT_EQ(0.0f, Vector2<float>::Right.Y);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, DownIsPointingTowardsNegativeY) {
    EXPECT_EQ(0.0f, Vector2<float>::Down.X);
    EXPECT_EQ(-1.0f, Vector2<float>::Down.Y);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, UpIsPointingTowardsPositiveY) {
    EXPECT_EQ(0.0f, Vector2<float>::Up.X);
    EXPECT_EQ(1.0f, Vector2<float>::Up.Y);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, SquaredLengthCanBeCalculated) {
    const float X = 5.0f;
    const float Y = 10.0f;
    EXPECT_EQ(X * X + Y * Y, Vector2<float>(X, Y).GetSquaredLength());
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, SquaredLengthOfZeroVectorIsZero) {
    EXPECT_EQ(0.0f, Vector2<float>::Zero.GetSquaredLength());
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, LengthCanBeCalculated) {
    const float X = 5.0f;
    const float Y = 10.0f;
    EXPECT_EQ(std::sqrt(X * X + Y * Y), Vector2<float>(X, Y).GetLength());
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, LengthOfZeroVectorIsZero) {
    EXPECT_EQ(0.0f, Vector2<float>::Zero.GetLength());
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, VectorsCanBeNormalized) {
    Vector2<float> right(2.0f, 0.0f);
    right.Normalize();
    EXPECT_EQ(1.0f, right.X);
    EXPECT_EQ(0.0f, right.Y);

    Vector2<float> up(0.0f, 2.0f);
    up.Normalize();
    EXPECT_EQ(0.0f, up.X);
    EXPECT_EQ(1.0f, up.Y);

    Vector2<float> diagonal(2.0f, 1.0f);
    diagonal.Normalize();
    EXPECT_FLOAT_EQ(1.0, diagonal.GetSquaredLength()); // squared or non squared, 1.0 stays 1.0
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, VectorsCanProvideNormalizedCopies) {
    const Vector2<float> right(2.0f, 0.0f);
    Vector2<float> normalizedRight = Vector2<float>::Normalize(right);
    EXPECT_EQ(1.0f, normalizedRight.X);
    EXPECT_EQ(0.0f, normalizedRight.Y);

    const Vector2<float> up(0.0f, 2.0f);
    Vector2<float> normalizedUp = Vector2<float>::Normalize(up);
    EXPECT_EQ(0.0f, normalizedUp.X);
    EXPECT_EQ(1.0f, normalizedUp.Y);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, NormalizedCopyLeavesOriginalUntouched) {
    const Vector2<float> notNormalized(12.34f, 56.78f);
    Vector2<float> normalized = Vector2<float>::Normalize(notNormalized);

    EXPECT_EQ(12.34f, notNormalized.X);
    EXPECT_EQ(56.78f, notNormalized.Y);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, DotProductCanBeCalculated) {
    const Vector2<float> first(2.0f, 4.0f);
    const Vector2<float> second(6.0f, 8.0f);

    float dotProduct = (first.X * second.X) + (first.Y * second.Y);
    EXPECT_EQ(dotProduct, Vector2<float>::Dot(first, second));
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, AbsoluteValueCanBeCalculated) {
    Vector2<float> test = Vector2<float>::Abs(Vector2<float>(-12.34f, -56.78f));

    EXPECT_EQ(12.34f, test.X);
    EXPECT_EQ(56.78f, test.Y);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, ComponentsCanBeAccessedByIndex) {
    const Vector2<float> test(12.34f, 56.78f);

    EXPECT_EQ(test.X, test[0]);
    EXPECT_EQ(test.X, test[Axis2::X]);

    EXPECT_EQ(test.Y, test[1]);
    EXPECT_EQ(test.Y, test[Axis2::Y]);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, AccessingComponentsByInvalidIndexThrowsException) {
    EXPECT_THROW(Vector2<float>::Zero[2], std::out_of_range);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, CanObtainOrthogonalUpVectorForRightVector) {
    const Vector2<float> nearlyRight(1.0f, 0.1f);
    const Vector2<float> orthogonalFromNearlyRight = nearlyRight.GetOrthogonalUp();
    EXPECT_EQ(-nearlyRight.Y, orthogonalFromNearlyRight.X);
    EXPECT_EQ(nearlyRight.X, orthogonalFromNearlyRight.Y);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, CanObtainOrthogonalUpVectorForLeftVector) {
    const Vector2<float> nearlyLeft(-1.0f, 0.1f);
    const Vector2<float> orthogonalFromNearlyLeft = nearlyLeft.GetOrthogonalUp();
    EXPECT_EQ(nearlyLeft.Y, orthogonalFromNearlyLeft.X);
    EXPECT_EQ(-nearlyLeft.X, orthogonalFromNearlyLeft.Y);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, CanObtainOrthogonalUpVectorForUpVector) {
    const Vector2<float> nearlyUp(0.1f, 1.0f);
    const Vector2<float> orthogonalFromNearlyUp = nearlyUp.GetOrthogonalUp();
    EXPECT_EQ(nearlyUp.Y, orthogonalFromNearlyUp.X);
    EXPECT_EQ(-nearlyUp.X, orthogonalFromNearlyUp.Y);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, CanObtainOrthogonalUpVectorForDownVector) {
    const Vector2<float> nearlyDown(0.1f, -1.0f);
    const Vector2<float> orthogonalFromNearlyDown = nearlyDown.GetOrthogonalUp();
    EXPECT_EQ(-nearlyDown.Y, orthogonalFromNearlyDown.X);
    EXPECT_EQ(nearlyDown.X, orthogonalFromNearlyDown.Y);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, AngleBetweenTwoVectorsCanBeDetermined) {
    float angle = Vector2<float>::AngleBetween(Vector2<float>::Up, Vector2<float>::Right);
    EXPECT_EQ(Math<float>::Pi / 2.0f, angle);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, AngleBetweenTwoVectorsIsAlwaysPositive) {
    float upAngle = Vector2<float>::AngleBetween(Vector2<float>::Left, Vector2<float>::Up);
    float downAngle = Vector2<float>::AngleBetween(Vector2<float>::Left, Vector2<float>::Down);
    EXPECT_EQ(upAngle, downAngle);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, VectorsCanBeRotated) {
    const float Tolerance = 1.e-007f;

    Vector2<float> right = Vector2<float>::Right;
    right.Rotate(Math<float>::Pi / 2.0f);
    EXPECT_NEAR(0.0f, right.X, Tolerance);
    EXPECT_NEAR(1.0f, right.Y, Tolerance);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, VectorsCanProvideRotatedCopies) {
    const float Tolerance = 1.e-007f;

    Vector2<float> right = Vector2<float>::Right.GetRotated(Math<float>::Pi / 2.0f);
    EXPECT_NEAR(0.0f, right.X, Tolerance);
    EXPECT_NEAR(1.0f, right.Y, Tolerance);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, RotatedCopyLeavesOriginalUntouched) {
    const Vector2<float> notRotated(12.34f, 56.78f);
    Vector2<float> rotated = notRotated.GetRotated(Math<float>::Pi / 2.0f);

    EXPECT_EQ(12.34f, notRotated.X);
    EXPECT_EQ(56.78f, notRotated.Y);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, RotatedVectorsGoCounterClockwise) {
    const float Tolerance = 1.e-007f;

    Vector2<float> up = Vector2<float>::Right.GetRotated(Math<float>::Pi / 2.0f);
    EXPECT_NEAR(0.0f, up.X, Tolerance);
    EXPECT_NEAR(1.0f, up.Y, Tolerance);

    Vector2<float> left = Vector2<float>::Right.GetRotated(Math<float>::Pi);
    EXPECT_NEAR(-1.0f, left.X, Tolerance);
    EXPECT_NEAR(0.0f, left.Y, Tolerance);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, AngleOfVectorCanBeDetermined) {
    const float Tolerance = 1.e-007f;

    EXPECT_NEAR(0.0f, Vector2<float>::Right.GetAngle(), Tolerance);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, VectorAnglesGoCounterClockwise) {
    const float Tolerance = 1.e-007f;

    EXPECT_NEAR(Math<float>::Pi / 2.0f, Vector2<float>::Up.GetAngle(), Tolerance);
    EXPECT_NEAR(Math<float>::Pi, Vector2<float>::Left.GetAngle(), Tolerance);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, VectorsCanBeNegated) {
    Vector2<float> negative = -Vector2<float>(12.34f, 56.78f);

    EXPECT_EQ(-12.34f, negative.X);
    EXPECT_EQ(-56.78f, negative.Y);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, VectorsCanBeSubtractedFromEachOther) {
    Vector2<float> result = Vector2<float>(22.0f, 44.0f) - Vector2<float>(10.0f, 20.0f);

    EXPECT_EQ(12.0f, result.X);
    EXPECT_EQ(24.0f, result.Y);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, VectorsCanBeSubtractAssigned) {
    Vector2<float> test(22.0f, 44.0f);
    test -= Vector2<float>(10.0f, 20.0f);

    EXPECT_EQ(12.0f, test.X);
    EXPECT_EQ(24.0f, test.Y);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, VectorsCanBeAddedTogether) {
    Vector2<float> result = Vector2<float>(22.0f, 44.0f) + Vector2<float>(10.0f, 20.0f);

    EXPECT_EQ(32.0f, result.X);
    EXPECT_EQ(64.0f, result.Y);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, VectorsCanBeAddAssigned) {
    Vector2<float> test(22.0f, 44.0f);
    test += Vector2<float>(10.0f, 20.0f);

    EXPECT_EQ(32.0f, test.X);
    EXPECT_EQ(64.0f, test.Y);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, VectorsCanBeMultipliedWithEachOther) {
    Vector2<float> result = Vector2<float>(22.0f, 44.0f) * Vector2<float>(5.0f, 10.0f);

    EXPECT_EQ(110.0f, result.X);
    EXPECT_EQ(440.0f, result.Y);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, VectorsCanBeMultiplyAssigned) {
    Vector2<float> test(22.0f, 44.0f);
    test *= Vector2<float>(5.0f, 10.0f);

    EXPECT_EQ(110.0f, test.X);
    EXPECT_EQ(440.0f, test.Y);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, VectorsCanBeDividedByEachOther) {
    Vector2<float> result = Vector2<float>(22.0f, 44.0f) / Vector2<float>(4.0f, 10.0f);

    EXPECT_EQ(5.5f, result.X);
    EXPECT_EQ(4.4f, result.Y);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, VectorsCanBeDivisionAssigned) {
    Vector2<float> test(22.0f, 44.0f);
    test /= Vector2<float>(4.0f, 10.0f);

    EXPECT_EQ(5.5f, test.X);
    EXPECT_EQ(4.4f, test.Y);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, VectorsCanBeMultipliedByScalars) {
    Vector2<float> result = Vector2<float>(22.0f, 44.0f) * 3.0f;

    EXPECT_EQ(66.0f, result.X);
    EXPECT_EQ(132.0f, result.Y);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, ScalarsCanBeMultipliedByVectors) {
    Vector2<float> result = 3.0f * Vector2<float>(22.0f, 44.0f);

    EXPECT_EQ(66.0f, result.X);
    EXPECT_EQ(132.0f, result.Y);
  }

  // ------------------------------------------------------------------------------------------- //

  TEST(Vector2Test, VectorsCanBeDividedByScalars) {
    Vector2<float> result = Vector2<float>(22.0f, 44.0f) / 4.0f;

    EXPECT_EQ(5.5f, result.X);
    EXPECT_EQ(11.0f, result.Y);
  }

  // ------------------------------------------------------------------------------------------- //

}} // namespace Nuclex::Geometry