#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_AREAS_POLYGON2_H
#define NUCLEX_GEOMETRY_AREAS_POLYGON2_H

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

#include <vector>

namespace Nuclex { namespace Geometry { namespace Areas {

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

  /// <summary>2D polygon connecting a set of ordered vertices in a loop</summary>
  template <typename TScalar>
  struct Polygon2 {
  
    /// <summary>Initializes a polygon using the specified vertices</summary>
    /// <param name="vertices">Array containing the polygon's vertices</param>
    /// <param name="count">Number of vertices in the array</param>
    public: Polygon2(const Point2<TScalar> *vertices, std::size_t count) :
      Vertices(vertices, count) {}

    /// <summary>Calculates the area of the polygon</summary>
    /// <returns>The area of the polygon</returns>
    /// <remarks>
    ///   Formula taken from http://stackoverflow.com/questions/451426
    ///   http://softsurfer.com/Archive/algorithm_0101/algorithm_0101.htm
    /// </remarks>
    public: TScalar GetArea() const {
      std::size_t vertexCount = this->Vertices.size();
      if(vertexCount < 3) {
        return 0;
      }

      TScalar area = this->Vertices[0].X * (
        this->Vertices[1].Y - this->Vertices[vertexCount - 1].Y
      );
      area += this->Vertices[vertexCount - 1].X * (
        this->Vertices[0].Y - this->Vertices[vertexCount - 2].Y
      );

      for(std::size_t index = 0; index < vertexCount - 2; ++index) {
        area += this->Vertices[index + 1].X * (
          this->Vertices[index + 2].Y - this->Vertices[index].Y
        );
      }

      return area / 2;
    }

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

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

      return length;
    }

    /// <summary>Offsets the entire polygon by the specified amount</summary>
    /// <param name="amountX">Amount the polygon will be offset on the X axis</param>
    /// <param name="amountY">Amount the polygon 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 polygon by the specified amount</summary>
    /// <param name="amount">Amount the polygon 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;
      }
    }

#if 0
    public: void Rotate(TScalar angle) {
      for(std:.size_t index = 0; index < this->count; ++index) {
        this->Vertices[index]
      }
    }
#endif

    /// <summary>Calculates the distance between two points</summary>
    /// <param name="first">First point for the distance calculation</param>
    /// <param name="second">Second point for the distance calculation</param>
    /// <returns>The distance between the two points</returns>
    private: static TScalar distance(
      const Point2<TScalar> &first, const Point2<TScalar> &second
    ) {
      TScalar x = second.X - first.X;
      TScalar y = second.Y - first.Y;

      return Math<TScalar>::SquareRoot((x * x) + (y * y));
    }

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

  };

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

}}} // namespace Nuclex::Geometry::Areas

#endif // NUCLEX_GEOMETRY_AREAS_POLYGON2_H