#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_POLYLINE2_H
#define NUCLEX_GEOMETRY_LINES_POLYLINE2_H

#include "Nuclex/Geometry/Config.h"
#include "Nuclex/Geometry/Point2.h"

#include <vector>

namespace Nuclex { namespace Geometry { namespace Lines {

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

  /// <summary>Strip of connected 2D line segments</summary>
  template <typename TScalar>
  struct PolyLine2 {
  
    /// <summary>Constructs an uninitialized polyline</summary>
    public: PolyLine2() {}

    /// <summary>Constructs a polyline as copy of an existing polyline</summary>
    /// <param name="other">Other polyline that will be coeeid</param>
    public: PolyLine2(const PolyLine2 &other) :
      Vertices(other.Vertices) {}

    /// <summary>Calculates the length of the polyline</summary>
    /// <returns>The polyline's length</returns>
    public: TScalar GetLength() const {
      std::size_t vertexCount = this->Vertices.size();
      if(vertexCount < 2) {
        return 0;
      }

      TScalar length = Point2<TScalar>::DistanceBetween(this->Vertices[0], this->Vertices[1]);
      for(std::size_t index = 1; index < vertexCount - 1; ++index) {
        length += Point2<TScalar>::DistanceBetween(
          this->Vertices[index], this->Vertices[index + 1]
        );
      }

      return length;
    }

    /// <summary>Clones a subset of the poly line</summary>
    /// <param name="firstIndex">Index of the first vertex to place in the clone</param>
    /// <param name="count">Number of vertices that should be added to the clone</param>
    /// <returns>A poly line containing the specified range of vertices</returns>
    public: PolyLine2 Subset(std::size_t firstIndex, std::size_t count) const {
      PolyLine2 result;
      result.Vertices.reserve(count);

      count += firstIndex;
      for(std::size_t index = firstIndex; index < count; ++index) {
        result.Vertices.push_back(this->Vertices[index]);
      }

      return result;
    }

    /// <summary>Clones a subset of the poly line</summary>
    /// <param name="firstIndex">Index of the first vertex to place in the clone</param>
    /// <returns>A poly line containing the specified range of vertices</returns>
    public: PolyLine2 Subset(std::size_t firstIndex) const {
      PolyLine2 result;

      std::size_t count = this->Vertices.size();
      result.Vertices.reserve(count - firstIndex);

      for(std::size_t index = firstIndex; index < count; ++index) {
        result.Vertices.push_back(this->Vertices[index]);
      }

      return result;
    }

    /// <summary>Offsets the entire polyline by the specified amount</summary>
    /// <param name="amountX">Amount the polyline will be offset on the X axis</param>
    /// <param name="amountY">Amount the polyline will be offset on the Y axis</param>
    public: void ShiftBy(TScalar amountX, TScalar amountY) {
      for(std::size_t index = 0; index < this->count; ++index) {
        this->vertices[index].X += amountX;
        this->vertices[index].Y += amountY;
      }
    }

    /// <summary>Offsets the entire polyline by the specified amount</summary>
    /// <param name="amount">Amount the polyline will be offset</param>
    public: void ShiftBy(const Vector2<TScalar> &amount) {
      for(std::size_t index = 0; index < this->count; ++index) {
        this->Vertices[index] += amount;
      }
    }

    /// <summary>Finds the index of the vertex that is closest to a given point</summary>
    /// <param name="referencePoint">Point to which the closes vertex will be found</param>
    /// <returns>The index of the closest vertex</returns>
    public: std::size_t GetClosestVertexIndex(const Point2<TScalar> &referencePoint) const {
      return GetClosestVertexIndex(referencePoint.X, referencePoint.Y);
    }

    /// <summary>Finds the index of the vertex that is closest to a given point</summary>
    /// <param name="x">X coordinate to which the closes vertex will be found</param>
    /// <param name="y">Y coordinate to which the closes vertex will be found</param>
    /// <returns>The index of the closest vertex</returns>
    public: std::size_t GetClosestVertexIndex(TScalar x, TScalar y) const {
      if(this->Vertices.empty()) {
        throw std::runtime_error("No closest vertex because poly line contains no vertices");
      }

      std::size_t closestIndex = 0;
      TScalar closestSquaredDistance = this->Vertices[0].SquaredDistanceTo(x, y);

      for(std::size_t index = 1; index < this->Vertices.size(); ++index) {
        TScalar squaredDistance = this->Vertices[index].SquaredDistanceTo(x, y);
        if(squaredDistance < closestSquaredDistance) {
          closestIndex = index;
          closestSquaredDistance = squaredDistance;
        }
      }

      return closestIndex;
    }

    /// <summary>The polyline's vertices</summary>
    public: std::vector< Point2<TScalar> > Vertices;

  };

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

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

#endif // NUCLEX_GEOMETRY_LINES_POLYLINE2_H