#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_VECTOR3_H
#define NUCLEX_GEOMETRY_VECTOR3_H

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

#include <cassert>
#include <stdexcept>

namespace Nuclex { namespace Geometry {

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

  /// <summary>A direction in 3D space</summary>
  template <typename TScalar>
  struct Vector3 {

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

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

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

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

    /// <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) + (this->Z * this->Z);
    }

    /// <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;
        this->Z = 0;
      } else {
        length = Math<TScalar>::SquareRoot(length);
        this->X /= length;
        this->Y /= length;
        this->Z /= length;
      }
    }

    /// <summary>Builds a normalized copy of the vector</summary>
    /// <returns>A normalized copy of the vector</returns>
    public: static Vector3 Normalize(const Vector3 &vector) {
      TScalar length = vector.GetSquaredLength();
      if(length == 0) {
        return Vector3(0, 0, 0);
      } else {
        length = Math<TScalar>::SquareRoot(length);
        return Vector3(vector.X / length, vector.Y / length, vector.Z / length);
      }
    }

    /// <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 Vector3 &first, const Vector3 &second) {
      first.EnforceNormalization();
      second.EnforceNormalization();

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

    /// <summary>Calculates the cross product between this vector and another one</summary>
    /// <param name="first">First vector the cross product will be calculated for</param>
    /// <param name="second">Second vector the cross product will be calculated for</param>
    /// <returns>The cross product of this vector with the other vector</returns>
    public: static Vector3 Cross(const Vector3 first, const Vector3 &second) {
      return Vector3(
        (first.Y * second.Z) - (first.Z * second.Y),
        (first.Z * second.X) - (first.X * second.Z),
        (first.X * second.Y) - (first.Y * second.X)
      );
    }

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

    /// <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 Vector3 Abs(const Vector3 &vector) {
      return Vector3(
        Math<TScalar>::Abs(vector.X),
        Math<TScalar>::Abs(vector.Y),
        Math<TScalar>::Abs(vector.Z)
      );
    }

    /// <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 Axis3::X: { return this->X; }
        case Axis3::Y: { return this->Y; }
        case Axis3::Z: { return this->Z; }
        default: { throw std::out_of_range("Invalid Vector3 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 Axis3::X: { return this->X; }
        case Axis3::Y: { return this->Y; }
        case Axis3::Z: { return this->Z; }
        default: { throw std::out_of_range("Invalid Vector3 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>
    public: Vector3 GetOrthogonalUp() const {
      switch(GetLongestComponentIndex()) {
        case Axis3::X: {
          if(this->X > 0) {
            return Vector3(-this->Z, 0, this->X);
          } else {
            return Vector3(this->Z, 0, -this->X);
          }
        }
        case Axis3::Y: {
          if(this->Y > 0) {
            return Vector3(0, -this->Z, this->Y);
          } else {
            return Vector3(0, this->Z, -this->Y);
          }
        }
        case Axis3::Z: {
          if(this->X > 0) {
            return Vector3(-this->Z, 0, this->X);
          } else {
            return Vector3(this->Z, 0, -this->X);
          }
        }
        default: {
          throw std::logic_error("GetLongestComponentIndex() malfunctioned");
        }
      }
    }

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

    /// <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: Vector3 operator -(const Vector3 &other) const {
      return Vector3(this->X - other.X, this->Y - other.Y, this->Z - other.Z);
    }

    /// <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: Vector3 &operator -=(const Vector3 &other) {
      this->X -= other.X;
      this->Y -= other.Y;
      this->Z -= other.Z;
      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: Vector3 operator +(const Vector3 &other) const {
      return Vector3(this->X + other.X, this->Y + other.Y, this->Z + other.Z);
    }

    /// <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: Vector3 &operator +=(const Vector3 &other) {
      this->X += other.X;
      this->Y += other.Y;
      this->Z += other.Z;
      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: Vector3 operator *(const Vector3 &other) const {
      return Vector3(this->X * other.X, this->Y * other.Y, this->Z * other.Z);
    }

    /// <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: Vector3 &operator *=(const Vector3 &other) {
      this->X *= other.X;
      this->Y *= other.Y;
      this->Z *= other.Z;
      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: Vector3 operator /(const Vector3 &other) const {
      return Vector3(this->X / other.X, this->Y / other.Y, this->Z / other.Z);
    }

    /// <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: Vector3 &operator /=(const Vector3 &other) {
      this->X /= other.X;
      this->Y /= other.Y;
      this->Z /= other.Z;
      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: Vector3 operator *(TScalar factor) const {
      return Vector3(this->X * factor, this->Y * factor, this->Z * 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: Vector3 &operator *=(TScalar factor) {
      this->X *= factor;
      this->Y *= factor;
      this->Z *= 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: Vector3 operator /(TScalar factor) const {
      return Vector3(this->X / factor, this->Y / factor, this->Z / 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: Vector3 &operator /=(TScalar divisor) {
      this->X /= divisor;
      this->Y /= divisor;
      this->Z /= 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 {
      TScalar absX = Math<TScalar>::Abs(this->X);
      TScalar absY = Math<TScalar>::Abs(this->Y);
      if(absY > absX) {
        if(Math<TScalar>::Abs(this->Z) > absY) {
          return Axis3::Z;
        } else {
          return Axis3::Y;
        }
      } else {
        if(Math<TScalar>::Abs(this->Z) > absX) {
          return Axis3::Z;
        } else {
          return Axis3::X;
        }
      }
    }

    /// <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() && "Vector3 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>Offset of the vector's direction on the Z axis</summary>
    public: TScalar Z;

  };

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

  /// <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>
  Vector3<TScalar> operator *(TScalar factor, const Vector3<TScalar> &vector) {
    return Vector3<TScalar>(factor * vector.X, factor * vector.Y, factor * vector.Z);
  }

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

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

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

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

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

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

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

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

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

  template<typename TScalar>
  const Vector3<TScalar> Vector3<TScalar>::Backward(0, -1, 0);

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

  template<typename TScalar>
  const Vector3<TScalar> Vector3<TScalar>::Forward(0, 1, 0);

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

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

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

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

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

}} // namespace Nuclex::Geometry

#endif // NUCLEX_GEOMETRY_VECTOR3_H