#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

// If the library is compiled as a DLL, this ensures symbols are exported
#define NUCLEX_GEOMETRY_SOURCE 1

#include "Nuclex/Geometry/Lines/Interpolators/CubicInterpolator.h"
#include "Nuclex/Geometry/Point2.h"
#include <gtest/gtest.h>

namespace {

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

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

    /// <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 Nuclex::Geometry::Point2<float> 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 Nuclex::Geometry::Point2<float> &first,
      const Nuclex::Geometry::Point2<float> &second
    ) {
      return Nuclex::Geometry::Point2<float>::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(
      Nuclex::Geometry::Point2<float> &base, Nuclex::Geometry::Point2<float> 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(
      Nuclex::Geometry::Point2<float> &base, Nuclex::Geometry::Point2<float> 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(Nuclex::Geometry::Point2<float> &base, float 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(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);
    }

  };

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

  const Nuclex::Geometry::Point2<float> Point2VertexTraits::ZeroVertex(0.0f, 0.0f);

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

  /// <summary>Verifies that a point lies near to another point</summary>
  /// <param name="first">First point that will be compared</param>
  /// <param name="second">Second point that will be compared</param>
  /// <returns>True if the first point is near the 
  void ExpectIsNear(
    const Nuclex::Geometry::Point2<float> &first,
    const Nuclex::Geometry::Point2<float> &second
  ) {
    const float Tolerance = 1.e-005f;

    EXPECT_NEAR(first.X, second.X, Tolerance);
    EXPECT_NEAR(first.Y, second.Y, Tolerance);
  }

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

  /// <summary>Interpolator we use for testing</summary>
  typedef Nuclex::Geometry::Lines::Interpolators::CubicInterpolator<
    Nuclex::Geometry::Point2<float>, Point2VertexTraits
  > InterpolatorType;

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

} // anonymous namespace

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

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

  TEST(CubicInterpolatorTest, InterpolateByTimeHandlesEmptyPath) {
    std::vector<Point2<float>> vertices;
    EXPECT_EQ(
      Point2<float>::Zero,
      InterpolatorType::InterpolateByTime(vertices.begin(), vertices.end(), 0.5f)
    );
  }

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

  TEST(CubicInterpolatorTest, InterpolateByTimeHandlesSingleVertex) {
    std::vector<Point2<float>> vertices;
    vertices.push_back(Point2<float>(5.0f, 5.0f));

    EXPECT_EQ(
      vertices[0],
      InterpolatorType::InterpolateByTime(vertices.begin(), vertices.end(), -1.1f)
    );
    EXPECT_EQ(
      vertices[0],
      InterpolatorType::InterpolateByTime(vertices.begin(), vertices.end(), 0.0f)
    );
    EXPECT_EQ(
      vertices[0],
      InterpolatorType::InterpolateByTime(vertices.begin(), vertices.end(), 1.1f)
    );
  }

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

  TEST(CubicInterpolatorTest, VertexCanBeInterpolatedByTime) {
    std::vector<Point2<float>> vertices;
    vertices.push_back(Point2<float>(1.0f, 5.0f));
    vertices.push_back(Point2<float>(10.0f, 6.0f));
    vertices.push_back(Point2<float>(9.0f, 10.0f));
    vertices.push_back(Point2<float>(5.0f, 1.0f));

    EXPECT_EQ(
      vertices[0],
      InterpolatorType::InterpolateByTime(vertices.begin(), vertices.end(), 0.0f)
    );
    ExpectIsNear(
      Point2<float>(3.296875f, 5.0625f),
      InterpolatorType::InterpolateByTime(vertices.begin(), vertices.end(), 0.25f)
    );
    ExpectIsNear(
      Point2<float>(7.890625f, 5.1875f),
      InterpolatorType::InterpolateByTime(vertices.begin(), vertices.end(), 0.75f)
    );
    ExpectIsNear(
      Point2<float>(8.072f, 8.712f),
      InterpolatorType::InterpolateByTime(vertices.begin(), vertices.end(), 2.2f)
    );
    ExpectIsNear(
      Point2<float>(5.768f, 2.928f),
      InterpolatorType::InterpolateByTime(vertices.begin(), vertices.end(), 2.8f)
    );
  }

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

  TEST(CubicInterpolatorTest, InterpolateByTimeClamps) {
    std::vector<Point2<float>> vertices;
    vertices.push_back(Point2<float>(1.0f, 5.0f));
    vertices.push_back(Point2<float>(10.0f, 1.0f));
    vertices.push_back(Point2<float>(5.0f, 10.0f));

    EXPECT_EQ(
      vertices[0],
      InterpolatorType::InterpolateByTime(vertices.begin(), vertices.end(), -0.1f)
    );
    EXPECT_EQ(
      vertices[0],
      InterpolatorType::InterpolateByTime(vertices.begin(), vertices.end(), -2.5f)
    );
    EXPECT_EQ(
      vertices[2],
      InterpolatorType::InterpolateByTime(vertices.begin(), vertices.end(), 2.1f)
    );
    EXPECT_EQ(
      vertices[2],
      InterpolatorType::InterpolateByTime(vertices.begin(), vertices.end(), 4.5f)
    );
  }

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

  TEST(CubicInterpolatorTest, InterpolateByDistanceHandlesEmptyPath) {
    std::vector<Point2<float>> vertices;
    EXPECT_EQ(
      Point2<float>::Zero,
      InterpolatorType::InterpolateByDistance(vertices.begin(), vertices.end(), 0.5f)
    );
  }

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

  TEST(CubicInterpolatorTest, InterpolateByDistanceHandlesSingleVertex) {
    std::vector<Point2<float>> vertices;
    vertices.push_back(Point2<float>(5.0f, 5.0f));

    EXPECT_EQ(
      vertices[0],
      InterpolatorType::InterpolateByDistance(vertices.begin(), vertices.end(), -1.1f)
    );
    EXPECT_EQ(
      vertices[0],
      InterpolatorType::InterpolateByDistance(vertices.begin(), vertices.end(), 0.0f)
    );
    EXPECT_EQ(
      vertices[0],
      InterpolatorType::InterpolateByDistance(vertices.begin(), vertices.end(), 1.1f)
    );
  }

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

  TEST(CubicInterpolatorTest, VertexCanBeInterpolatedByDistance) {
    std::vector<Point2<float>> vertices;
    vertices.push_back(Point2<float>(1.0f, 5.0f));
    vertices.push_back(Point2<float>(10.0f, 6.0f));
    vertices.push_back(Point2<float>(9.0f, 10.0f));
    vertices.push_back(Point2<float>(5.0f, 1.0f));

    EXPECT_EQ(
      vertices[0],
      InterpolatorType::InterpolateByDistance(vertices.begin(), vertices.end(), 0.0f)
    );
    ExpectIsNear(
      Point2<float>(5.5348591023442699f, 5.0001860366579622f),
      InterpolatorType::InterpolateByDistance(vertices.begin(), vertices.end(), 4.5f)
    );
    ExpectIsNear(
      Point2<float>(5.6356805274240491f, 5.0000026729331379f),
      InterpolatorType::InterpolateByDistance(vertices.begin(), vertices.end(), 4.6f)
    );
    ExpectIsNear(
      Point2<float>(7.9330876753704489f, 8.4554048020316213f),
      InterpolatorType::InterpolateByDistance(vertices.begin(), vertices.end(), 18.0f)
    );
    ExpectIsNear(
      Point2<float>(7.8481170698040952f, 8.2902662879818756f),
      InterpolatorType::InterpolateByDistance(vertices.begin(), vertices.end(), 18.2f)
    );
  }

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

  TEST(CubicInterpolatorTest, InterpolateByDistanceClamps) {
    std::vector<Point2<float>> vertices;
    vertices.push_back(Point2<float>(1.0f, 5.0f));
    vertices.push_back(Point2<float>(10.0f, 1.0f));
    vertices.push_back(Point2<float>(5.0f, 10.0f));

    EXPECT_EQ(
      vertices[0],
      InterpolatorType::InterpolateByDistance(vertices.begin(), vertices.end(), -0.1f)
    );
    EXPECT_EQ(
      vertices[0],
      InterpolatorType::InterpolateByDistance(vertices.begin(), vertices.end(), -15.0f)
    );
    EXPECT_EQ(
      vertices[2],
      InterpolatorType::InterpolateByDistance(vertices.begin(), vertices.end(), 23.1f)
    );
    EXPECT_EQ(
      vertices[2],
      InterpolatorType::InterpolateByDistance(vertices.begin(), vertices.end(), 35.0f)
    );
  }

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

  TEST(CubicInterpolatorTest, LengthHandlesEmptyPath) {
    std::vector<Point2<float>> vertices;
    EXPECT_EQ(
      0.0f, InterpolatorType::EstimateLength(vertices.begin(), vertices.end())
    );
  }

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

  TEST(CubicInterpolatorTest, LengthCanBeEstimated) {
    std::vector<Point2<float>> vertices;
    vertices.push_back(Point2<float>(1.0f, 5.0f));
    vertices.push_back(Point2<float>(10.0f, 6.0f));
    vertices.push_back(Point2<float>(9.0f, 10.0f));
    vertices.push_back(Point2<float>(5.0f, 1.0f));

    EXPECT_NEAR(
      25.599182241049128f,
      InterpolatorType::EstimateLength(vertices.begin(), vertices.end()),
      0.001f
    );
  }

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

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