#pragma region CPL License
/*
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

#ifndef NUCLEX_GEOMETRY_VECTOR2_H
#define NUCLEX_GEOMETRY_VECTOR2_H

#include "Nuclex/Geometry/Config.h"
#include "Nuclex/Geometry/Math.h"
#include "Nuclex/Geometry/Axis2.h"

#include <cassert>
#include <stdexcept>

namespace Nuclex { namespace Geometry {

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

  /// <summary>A direction in 2D space</summary>
  template <typename TScalar>
  struct Vector2 {

    /// <summary>A vector whose components have been initialized to zero</summary>
    public: static const Vector2 Zero;
    /// <summary>A vector whose components have been initialized to one</summary>
    public: static const Vector2 One;

    /// <summary>A vector pointing towards the negative X axis</summary>
    public: static const Vector2 Left;
    /// <summary>A vector pointing towards the positive X axis</summary>
    public: static const Vector2 Right;
    /// <summary>A vector pointing towards the negative Y axis</summary>
    public: static const Vector2 Down;
    /// <summary>A vector pointing towards the positive Y axis</summary>
    public: static const Vector2 Up;

    /// <summary>Constructs new uninitialized vector</summary>
    public: Vector2() {}

    /// <summary>Initializes a new vector pointing in the specified direction</summary>
    /// <param name="x">X offset the vector is pointing at</param>
    /// <param name="y">Y offset the vector is pointing at</param>
    public: Vector2(TScalar x, TScalar y) : X(x), Y(y) {}

    /// <summary>Creates a unit vector pointing in the direction specified by the angle</summary>
    /// <param name="angleInRadians">Angle the vector will be pointing towards</param>
    /// <returns>A unit vector pointing towards the specified angle</returns>
    public: static Vector2 FromAngle(TScalar angleInRadians) {
      return Vector2(
        Math<TScalar>::Cosine(angleInRadians), Math<TScalar>::Sine(angleInRadians)
      );
    }

    /// <summary>Returns the squared length of the vector</summary>
    /// <returns>The squared length of the vector</returns>
    public: TScalar GetSquaredLength() const {
      return (this->X * this->X) + (this->Y * this->Y);
    }

    /// <summary>Returns the length (magnitude) of the vector</summary>
    /// <returns>The length (magnitude) of the vector</returns>
    public: TScalar GetLength() const {
      return Math<TScalar>::SquareRoot(GetSquaredLength());
    }

    /// <summary>Normalizes the vector, ensuring it has a length of 1.0</summary>
    public: void Normalize() {
      TScalar length = GetSquaredLength();
      if(length == 0) {
        this->X = 0;
        this->Y = 0;
      } else {
        length = Math<TScalar>::SquareRoot(length);
        this->X /= length;
        this->Y /= length;
      }
    }

    /// <summary>Returns a normalized copy of the vector</summary>
    /// <param name="vector">Vector of which a normalized copy will be created</param>
    /// <returns>A normalized copy of the vector</returns>
    public: static Vector2 Normalize(const Vector2 &vector) {
      TScalar length = vector.GetSquaredLength();
      if(length == 0) {
        return Vector2::Zero;
      } else {
        length = Math<TScalar>::SquareRoot(length);
        return Vector2(vector.X / length, vector.Y / length);
      }
    }

    /// <summary>Initializes a normalized vector</summary>
    /// <param name="x">X coordinate that will be normalized to build the vector</param>
    /// <param name="y">Y coordinate that will be normalized to build the vector</param>
    /// <returns>A vector initialized with the normalized coordinates</returns>
    public: static Vector2 Normalize(TScalar x, TScalar y) {
      TScalar length = (x * x) + (y * y);
      if(length == 0) {
        return Vector2::Zero;
      } else {
        length = Math<TScalar>::SquareRoot(length);
        return Vector2(x / length, y / length);
      }
    }

    /// <summary>Determines the absolute angle of the vector</summary>
    /// <returns>The vector's absolute angle in radians</returns>
    public: TScalar GetAngle() const {
      EnforceNormalization();

      return Math<TScalar>::ArcTangent(this->X, this->Y);
    }

    /// <summary>Determines the absolute (unsigned) angle between two directions</summary>
    /// <param name="first">Vector from which the angle will be calculated</param>
    /// <param name="second">Vector to which the angle will be calculated</param>
    /// <returns>The absolute angle between the two directions</returns>
    public: static TScalar AngleBetween(const Vector2 &first, const Vector2 &second) {
      first.EnforceNormalization();
      second.EnforceNormalization();

      return Math<TScalar>::ArcCosine(Vector2::Dot(first, second));
    }

    /// <summary>Calculates the dot product between two vectors</summary>
    /// <param name="first">First vector from which the dot product will be calculated</param>
    /// <param name="second">Second vector from which the dot product will be calculated</param>
    /// <returns>The dot product of the two vectors</returns>
    public: static TScalar Dot(const Vector2 &first, const Vector2 &second) {
      return (first.X * second.X) + (first.Y * second.Y);
    }

    /// <summary>Returns the absolute product of the input vector</summary>
    /// <param name="vector">Vector of which the absolute product will be returned</param>
    /// <returns>The absolute product of the vector</returns>
    public: static Vector2 Abs(const Vector2 &vector) {
      return Vector2(Math<TScalar>::Abs(vector.X), Math<TScalar>::Abs(vector.Y));
    }

    /// <summary>Accesses one of the vector's components by index</summary>
    /// <param name="index">Index of the component that will be accessed</param>
    /// <returns>The component at the specified index</returns>
    public: TScalar &operator[](std::size_t index) {
      switch(index) {
        case Axis2::X: { return this->X; }
        case Axis2::Y: { return this->Y; }
        default: { throw std::out_of_range("Invalid Vector2 component index"); }
      }
    }

    /// <summary>Accesses one of the vector's components by index</summary>
    /// <param name="index">Index of the component that will be accessed</param>
    /// <returns>The component at the specified index</returns>
    public: const TScalar &operator[](std::size_t index) const {
      switch(index) {
        case Axis2::X: { return this->X; }
        case Axis2::Y: { return this->Y; }
        default: { throw std::out_of_range("Invalid Vector2 component index"); }
      }
    }

    /// <summary>Returns an orthogonal up vector for the vector</summary>
    /// <returns>A vector that is orthogonal to this vector and points up</returns>
    /// <remarks>
    ///   This method uses a simple method to obtain a right-angled vector which prefers
    ///   the up axis (Y+) in all cases. 
    /// </remarks>
    public: Vector2 GetOrthogonalUp() const {
      switch(GetLongestComponentIndex()) {
        case Axis2::X: {
          if(this->X > 0) {
            return Vector2(-this->Y, this->X);
          } else {
            return Vector2(this->Y, -this->X);
          }
        }
        case Axis2::Y: {
          if(this->Y > 0) {
            return Vector2(this->Y, -this->X);
          } else {
            return Vector2(-this->Y, this->X);
          }
        }
        default: {
          throw std::logic_error("GetLongestComponentIndex() malfunctioned");
        }
      }
    }

    /// <summary>Rotates the vector by the specified angle</summary>
    /// <param name="angleInRadians">Angle by which the vector will be rotated</param>
    public: void Rotate(TScalar angleInRadians) {
      TScalar sine = Math<TScalar>::Sine(angleInRadians);
      TScalar cosine = Math<TScalar>::Cosine(angleInRadians);

      TScalar temp = this->X * sine + this->Y * cosine;
      this->X = this->X * cosine - this->Y * sine;
      this->Y = temp;
    }

    /// <summary>Returns a rotated copy of the vector</summary>
    /// <param name="angleInRadians">Angle by which the vector copy will be rotated</param>
    /// <returns>The rotated copy of the vector</returns>
    public: Vector2 GetRotated(TScalar angleInRadians) const {
      TScalar sine = Math<TScalar>::Sine(angleInRadians);
      TScalar cosine = Math<TScalar>::Cosine(angleInRadians);

      return Vector2(
        this->X * cosine - this->Y * sine,
        this->X * sine + this->Y * cosine
      );
    }

    /// <summary>Negates the components of the vector</summary>
    /// <returns>The negated vector</returns>
    public: Vector2 operator -() {
      return Vector2(-this->X, -this->Y);
    }

    /// <summary>Subtracts another vector from this one and returns the result</summary>
    /// <param name="other">Other vector that will be subtracted</param>
    /// <returns>The vector resulting from the subtraction</returns>
    public: Vector2 operator -(const Vector2 &other) const {
      return Vector2(this->X - other.X, this->Y - other.Y);
    }

    /// <summary>Subtracts another vector from this one</summary>
    /// <param name="other">Other vector that will be subtracted</param>
    /// <returns>This vector after the subtraction</returns>
    public: Vector2 &operator -=(const Vector2 &other) {
      this->X -= other.X;
      this->Y -= other.Y;
      return *this;
    }

    /// <summary>Adds another vector to this one and returns the result</summary>
    /// <param name="other">Other vector that will be added</param>
    /// <returns>The vector resulting from the addition</returns>
    public: Vector2 operator +(const Vector2 &other) const {
      return Vector2(this->X + other.X, this->Y + other.Y);
    }

    /// <summary>Adds another vector to this one</summary>
    /// <param name="other">Other vector that will be added</param>
    /// <returns>This vector after the addition</returns>
    public: Vector2 &operator +=(const Vector2 &other) {
      this->X += other.X;
      this->Y += other.Y;
      return *this;
    }

    /// <summary>Multiplies this vector with another vector and returns the result</summary>
    /// <param name="other">Other vector this vector will be multiplied with</param>
    /// <returns>The vector resulting from the multiplication</returns>
    public: Vector2 operator *(const Vector2 &other) const {
      return Vector2(this->X * other.X, this->Y * other.Y);
    }

    /// <summary>Multiplies this vector with another vector</summary>
    /// <param name="other">Other vector with which to multiply</param>
    /// <returns>This vector after the multiplication</returns>
    public: Vector2 &operator *=(const Vector2 &other) {
      this->X *= other.X;
      this->Y *= other.Y;
      return *this;
    }

    /// <summary>Divides this vector by another vector and returns the result</summary>
    /// <param name="other">Other vector this vector will be divided by</param>
    /// <returns>The vector resulting from the division</returns>
    public: Vector2 operator /(const Vector2 &other) const {
      return Vector2(this->X / other.X, this->Y / other.Y);
    }

    /// <summary>Divides this vector by another vector</summary>
    /// <param name="other">Other vector by which to divide</param>
    /// <returns>This vector after the division</returns>
    public: Vector2 &operator /=(const Vector2 &other) {
      this->X /= other.X;
      this->Y /= other.Y;
      return *this;
    }

    /// <summary>Multiplies this vector by a factor and returns the result</summary>
    /// <param name="factor">Factor by which the vector will be multiplied</param>
    /// <returns>The result of the vector multiplication</returns>
    public: Vector2 operator *(TScalar factor) const {
      return Vector2(this->X * factor, this->Y * factor);
    }

    /// <summary>Multiplies this vector with a factor</summary>
    /// <param name="factor">Factor with which to multiply</param>
    /// <returns>This vector after the multiplication</returns>
    public: Vector2 &operator *=(TScalar factor) {
      this->X *= factor;
      this->Y *= factor;
      return *this;
    }

    /// <summary>Divides this vector through a divisor and returns the result</summary>
    /// <param name="divisor">Divisor through which the vector will be divided</param>
    /// <returns>The result of the vector division</returns>
    public: Vector2 operator /(TScalar factor) const {
      return Vector2(this->X / factor, this->Y / factor);
    }

    /// <summary>Multiplies this vector by a divisor</summary>
    /// <param name="divisor">Divisor by which to divide</param>
    /// <returns>This vector after the division</returns>
    public: Vector2 &operator /=(TScalar divisor) {
      this->X /= divisor;
      this->Y /= divisor;
      return *this;
    }

    /// <summary>Returns the index of the longest component in the vector</summary>
    /// <returns>The index of the longest component stored in the vector</returns>
    public: std::size_t GetLongestComponentIndex() const {
      if(Math<TScalar>::Abs(this->X) > Math<TScalar>::Abs(this->Y)) {
        return Axis2::X;
      } else {
        return Axis2::Y;
      }
    }

    /// <summary>Checks whether the vector is normalized</summary>
    /// <returns>True if the vector is normalized, false otherwise</returns>
    public: bool IsNormalized() const {
      return (Math<TScalar>::Abs(GetSquaredLength() - 1) * 1000000 < 1);
    }

    /// <summary>Fails an assertion if the vector is not normalized</summary>
    public: void EnforceNormalization() const {
      using namespace std;
      assert(IsNormalized() && "Vector2 has to be normalized");
    }

    /// <summary>Offset of the vector's direction on the X axis</summary>
    public: TScalar X;
    /// <summary>Offset of the vector's direction on the Y axis</summary>
    public: TScalar Y;

  };

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

  /// <summary>Multiplies this vector by a factor and returns the result</summary>
  /// <param name="factor">Factor by which the vector will be multiplied</param>
  /// <returns>The result of the vector multiplication</returns>
  template<typename TScalar>
  Vector2<TScalar> operator *(TScalar factor, const Vector2<TScalar> &vector) {
    return Vector2<TScalar>(factor * vector.X, factor * vector.Y);
  }

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

  template<typename TScalar>
  const Vector2<TScalar> Vector2<TScalar>::Zero(0, 0);

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

  template<typename TScalar>
  const Vector2<TScalar> Vector2<TScalar>::One(1, 1);

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

  template<typename TScalar>
  const Vector2<TScalar> Vector2<TScalar>::Left(-1, 0);

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

  template<typename TScalar>
  const Vector2<TScalar> Vector2<TScalar>::Right(1, 0);

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

  template<typename TScalar>
  const Vector2<TScalar> Vector2<TScalar>::Down(0, -1);

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

  template<typename TScalar>
  const Vector2<TScalar> Vector2<TScalar>::Up(0, 1);

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

}} // namespace Nuclex::Geometry

#endif // NUCLEX_GEOMETRY_VECTOR2_H