#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_VECTOR4_H
#define NUCLEX_GEOMETRY_VECTOR4_H

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

#include <cassert>
#include <stdexcept>

namespace Nuclex { namespace Geometry {

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

  /// <summary>A direction in 4D space</summary>
  template <typename TScalar>
  struct Vector4 {

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

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

    /// <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>
    /// <param name="w">W offset the vector is pointing at</param>
    public: Vector4(TScalar x, TScalar y, TScalar z, TScalar w) : X(x), Y(y), Z(z), W(w) {}

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

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

    /// <summary>Returns a normalized copy of the vector</summary>
    /// <returns>A normalized copy of the vector</returns>
    public: Vector4 GetNormalized() const {
      TScalar length = GetSquaredLength();
      if(length == 0) {
        return Vector4(0, 0, 0, 0);
      } else {
        length = Math<TScalar>::SquareRoot(length);
        return Vector4(this->X / length, this->Y / length, this->Z / length, this->W / 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 Vector4 &first, const Vector4 &second) {
      first.EnforceNormalization();
      second.EnforceNormalization();

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

    /// <summary>Calculates the cross product between three vectors</summary>
    /// <param name="first">First vector the cross product is calculated with</param>
    /// <param name="second">Second vector the cross product is calculated with</param>
    /// <param name="third">Third vector the cross product is calculated with</param>
    /// <returns>The cross product of the three vectors</returns>
    public: static Vector4 Cross(
      const Vector4 first, const Vector4 &second, const Vector4 &third
    ) {
      // TODO: Implement cross product for 4D vectors.
    }

    /// <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 Vector4 &first, const Vector4 &second) {
      return
        (first.X * second.X) +
        (first.Y * second.Y) +
        (first.Z * second.Z) +
        (first.W * second.W);
    }

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

    /// <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 Axis4::X: { return this->X; }
        case Axis4::Y: { return this->Y; }
        case Axis4::Z: { return this->Z; }
        case Axis4::W: { return this->W; }
        default: { throw std::out_of_range("Invalid Vector4 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 Axis4::X: { return this->X; }
        case Axis4::Y: { return this->Y; }
        case Axis4::Z: { return this->Z; }
        case Axis4::W: { return this->W; }
        default: { throw std::out_of_range("Invalid Vector4 component index"); }
      }
    }

#if 0
    /// <summary>Returns an orthogonal up vector for the vector</summary>
    /// <returns>A vector that is orthogonal to this vector and points up</returns>
    public: Vector4 GetOrthogonalUp() const {
      // TODO: GetOrthogonalUp() is not correct for 4D vectors
      switch(GetLongestComponentIndex()) {
        case Axis4::X: {
          if(this->X > 0) {
            return Vector4(-this->Z, 0, this->X);
          } else {
            return Vector4(this->Z, 0, -this->X);
          }
        }
        case Axis4::Y: {
          if(this->Y > 0) {
            return Vector4(0, -this->Z, this->Y);
          } else {
            return Vector4(0, this->Z, -this->Y);
          }
        }
        case Axis4::Z: {
          if(this->X > 0) {
            return Vector4(-this->Z, 0, this->X);
          } else {
            return Vector4(this->Z, 0, -this->X);
          }
        }
        default: {
          throw std::logic_error("GetLongestComponentIndex() malfunctioned");
        }
      }
    }
#endif

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

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

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

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

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

    /// <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: Vector4 &operator /=(const Vector4 &other) {
      this->X /= other.X;
      this->Y /= other.Y;
      this->Z /= other.Z;
      this->W /= other.W;
      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: Vector4 operator *(TScalar factor) const {
      return Vector4(this->X * factor, this->Y * factor, this->Z * factor, this->W * 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: Vector4 &operator *=(TScalar factor) {
      this->X *= factor;
      this->Y *= factor;
      this->Z *= factor;
      this->W *= 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: Vector4 operator /(TScalar factor) const {
      return Vector4(this->X / factor, this->Y / factor, this->Z / factor, this->W / 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: Vector4 &operator /=(TScalar divisor) {
      this->X /= divisor;
      this->Y /= divisor;
      this->Z /= divisor;
      this->W /= 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);
      TScalar absZ = Math<TScalar>::Abs(this->Z);
      if(absY > absX) {
        if(absZ > absY) {
          if(Math<TScalar>::Abs(this->W) > absZ) {
            return Axis4::W;
          } else {
            return Axis4::Z;
          }
        } else {
          if(Math<TScalar>::Abs(this->W) > absY) {
            return Axis4::W;
          } else {
            return Axis4::Y;
          }
        }
      } else {
        if(absZ > absX) {
          if(Math<TScalar>::Abs(this->W) > absZ) {
            return Axis4::W;
          } else {
            return Axis4::Z;
          }
        } else {
          if(Math<TScalar>::Abs(this->W) > absX) {
            return Axis4::W;
          } else {
            return Axis4::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() && "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>Offset of the vector's direction on the Z axis</summary>
    public: TScalar Z;
    /// <summary>Offset of the vector's direction on the W axis</summary>
    public: TScalar W;

  };

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

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

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

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

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

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

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

}} // namespace Nuclex::Geometry

#endif // NUCLEX_GEOMETRY_VECTOR4_H