#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/LinearInterpolator.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>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-006f;

    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::LinearInterpolator<
    Nuclex::Geometry::Point2<float>, Point2VertexTraits
  > InterpolatorType;

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

} // anonymous namespace

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

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

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

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

  TEST(LinearInterpolatorTest, 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(LinearInterpolatorTest, 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)
    );
    EXPECT_EQ(
      Point2<float>(5.41f, 5.49f),
      InterpolatorType::InterpolateByTime(vertices.begin(), vertices.end(), 0.49f)
    );
    EXPECT_EQ(
      Point2<float>(5.59f, 5.51f),
      InterpolatorType::InterpolateByTime(vertices.begin(), vertices.end(), 0.51f)
    );
    EXPECT_EQ(
      Point2<float>(7.08f, 5.68f),
      InterpolatorType::InterpolateByTime(vertices.begin(), vertices.end(), 2.48f)
    );
    EXPECT_EQ(
      Point2<float>(6.92f, 5.32f),
      InterpolatorType::InterpolateByTime(vertices.begin(), vertices.end(), 2.52f)
    );
  }

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

  TEST(LinearInterpolatorTest, 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(LinearInterpolatorTest, InterpolateByDistanceHandlesEmptyPath) {
    std::vector<Point2<float>> vertices;
    EXPECT_EQ(
      Point2<float>::Zero,
      InterpolatorType::InterpolateByDistance(vertices.begin(), vertices.end(), 0.5f)
    );
  }

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

  TEST(LinearInterpolatorTest, 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(LinearInterpolatorTest, 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.4724768060312850411736491557f, 5.4969418673368094490192943506f),
      InterpolatorType::InterpolateByDistance(vertices.begin(), vertices.end(), 4.5f)
    );
    ExpectIsNear(
      Point2<float>(5.5718651794986469309775080258f, 5.5079850199442941034419453362f),
      InterpolatorType::InterpolateByDistance(vertices.begin(), vertices.end(), 4.6f)
    );
    ExpectIsNear(
      Point2<float>(7.0417996347289572632238987003f, 5.5940491781401538422537720758f),
      InterpolatorType::InterpolateByDistance(vertices.begin(), vertices.end(), 18.0f)
    );
    ExpectIsNear(
      Point2<float>(6.9605719415182677397455794309f, 5.4112868684161024144275537196f),
      InterpolatorType::InterpolateByDistance(vertices.begin(), vertices.end(), 18.2f)
    );
  }

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

  TEST(LinearInterpolatorTest, 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(LinearInterpolatorTest, LengthHandlesEmptyPath) {
    std::vector<Point2<float>> vertices;
    EXPECT_EQ(
      0.0f, InterpolatorType::EstimateLength(vertices.begin(), vertices.end())
    );
  }

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

  TEST(LinearInterpolatorTest, LengthHandlesSingleVertex) {
    std::vector<Point2<float>> vertices;
    vertices.push_back(Point2<float>(5.0f, 5.0f));
    EXPECT_EQ(
      0.0f, InterpolatorType::EstimateLength(vertices.begin(), vertices.end())
    );
  }

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

  TEST(LinearInterpolatorTest, 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_EQ(
      23.027348565551183f,
      InterpolatorType::EstimateLength(vertices.begin(), vertices.end())
    );
  }

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

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