#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/NearestInterpolator.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>Interpolator we use for testing</summary>
  typedef Nuclex::Geometry::Lines::Interpolators::NearestInterpolator<
    Nuclex::Geometry::Point2<float>, Point2VertexTraits
  > InterpolatorType;

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

} // anonymous namespace

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

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

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

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

  TEST(NearestInterpolatorTest, 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(NearestInterpolatorTest, VertexCanBeFoundByTime) {
    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(
      vertices[0],
      InterpolatorType::InterpolateByTime(vertices.begin(), vertices.end(), 0.49f)
    );
    EXPECT_EQ(
      vertices[1],
      InterpolatorType::InterpolateByTime(vertices.begin(), vertices.end(), 0.51f)
    );
    EXPECT_EQ(
      vertices[2],
      InterpolatorType::InterpolateByTime(vertices.begin(), vertices.end(), 2.48f)
    );
    EXPECT_EQ(
      vertices[3],
      InterpolatorType::InterpolateByTime(vertices.begin(), vertices.end(), 2.52f)
    );
  }

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

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

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

  TEST(NearestInterpolatorTest, 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(NearestInterpolatorTest, VertexCanBeFoundByDistance) {
    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)
    );
    EXPECT_EQ(
      vertices[0],
      InterpolatorType::InterpolateByDistance(vertices.begin(), vertices.end(), 4.5f)
    );
    EXPECT_EQ(
      vertices[1],
      InterpolatorType::InterpolateByDistance(vertices.begin(), vertices.end(), 4.6f)
    );
    EXPECT_EQ(
      vertices[2],
      InterpolatorType::InterpolateByDistance(vertices.begin(), vertices.end(), 18.0f)
    );
    EXPECT_EQ(
      vertices[3],
      InterpolatorType::InterpolateByDistance(vertices.begin(), vertices.end(), 18.2f)
    );
  }

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

  TEST(NearestInterpolatorTest, 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)
    );
  }

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

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