#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_NEARESTINTERPOLATOR_H
#define NUCLEX_GEOMETRY_LINES_INTERPOLATORS_NEARESTINTERPOLATOR_H

#include "Nuclex/Geometry/Config.h"
#include "Nuclex/Geometry/Lines/CurveInterpolationMethod.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 clamps to the nearest vertex in a sequence</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 NearestInterpolator {

    /// <summary>Returns the closest vertex to 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 closest vertex to 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;
      }

      // Round to closest vertex index
      std::size_t nearestVertexIndex = TVertexTraits::RoundScalarToInteger(t);

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

      // Regular query, return closest vertex
      return *(first + nearestVertexIndex);

    }

    /// <summary>Returns the closest vertex to 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 closest vertex to the specified distance</returns>
    public: template<typename TVertexIterator>
    static TVertex InterpolateByDistance(
      TVertexIterator first, TVertexIterator onePastLast,
      typename TVertexTraits::TDistance distance
    ) {

      // Empty vertex list? Return the 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 the closer of the to vertices
      ++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) {
          if(segmentLength - distance > distance) { // Closer to left vertex?
            return previous;
          } else { // Closer to right vertex
            return current;
          }
        }

        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 the curve</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 curve</returns>
    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 TVertexTraits::ZeroVertex;
      }

      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_NEARESTINTERPOLATOR_H