#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_CURVE2INTERPOLATOR_H
#define NUCLEX_GEOMETRY_LINES_INTERPOLATORS_CURVE2INTERPOLATOR_H

#include "Nuclex/Geometry/Config.h"
#include "Nuclex/Geometry/Lines/Curve2.h"

#include "Nuclex/Geometry/Lines/Interpolators/NearestInterpolator.h"
#include "Nuclex/Geometry/Lines/Interpolators/LinearInterpolator.h"
#include "Nuclex/Geometry/Lines/Interpolators/CosineInterpolator.h"
#include "Nuclex/Geometry/Lines/Interpolators/CubicInterpolator.h"

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

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

  /// <summary>Interpolates along the vertices of a 2D curve</summary>
  /// <typeparam name="TScalar">Type of values used to store the curve's vertices</typeparam>
  template<typename TScalar>
  struct Curve2Interpolator {

    #pragma region struct Point2VertexTraits

    /// <summary>Vertex traits for Point2 types when used in interpolators</summary>
    private: struct Point2VertexTraits {

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

      /// <summary>A vertex with a value of zero</summary>
      public: static const Point2<TScalar> ZeroVertex;

      /// <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(
        const Point2<TScalar> &first, const Point2<TScalar> &second
      ) {
        return Point2<TScalar>::DistanceBetween(first, second);
      }

      /// <summary>Sums a point with another point</summary>
      /// <param name="base">Point to which another point wlll be added</param>
      /// <param name="amount">Other point that will be added to the point</param>
      public: static void Add(Point2<TScalar> &base, Point2<TScalar> amount) {
        base.X += amount.X;
        base.Y += amount.Y;
      }

      /// <summary>Subtracts another point from a point</summary>
      /// <param name="base">Point from which another point wlll be subtracted</param>
      /// <param name="amount">Other point that will be substracted from the point</param>
      public: static void Subtract(Point2<TScalar> &base, Point2<TScalar> amount) {
        base.X -= amount.X;
        base.Y -= amount.Y;
      }

      /// <summary>Scales a point by a factor</summary>
      /// <param name="base">Point that will be scaled by a factor</param>
      /// <param name="factor">Factor the point will be scaled by</param>
      public: static void Scale(Point2<TScalar> &base, TScalar factor) {
        base.X *= factor;
        base.Y *= factor;
      }

      /// <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(TScalar t) {
        return static_cast<std::size_t>(t + 0.5);
      }

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

    };

    #pragma endregion // struct Point2VertexTraits

    /// <summary>Interpolator that searches for the nearest vertex</summary>
    public: typedef Interpolators::NearestInterpolator<
      Point2<TScalar>, Point2VertexTraits
    > NearestInterpolatorType;

    /// <summary>Interpolator that linearly interpolates along a path</summary>
    public: typedef Interpolators::LinearInterpolator<
      Point2<TScalar>, Point2VertexTraits
    > LinearInterpolatorType;

    /// <summary>Interpolator that uses cosine interpolation along a path</summary>
    public: typedef Interpolators::CosineInterpolator<
      Point2<TScalar>, Point2VertexTraits
    > CosineInterpolatorType;

    /// <summary>Interpolator that uses cubic interpolation along a path</summary>
    public: typedef Interpolators::CubicInterpolator<
      Point2<TScalar>, Point2VertexTraits
    > CubicInterpolatorType;

    /// <summary>Interpolates a point along the curve</summary>
    /// <param name="t">Time at which the point will be interpolated</param>
    /// <returns>The point at the specified time</returns>
    public: static Point2<TScalar> InterpolateByTime(const Curve2<TScalar> &curve, TScalar t) {
      switch(curve.InterpolationMethod) {
        case CurveInterpolationMethod::Closest: {
          return NearestInterpolatorType::InterpolateByTime(
            curve.Vertices.begin(), curve.Vertices.end(), t
          );
        }
        case CurveInterpolationMethod::Linear: {
          return LinearInterpolatorType::InterpolateByTime(
            curve.Vertices.begin(), curve.Vertices.end(), t
          );
        }
        case CurveInterpolationMethod::Cosine: {
          return CosineInterpolatorType::InterpolateByTime(
            curve.Vertices.begin(), curve.Vertices.end(), t
          );
        }
        case CurveInterpolationMethod::Cubic: {
          return CubicInterpolatorType::InterpolateByTime(
            curve.Vertices.begin(), curve.Vertices.end(), t
          );
        }
        default: {
          throw std::runtime_error("Unknown interpolation method");
        }
      }
    }

    /// <summary>Estimates the length of the curve</summary>
    /// <returns>The estimated length of the curve</returns>
    public: static TScalar EstimateLength(const Curve2<TScalar> &curve) {
      switch(curve.InterpolationMethod) {
        case CurveInterpolationMethod::Closest: {
          return NearestInterpolatorType::EstimateLength(
            curve.Vertices.begin(), curve.Vertices.end()
          );
        }
        case CurveInterpolationMethod::Linear: {
          return LinearInterpolatorType::EstimateLength(
            curve.Vertices.begin(), curve.Vertices.end()
          );
        }
        case CurveInterpolationMethod::Cosine: {
          return CosineInterpolatorType::EstimateLength(
            curve.Vertices.begin(), curve.Vertices.end()
          );
        }
        case CurveInterpolationMethod::Cubic: {
          return CubicInterpolatorType::EstimateLength(
            curve.Vertices.begin(), curve.Vertices.end()
          );
        }
        default: {
          throw std::runtime_error("Unknown interpolation method");
        }
      }
    }

  };

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

  template<typename TScalar>
  const Point2<TScalar> Curve2Interpolator<TScalar>::Point2VertexTraits::ZeroVertex(0, 0);

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


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

#endif // NUCLEX_GEOMETRY_LINES_INTERPOLATORS_CURVE2INTERPOLATOR_H