#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_LINES_INTERPOLATORS_COSINEINTERPOLATOR_H
#define NUCLEX_GEOMETRY_LINES_INTERPOLATORS_COSINEINTERPOLATOR_H

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

#include <cstddef>

namespace Nuclex { namespace Geometry { namespace Lines { namespace Interpolators {

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

  #if 0

  /// <summary>Example implementation of the TVertexTraits type</summary>
  struct ExampleVertexTraits {

    /// <summary>Type that is used to measure distance between vertices</summary>
    public: typedef float TDistance;
    /// <summary>Type that is used to specify the interpolation interval</summary>
    public: typedef float TScalar;

    /// <summary>A vertex with a value of zero</summary>
    public: static const float ZeroVertex = 0.0f;

    /// <summary>Measures the distance between two vertices</summary>
    /// <param name="first">First vertex for the distance calculation</param>
    /// <param name="second">Second vertex for the distance calculation</param>
    /// <returns>The distance between the two vertices</returns>
    public: static TDistance DistanceBetween(float first, float second) {
      return std::abs(second - first),
    }

    /// <summary>Rounds a scalar / interval value to the closest integer</summary>
    /// <param name="t">Scalar / interval value that will be rounded</param>
    /// <returns>The closest integer to the specified scalar / interval value</returns>
    public: static std::size_t RoundScalarToInteger(float t) {
      return static_cast<std::size_t>(t + 0.5f);
    }

    /// <summary>Truncates a scalar / interval value to the next lower integer</summary>
    /// <param name="t">Scalar / interval value that will be truncated</param>
    /// <returns>The next lower integer to the specified scalar / interval value</returns>
    public: static std::size_t TruncateScalarToInteger(float t) {
      return static_cast<std::size_t>(t);
    }

  };

  #endif

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

  /// <summary>Interpolator that eases in and out between vertices</summary>
  /// <typeparam name="TVertex">Type of the interpolated values</typeparam>
  /// <typeparam name="TVertexTraits">Additional information about the vertex type</typeparam>
  template <typename TVertex, typename TVertexTraits>
  struct CosineInterpolator {

    /// <summary>
    ///   Performs cosine interpolation between the vertices at the specified time index
    /// </summary>
    /// <typeparam name="TVertexIterator">Type of the iterator used to find vertices</typeparam>
    /// <param name="first">Iterator pointing to the first vertex</param>
    /// <param name="onePastLast">Iterator pointing one past the last vertex</param>
    /// <param name="t">Interpolation time index, equivalent to vertex index</param>
    /// <returns>The cosine-interpolated position at the specified time index</returns>
    public: template<typename TVertexIterator>
    static TVertex InterpolateByTime(
      TVertexIterator first, TVertexIterator onePastLast, typename TVertexTraits::TScalar t
    ) {

      // Empty vertex list? Return default value
      if(onePastLast == first) {
        return TVertexTraits::ZeroVertex;
      }

      // Asking for a time before the first vertex? Clamp to first vertex
      if(t < 0) {
        return *first;
      }

      // Truncate to obtain left vertex and right vertex index
      std::size_t leftVertexIndex = TVertexTraits::TruncateScalarToInteger(t);
      std::size_t rightVertexIndex = leftVertexIndex + 1;  

      // Asking for a time past the last vertex? Clamp to last vertex
      std::size_t count = onePastLast - first;
      if(rightVertexIndex > count - 1) {
        return *(onePastLast - 1);
      }

      // At this point we know the leftVertex is at least index 0 and
      // the rightVertex is at least one before the end. Interpolate.
      t -= leftVertexIndex;
      t = 1 - Math<typename TVertexTraits::TScalar>::Cosine(
        t * Math<typename TVertexTraits::TScalar>::Pi
      );
      t /= 2;
      TVertex leftVertex = *(first + leftVertexIndex);
      TVertex rightVertex = *(first + rightVertexIndex);
      leftVertex += (rightVertex - leftVertex) * t;
      return leftVertex;

    }

    /// <summary>
    ///   Performs cosine interpolation between the vertices at the specified distance
    /// </summary>
    /// <typeparam name="TVertexIterator">Type of the iterator used to find vertices</typeparam>
    /// <param name="first">Iterator pointing to the first vertex</param>
    /// <param name="onePastLast">Iterator pointing one past the last vertex</param>
    /// <param name="distance">Distance along the path to interpolate</param>
    /// <returns>The cosine-interpolated position at the specified distance</returns>
    /// <remarks>
    ///   This is identical to the linear interpolator because the cosine interpolator's
    ///   path differs in time, but not in space (the curve you may know from friendly
    ///   illustrations is a 1D interpolation where the X axis is time).
    /// </remarks>
    public: template<typename TVertexIterator>
    static TVertex InterpolateByDistance(
      TVertexIterator first, TVertexIterator onePastLast,
      typename TVertexTraits::TDistance distance
    ) {

      // Empty vertex list? Return default value
      if(onePastLast == first) {
        return TVertexTraits::ZeroVertex;
      }

      // If the distance is zero or less, return the starting point
      TVertex previous = *first;
      if(distance < 0) {
        return previous;
      }

      // Go through all segments and if the distance falls into the current segment,
      // return interpolated position on the current segment;
      ++first;
      while(first != onePastLast) {
        TVertex current = *first;
        typename TVertexTraits::TDistance segmentLength = TVertexTraits::DistanceBetween(
          previous, current
        );

        // Does the user-specified distance fall into this segment?
        if (segmentLength >= distance) {
          typename TVertexTraits::TScalar t = distance / segmentLength;
          previous += (current - previous) * t;
          return previous;
        }

        distance -= segmentLength;
        previous = current;
        ++first;
      }

      // Specified distance was beyond the end of the path, return the lastmost
      // vertex we processed (thereby clamping to the end of the path)
      return previous;

    }

    /// <summary>Estimates the length of a path when cosine-interpolated</summary>
    /// <typeparam name="TVertexIterator">Type of the iterator used to find vertices</typeparam>
    /// <param name="first">Iterator pointing to the first vertex</param>
    /// <param name="onePastLast">Iterator pointing one past the last vertex</param>
    /// <returns>The length of the path</returns>
    /// <remarks>
    ///   This is identical to the linear interpolator because the cosine interpolator's
    ///   path differs in time, but not in space (the curve you may know from friendly
    ///   illustrations is a 1D interpolation where the X axis is time).
    /// </remarks>
    public: template<typename TVertexIterator>
    static typename TVertexTraits::TDistance EstimateLength(
      TVertexIterator first, TVertexIterator onePastLast
    ) {

      // Empty vertex list? The path has a length of 0
      if(onePastLast == first) {
        return 0;
      }

      TVertex previous = *first;
      typename TVertexTraits::TDistance distance = 0;

      // Advance through all points, accumulating the total distance
      ++first;
      while(first != onePastLast) {
        TVertex current = *first;
        distance += TVertexTraits::DistanceBetween(previous, current);
        previous = current;
        ++first;
      }

      return distance;

    }

  };

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

}}}} // namespace Nuclex::Geometry::Lines::Interpolators

#endif // NUCLEX_GEOMETRY_LINES_INTERPOLATORS_COSINEINTERPOLATOR_H