#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_POINT3_H
#define NUCLEX_GEOMETRY_POINT3_H

#include "Nuclex/Geometry/Config.h"
#include "Nuclex/Geometry/Vector3.h"

namespace Nuclex { namespace Geometry {

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

  /// <summary>Point in 3D space using cartesian coordinates</summary>
  /// <remarks>
  ///   <para>
  ///     Most math libraries combine the concepts of a &quot;point&quot; and
  ///     a &quot;vector&quot; because they both store a pair of scalars and have many
  ///     equivalent operations. There is however a semantic meaning associated with a point:
  ///     it is a location, not a size and not a direction.
  ///   </para>
  ///   <para>
  ///     This library attempts to keep up this distinction to provide meaning without
  ///     additional documentation and to guard against errors from mistaken identity.
  ///   </para>
  /// </remarks>
  template <typename TScalar>
  struct Point3 {

    /// <summary>A point located at the center of the coordinate system</summary>
    public: static const Point3<TScalar> Zero;

    /// <summary>Initializes a new point at the center of the coordinate frame</summary>
    public: Point3() {}

    /// <summary>Initializes a new point with the given coordinates</summary>
    /// <param name="x">X coordinate of the point</param>
    /// <param name="y">Y coordinate of the point</param>
    /// <param name="z">Z coordinate of the point</param>
    public: Point3(TScalar x, TScalar y, TScalar z) : X(x), Y(y), Z(z) {}

    /// <summary>Calculates the squared distance to another point</summary>
    /// <param name="other">Other point to which the distance will be calculated</param>
    /// <returns>The squared distance from this point to the other points</returns>
    public: TScalar SquaredDistanceTo(const Point3 &other) const {
      float offsetX = other.X - this->X;
      float offsetY = other.Y - this->Y;
      float offsetZ = other.Z - this->Z;

      return (offsetX * offsetX) + (offsetY * offsetY) + (offsetZ * offsetZ);
    }

    /// <summary>Calculates the squared distance to another point</summary>
    /// <param name="x">X coordinate to which the distance will be calculated</param>
    /// <param name="y">Y coordinate to which the distance will be calculated</param>
    /// <param name="z">Z coordinate to which the distance will be calculated</param>
    /// <returns>The squared distance from this point to the other points</returns>
    public: TScalar SquaredDistanceTo(TScalar x, TScalar y, TScalar z) const {
      float offsetX = x - this->X;
      float offsetY = y - this->Y;
      float offsetZ = z - this->Z;

      return (offsetX * offsetX) + (offsetY * offsetY) + (offsetZ * offsetZ);
    }

    /// <summary>Calculates the distance to another point</summary>
    /// <param name="other">Other point to which the distance will be calculated</param>
    /// <returns>The distance from this point to the other points</returns>
    public: TScalar DistanceTo(const Point3 &other) const {
      return Math<TScalar>::SquareRoot(SquaredDistanceTo(other));
    }

    /// <summary>Calculates the distance to another point</summary>
    /// <param name="x">X coordinate to which the distance will be calculated</param>
    /// <param name="y">Y coordinate to which the distance will be calculated</param>
    /// <param name="z">Z coordinate to which the distance will be calculated</param>
    /// <returns>The distance from this point to the other points</returns>
    public: TScalar DistanceTo(TScalar x, TScalar y, TScalar z) const {
      return Math<TScalar>::SquareRoot(SquaredDistanceTo(x, y, z));
    }

    /// <summary>Calculates the squared distance between two points</summary>
    /// <param name="first">First point for the distance calculation</param>
    /// <param name="second">Second point for the distance calculation</param>
    /// <returns>The squared distance between the two points</returns>
    public: static TScalar SquaredDistanceBetween(const Point3 &first, const Point3 &second) {
      float offsetX = first.X - second.X;
      float offsetY = first.Y - second.Y;
      float offsetZ = first.Z - second.Z;

      return (offsetX * offsetX) + (offsetY * offsetY) + (offsetZ * offsetZ);
    }

    /// <summary>Calculates the distance between two points</summary>
    /// <param name="first">First point for the distance calculation</param>
    /// <param name="second">Second point for the distance calculation</param>
    /// <returns>The distance between the two points</returns>
    public: static TScalar DistanceBetween(const Point3 &first, const Point3 &second) {
      return Math<TScalar>::SquareRoot(Point3::DistanceBetween(first, second));
    }

    /// <summary>Linearly interpolates between two points</summary>
    /// <param name="left">Point from which the interpolation begins</param>
    /// <param name="right">Point to which the interpolation leds</param>
    /// <param name="t">Interpolation point between the two points</param>
    /// <returns>The interpolated point at <see cref="t" /></returns>
    public: Point3 Lerp(Point3 left, Point3 right, TScalar t) {
      TScalar inverseT = 1 - t;
      return Point3(
        (left.X * inverseT) + (right.X * t),
        (left.Y * inverseT) + (right.Y * t),
        (left.Z * inverseT) + (right.Z * t)
      );
    }

    /// <summary>Moves the point by the specified offset</summary>
    /// <param name="offset">Offset by which the point will be moved</param>
    /// <returns>The point moved by the specified offset</returns>
    public: Point3 operator +(const Vector3<TScalar> &offset) const {
      return Point3(this->X + offset.X, this->Y + offset.Y, this->Z + offset.Z);
    }

    /// <summary>Moves the point against the specified offset</summary>
    /// <param name="offset">Offset against which the point will be moved</param>
    /// <returns>The point moved against the specified offset</returns>
    public: Point3 operator -(const Vector3<TScalar> &offset) const {
      return Point3(this->X - offset.X, this->Y - offset.Y, this->Z - offset.Z);
    }

    /// <summary>Calculates the offset from this point to another</summary>
    /// <param name="other">Other point to which the offset is calculated</param>
    /// <returns>The offset to the other point</returns>
    public: Vector3<TScalar> operator -(const Point3 &other) const {
      return Vector3<TScalar>(this->X - other.X, this->Y - other.Y, this->Z - other.Z);
    }

    /// <summary>Moves the point by a specified offset</summary>
    /// <param name="offset">Offset by which the point will be moved</param>
    /// <returns>The point after being moved by the specified offset</returns>
    public: Point3 operator +=(const Vector3<TScalar> &vector) {
      this->X += vector.X;
      this->Y += vector.Y;
      this->Z += vector.Z;
      return *this;
    }

    /// <summary>Moves the point against the specified offset</summary>
    /// <param name="offset">Offset against which the point will be move</param>
    /// <returns>The point after being moved against the specified offset</returns>
    public: Point3 operator -=(const Vector3<TScalar> &vector) {
      this->X -= vector.X;
      this->Y -= vector.Y;
      this->Z -= vector.Z;
      return *this;
    }

    /// <summary>Checks whether another point is equal to this one</summary>
    /// <param name="other">Other point that will be checked for equality</param>
    /// <returns>True if the other point is equal to this one</returns>
    public: bool operator ==(const Point3<TScalar> &other) const {
      return (this->X == other.X) && (this->Y == other.Y) && (this->Z == other.Z);
    }

    /// <summary>Checks whether another point is different from this one</summary>
    /// <param name="other">Other point that will be checked for inequality</param>
    /// <returns>True if the other point is different to this one</returns>
    public: bool operator !=(const Point3<TScalar> &other) const {
      return (this->X != other.X) || (this->Y != other.Y) || (this->Z != other.Z);
    }

    /// <summary>Location of the point on the X axis</summary>
    public: TScalar X;
    /// <summary>Location of the point on the Y axis</summary>
    public: TScalar Y;
    /// <summary>Location of the point on the Z axis</summary>
    public: TScalar Z;

  };

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

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

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

}} // namespace Nuclex::Geometry

#endif // NUCLEX_GEOMETRY_POINT3_H