#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_GENERATORS_DISC2GENERATOR_H
#define NUCLEX_GEOMETRY_AREAS_GENERATORS_DISC2GENERATOR_H

#include "Nuclex/Geometry/Config.h"
#include "Nuclex/Geometry/Areas/Disc2.h"
#include "Nuclex/Geometry/Areas/Rectangle2.h"

namespace Nuclex { namespace Geometry { namespace Areas { namespace Generators {

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

  /// <summary>Point and area generation methods for 2D discs</summary>
  template <typename TScalar>
  class Disc2Generator {

    /// <summary>Returns a random point within the disc</summary>
    /// <param name="disc">Disc in which a random point will be generated</param>
    /// <param name="random">Random number generator that will be used</param>
    /// <returns>A random point inside the disc</returns>
    public: template <typename TRandomNumberEngine>
    static Point2<TScalar> GetRandomPointInside(
      const Disc2<TScalar> &disc, TRandomNumberEngine &random
    ) {
      TScalar randomAngle = Math<TScalar>::Random(random, Math<TScalar>::Perigon());
      TScalar radius = Math<TScalar>::SquareRoot(
        Math<TScalar>::Random(random, 1)
      ) * disc.Radius;

      return new Point2<TScalar>(
        radius * Math<TScalar>::Cosine(randomAngle) + disc.Center.X,
        radius * Math<TScalar>::Sine(randomAngle) + disc.Center.Y
      );
    }

    /// <summary>Returns a random point on the outline of the disc</summary>
    /// <param name="disc">Disc on whose outline a random point will be generated</param>
    /// <param name="random">Random number generator that will be used</param>
    /// <returns>A random point on the disc's outline</returns>
    public: template <typename TRandomNumberEngine>
    static Point2<TScalar> GetRandomPointOnOutline(
      const Disc2<TScalar> &disc, TRandomNumberEngine &random
    ) {
      TScalar randomAngle = Math<TScalar>::Random(random, Math<TScalar>::Perigon());

      return new Point2<TScalar>(
        disc.Radius * Math<TScalar>::Cosine(randomAngle) + disc.Center.X,
        disc.Radius * Math<TScalar>::Sine(randomAngle) + disc.Center.Y
      );
    }

    /// <summary>Determines the closest point to another point inside the disc</summary>
    /// <param name="disc">Disc in which the closest point will be found</param>
    /// <param name="point">Point to which the closest point will be determined</param>
    /// <returns>The closest point to the specified point inside the disc</returns>
    public: static Point2<TScalar> GetClosestPointInside(
      const Disc2<TScalar> &disc, const Point2<TScalar> &point
    ) {
      TScalar offsetX = point.X - disc.Center.X;
      TScalar offsetY = point.Y - disc.Center.Y;
      TScalar squaredDistance = (offsetX * offsetX) + (offsetY * offsetY);

      if(squaredDistance <= (disc.Radius * disc.Radius)) {
        return point;
      } else {
        float distanceFactor = disc.Radius / Math<TScalar>::SquareRoot(squaredDistance);
        return Point2<TScalar>(
          disc.Center.X + (offsetX * distanceFactor),
          disc.Center.Y + (offsetY * distanceFactor)
        );
      }
    }

    /// <summary>Determines the closest point to another point on the disc's outline</summary>
    /// <param name="disc">Disc on whose outline the closest point will be found</param>
    /// <param name="point">Point to which the closest point will be determined</param>
    /// <returns>The closest point to the specified point on the disc's outline</returns>
    public: static Point2<TScalar> GetClosestPointOnOutline(
      const Disc2<TScalar> &disc, const Point2<TScalar> &point
    ) {
      TScalar offsetX = point.X - disc.Center.X;
      TScalar offsetY = point.Y - disc.Center.Y;
      TScalar squaredDistance = (offsetX * offsetX) + (offsetY * offsetY);

      if(squaredDistance == 0) {
        return Point2<TScalar>(disc.Center.X + disc.Radius, disc.Center.Y);
      } else {
        float distanceFactor = disc.Radius / Math<TScalar>::SquareRoot(squaredDistance);
        return Point2<TScalar>(
          disc.Center.X + (offsetX * distanceFactor),
          disc.Center.Y + (offsetY * distanceFactor)
        );
      }
    }

    /// <summary>Calculates the bounding rectangle of a disc</summary>
    /// <param name="disc">Disc of which the bounding rectangle will be calculated</param>
    /// <returns>The disc's bounding rectangle</returns>
    public: static Rectangle2<TScalar> GetBoundingRectangle(const Disc2<TScalar> &disc) {
      return Rectangle2<TScalar>::FromMinAndMax(
        disc.Center.X - disc.Radius, disc.Center.Y - disc.Radius,
        disc.Center.X + disc.Radius, disc.Center.Y + disc.Radius
      );
    }

    /// <summary>Calculates the bounding disc of a disc</summary>
    /// <param name="disc">Disc of which the bounding disc will be calculated</param>
    /// <returns>The disc's bounding disc</returns>
    /// <remarks>
    ///   This is a no-op, but provided for completeness so templated algorithms
    ///   can assume this member to be there in any generator type.
    /// </remarks>
    public: static Disc2<TScalar> GetBoundingDisc(const Disc2<TScalar> &disc) {
      return disc;
    }

  };

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

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

#endif // NUCLEX_GEOMETRY_AREAS_GENERATORS_DISC2GENERATOR_H