#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_POINT2_H
#define NUCLEX_GEOMETRY_POINT2_H

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

namespace Nuclex { namespace Geometry {

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

  /// <summary>Point in 2D 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 Point2 {

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

    /// <summary>Constructs a new uninitialized point</summary>
    public: Point2() {}

    /// <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>
    public: Point2(TScalar x, TScalar y) : X(x), Y(y) {}

    /// <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 point</returns>
    public: TScalar SquaredDistanceTo(const Point2 &other) const {
      float offsetX = other.X - this->X;
      float offsetY = other.Y - this->Y;

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

    /// <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>
    /// <returns>The squared distance from this point to the other point</returns>
    public: TScalar SquaredDistanceTo(TScalar x, TScalar y) const {
      float offsetX = x - this->X;
      float offsetY = y - this->Y;

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

    /// <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 point</returns>
    public: TScalar DistanceTo(const Point2 &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>
    /// <returns>The distance from this point to the other point</returns>
    public: TScalar DistanceTo(TScalar x, TScalar y) const {
      return Math<TScalar>::SquareRoot(SquaredDistanceTo(x, y));
    }

    /// <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 Point2 &first, const Point2 &second) {
      float offsetX = first.X - second.X;
      float offsetY = first.Y - second.Y;

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

    /// <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 Point2 &first, const Point2 &second) {
      return Math<TScalar>::SquareRoot(Point2::SquaredDistanceBetween(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: static Point2 Lerp(Point2 left, Point2 right, TScalar t) {
      TScalar inverseT = 1 - t;
      return Point2(
        (left.X * inverseT) + (right.X * t),
        (left.Y * inverseT) + (right.Y * t)
      );
    }

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

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

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

    /// <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: Point2 operator +=(const Vector2<TScalar> &vector) {
      this->X += vector.X;
      this->Y += vector.Y;
      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: Point2 operator -=(const Vector2<TScalar> &vector) {
      this->X -= vector.X;
      this->Y -= vector.Y;
      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 Point2<TScalar> &other) const {
      return (this->X == other.X) && (this->Y == other.Y);
    }

    /// <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 Point2<TScalar> &other) const {
      return (this->X != other.X) || (this->Y != other.Y);
    }

    /// <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;

  };

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

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

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

}} // namespace Nuclex::Geometry

#endif // NUCLEX_GEOMETRY_POINT2_H