#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_MATH_H
#error This file must be included through Math.h
#endif

namespace Nuclex { namespace Geometry {

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

  /// <summary>Math routines for geometry classes based on long double precision floats</summary>
  template <>
  class Math<long double> {

    /// <summary>The PI constant</summary>
    public: NUCLEX_GEOMETRY_API static constexpr long double Pi = (
      3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825L
    );

    /// <summary>Two times PI, useful for some operations</summary>
    public: NUCLEX_GEOMETRY_API static constexpr long double Perigon = (
      6.283185307179586476925286766559005768394338798750211641949889184615632812572417997256069651L
    );

    /// <summary>Calculates the square root of the specified value</summary>
    /// <param name="value">Value of which the square root is calculated</param>
    /// <returns>The square root of the specified number</returns>
    public: NUCLEX_GEOMETRY_API static long double SquareRoot(long double value) {
      return std::sqrt(value);
    }

    /// <summary>Returns a random number from 0.0 to the specified maximum</summary>
    /// <param name="random">The random number generator that will be used</param>
    /// <param name="max">Upper limit for the random number (exclusive)</param>
    /// <returns>A random number from 0.0 to the specified maximum</returns>
    public: template <typename TRandomNumberEngine> static long double Random(
      TRandomNumberEngine &random, long double max
    ) {
      std::uniform_real_distribution<long double> distribution(0.0, max);
      return distribution(random);
    }

    /// <summary>Returns a random number in the specified range</summary>
    /// <param name="random">The random number generator that will be used</param>
    /// <param name="min">Minimum possible value of the random number</param>
    /// <param name="max">Upper limit for the random number (exclusive)</param>
    /// <returns>A random number within the specified range</returns>
    public: template <typename TRandomNumberEngine> static long double Random(
      TRandomNumberEngine &random, long double min, long double max
    ) {
      std::uniform_real_distribution<long double> distribution(min, max);
      return distribution(random);
    }

    /// <summary>Calculates the sine of the specified angle</summary>
    /// <param name="angleInRadians">Angle for which the sine will be calculated</param>
    /// <returns>The sine of the specified angle</returns>
    public: NUCLEX_GEOMETRY_API static long double Sine(long double angleInRadians) {
      return std::sin(angleInRadians);
    }

    /// <summary>Calculates the cosine of the specified angle</summary>
    /// <param name="angleInRadians">Angle for which the cosine will be calculated</param>
    /// <returns>The cosine of the specified angle</returns>
    public: NUCLEX_GEOMETRY_API static long double Cosine(long double angleInRadians) {
      return std::cos(angleInRadians);
    }

    /// <summary>Calculates the angle of the specified sine value</summary>
    /// <param name="sineValue">Sine value of which the angle will be calculated</param>
    /// <returns>The angle of the specified sine value in radians</returns>
    public: NUCLEX_GEOMETRY_API static long double ArcSine(long double sineValue) {
      return std::asin(sineValue);
    }

    /// <summary>Calculates the angle of the specified cosine value</summary>
    /// <param name="cosineValue">Cosine value for which the angle will be calculated</param>
    /// <returns>The angle of the specified cosine value in radians</returns>
    public: NUCLEX_GEOMETRY_API static long double ArcCosine(long double cosineValue) {
      return std::acos(cosineValue);
    }

    /// <summary>Calculates the angle of the tangent specified by a direction</summary>
    /// <param name="x">X coordinate of the direction</param>
    /// <param name="y">Y coordinate of the direction</param>
    /// <returns>The angle of the tangent specified through the direction</returns>
    public: NUCLEX_GEOMETRY_API static long double ArcTangent(long double x, long double y) {
      return std::atan2(y, x);
    }

    /// <summary>Returns the absolute value of the specified value</summary>
    /// <param name="value">Value of which the absolute value will be returned</param>
    /// <returns>The absolute value of the provided value</returns>
    public: NUCLEX_GEOMETRY_API static long double Abs(long double value) {
      return std::fabs(value);
    }

    /// <summary>Calculates <see cref="value" /> to the power of <see cref="power" /></summary>
    /// <param name="value">Value that will be multiplied</param>
    /// <param name="power">To which power the value will be multiplied</param>
    /// <returns><see cref="value" /> to the power of <see cref="power" /></returns>
    public: NUCLEX_GEOMETRY_API static long double Power(long double value, long double power) {
      return std::pow(value, power);
    }

    /// <summary>Returns the smaller of two values</summary>
    /// <param name="first">First of the two values</param>
    /// <param name="second">Second of the two values</param>
    /// <returns>The smaller of the two provided values</returns>
    public: NUCLEX_GEOMETRY_API static long double Min(long double first, long double second) {
      return std::min(first, second);
    }

    /// <summary>Returns the smallest of three values</summary>
    /// <param name="first">First of the three values</param>
    /// <param name="second">Second of the three values</param>
    /// <param name="third">Third of the three values</param>
    /// <returns>The smallest of the three provided values</returns>
    public: NUCLEX_GEOMETRY_API static long double Min(
      long double first, long double second, long double third
    ) {
      return std::min(std::min(first, second), third);
    }

    /// <summary>Returns the larger of two values</summary>
    /// <param name="first">First of the two values</param>
    /// <param name="second">Second of the two values</param>
    /// <returns>The larger of the two provided values</returns>
    public: NUCLEX_GEOMETRY_API static long double Max(long double first, long double second) {
      return std::max(first, second);
    }

    /// <summary>Returns the largest of three values</summary>
    /// <param name="first">First of the three values</param>
    /// <param name="second">Second of the three values</param>
    /// <param name="third">Third of the three values</param>
    /// <returns>The largest of the three provided values</returns>
    public: NUCLEX_GEOMETRY_API static long double Max(
      long double first, long double second, long double third
    ) {
      return std::max(std::max(first, second), third);
    }

    /// <summary>Determines the extremes of two values</summary>
    /// <param name="first">First of the values whose extremes will be found</param>
    /// <param name="second">Second of the values whose extremes will be found</param>
    /// <returns>
    ///   A pair containing the smaller and the larger value in that order
    /// </returns>
    public: NUCLEX_GEOMETRY_API static std::pair<long double, long double> Extremes(
      long double first, long double second
    ) {
      if(first < second) {
        return std::pair<long double, long double>(first, second);
      } else {
        return std::pair<long double, long double>(second, first);
      }
    }

    /// <summary>Determines the extremes of three values</summary>
    /// <param name="first">First of the values whose extremes will be found</param>
    /// <param name="second">Second of the values whose extremes will be found</param>
    /// <param name="third">Third of the values whose extremes will be found</param>
    /// <returns>
    ///   A pair containing the smallest and the largest value of the three inputs
    /// </returns>
    public: NUCLEX_GEOMETRY_API static std::pair<long double, long double> Extremes(
      long double first, long double second, long double third
    ) {
      if(first < second) {
        if(second < third) { // first < second < third
          return std::make_pair(first, third);
        } else if(first < third) { // first < third < second
          return std::make_pair(first, second);
        } else { // third < first < second
          return std::make_pair(third, second);
        }
      } else {
        if(first < third) { // second < first < third
          return std::make_pair(second, third);
        } else if(second < third) { // second < third < first
          return std::make_pair(second, first);
        } else { // third < second < first
          return std::make_pair(third, first);
        }
      }
    }

    /// <summary>Unwinds a value in a circular (repeating) value range</summary>
    /// <param name="value">Value that will be unwound</param>
    /// <param name="min">Lower limit of the circular value range</param>
    /// <param name="max">Upper limit of the circular value range</param>
    /// <returns>The unwound value</returns>
    public: NUCLEX_GEOMETRY_API static long double Unwind(
      long double value, long double min, long double max
    ) {
      long double range = (max - min);
      long double floor = std::floor((value - min) / range);
      return value - (floor * range);
    }

    /// <summary>Limits the value to the specified range</summary>
    /// <param name="value">Value that will be limited</param>
    /// <param name="min">Minimum the value cannot go under</param>
    /// <param name="max">Maximum the value cannot go above</param>
    /// <returns>The value limited to the specified range</returns>
    public: NUCLEX_GEOMETRY_API static long double Clamp(
      long double value, long double min, long double max
    ) {
      if(value < min) {
        return min;
      }
      if(value > max) {
        return max;
      }

      return value;
    }

    /// <summary>Linearly interpolates between two values</summary>
    /// <param name="left">Value at the left interpolation point</param>
    /// <param name="right">Value at the right interpolation point</param>
    /// <param name="t">Time (0.0 .. 1.0) for which to interpolate the value</param>
    /// <returns>The interpolated value at the specified time</returns>
    public: NUCLEX_GEOMETRY_API static long double Lerp(
      long double left, long double right, long double t
    ) {
      return (right - left) * t + left;
    }

    /// <summary>Calculates the time of a linearly interpolated value</summary>
    /// <param name="left">Value at the left interpolation point</param>
    /// <param name="right">Value at the right interpolation point</param>
    /// <param name="value">Value that resulted from the interpolation</param>
    /// <returns>Time at which the value is placed in the interpolation range</returns>
    public: NUCLEX_GEOMETRY_API static long double Unlerp(
      long double left, long double right, long double value
    ) {
      return (value - left) / (right - left);
    }

    /// <summary>Checks whether the specified value is invalid (not a number)</summary>
    /// <param name="value">Value that will be checked</param>
    /// <returns>True if the specified value is not a number</returns>
    public: NUCLEX_GEOMETRY_API static bool IsNan(long double value) {
      return std::isnan(value);
    }

  };

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

}} // namespace Nuclex::Geometry