#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
#define NUCLEX_GEOMETRY_MATH_H

#include "Nuclex/Geometry/Config.h"

#include <algorithm>
#include <utility>
#include <cmath>
#include <random>

namespace Nuclex { namespace Geometry {

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

  /// <summary>Provides math routines to the other geometry classes</summary>
  template <typename TScalar>
  class Math {

    /// <summary>The PI constant</summary>
    public: static constexpr TScalar Pi = (
      3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253
    );

    /// <summary>Two times PI, useful for some operations</summary>
    public: static constexpr TScalar Perigon = (
      6.2831853071795864769252867665590057683943387987502116419498891846156328125724179972560696507
    );

    /// <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: static TScalar SquareRoot(TScalar 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 TScalar Random(
      TRandomNumberEngine &random, TScalar max
    ) {
      std::uniform_real_distribution<TScalar> distribution(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 TScalar Random(
      TRandomNumberEngine &random, TScalar min, TScalar max
    ) {
      std::uniform_real_distribution<TScalar> 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: static TScalar Sine(TScalar 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: static TScalar Cosine(TScalar 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: static TScalar ArcSine(TScalar 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: static TScalar ArcCosine(TScalar 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: static TScalar ArcTangent(TScalar x, TScalar 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: static TScalar Abs(TScalar 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: static TScalar Power(TScalar value, TScalar 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: static TScalar Min(TScalar first, TScalar 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: static TScalar Min(TScalar first, TScalar second, TScalar 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: static TScalar Max(TScalar first, TScalar 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: static TScalar Max(TScalar first, TScalar second, TScalar 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: static std::pair<TScalar, TScalar> Extremes(
      TScalar first, TScalar second
    ) {
      if(first < second) {
        return std::pair<TScalar, TScalar>(first, second);
      } else {
        return std::pair<TScalar, TScalar>(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: static std::pair<TScalar, TScalar> Extremes(
      TScalar first, TScalar second, TScalar 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);
        }
      }
    }

/*
    public: static std::ptrdiff_t RoundToDiffT(TScalar value) {
      return static_cast<std::ptrdiff_t>(value);
    }

    public: static std::size_t RoundToSizeT(TScalar value) {
      return static_cast<std::size_t>(value);
    }
*/

    /// <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: static TScalar Unwind(TScalar value, TScalar min, TScalar max) {
      TScalar range = (max - min);
      TScalar 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: static TScalar Clamp(TScalar value, TScalar min, TScalar 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: static TScalar Lerp(TScalar left, TScalar right, TScalar 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: static TScalar Unlerp(TScalar left, TScalar right, TScalar 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: static bool IsNan(TScalar value) {
      return std::isnan(value);
    }

  };

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

}} // namespace Nuclex::Geometry

#include "Math.Float.inl"
#include "Math.Double.inl"
#include "Math.LongDouble.inl"

#endif // NUCLEX_GEOMETRY_MATH_H