#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_VOLUMES_GENERATORS_SPHERE3GENERATOR_H
#define NUCLEX_GEOMETRY_VOLUMES_GENERATORS_SPHERE3GENERATOR_H

#include "Nuclex/Geometry/Config.h"
#include "Nuclex/Geometry/Volumes/Sphere3.h"
#include "Nuclex/Geometry/Volumes/Box3.h"

namespace Nuclex { namespace Geometry { namespace Volumes { namespace Generators {

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

  /// <summary>Point and volume generation methods for 3D spheres</summary>
  template <typename TScalar>
  class Sphere3Generator {

    /// <summary>Generates a random point within a sphere</summary>
    /// <param name="sphere">Sphere 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 sphere</returns>
    public: template <typename TRandomNumberEngine> Point3<TScalar>
    static GetRandomPointInside(const Sphere3<TScalar> &sphere, TRandomNumberEngine &random) {
      TScalar x = Math<TScalar>::Random(random, -1, +1);
      TScalar y = Math<TScalar>::Random(random, -1, +1);
      TScalar z = Math<TScalar>::Random(random, -1, +1);
      TScalar distance = Math<TScalar>::SquareRoot(x * x + y * y + z * z);
      TScalar factor = (sphere.Radius * Math<TScalar>::Random(random, 1)) / distance;

      return Point3<TScalar>(
        sphere.Center.X + x * factor,
        sphere.Center.Y + y * factor,
        sphere.Center.Z + z * factor
      );
    }

    /// <summary>Generates a random point on the hull of a sphere</summary>
    /// <param name="sphere">Sphere on which a random point will be generated</param>
    /// <param name="random">Random number generator that will be used</param>
    /// <returns>A random point on the hull of the sphere</returns>
    public: template <typename TRandomNumberEngine> Point3<TScalar>
    static GetRandomPointOnHull(const Sphere3<TScalar> &sphere, TRandomNumberEngine &random) {
      TScalar z = Math<TScalar>::Random(random, -1, +1);
      TScalar t = Math<TScalar>::Random(random, Math<TScalar>::Perigon());
      TScalar r = Math<TScalar>::SquareRoot(1 - (z * z));

      return Point3<TScalar>(
        sphere.Center.X + sphere.Radius * r * Math<TScalar>::Cosine(t),
        sphere.Center.Y + sphere.Radius * r * Math<TScalar>::Sine(t),
        sphere.Center.Z + sphere.Radius * z
      );
    }

    /// <summary>Determines the closest point to another point on the sphere's hull</summary>
    /// <param name="sphere">Sphere upon 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 on the sphere's hull</returns>
    public: Point3<TScalar> GetClosestPointOnHull(
      const Sphere3<TScalar> &sphere, const Point3<TScalar> &point
    ) {
      TScalar offsetX = point.X - sphere.Center.X;
      TScalar offsetY = point.Y - sphere.Center.Y;
      TScalar offsetZ = point.Z - sphere.Center.Z;
      TScalar squaredDistance = (offsetX * offsetX) + (offsetY * offsetY) + (offsetZ * offsetZ);

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

    /// <summary>Determines the closest point to another point inside the sphere</summary>
    /// <param name="sphere">Sphere within 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 sphere</returns>
    public: Point3<TScalar> GetClosestPointInside(
      const Sphere3<TScalar> &sphere, const Point3<TScalar> &point
    )  {
      TScalar offsetX = point.X - sphere.Center.X;
      TScalar offsetY = point.Y - sphere.Center.Y;
      TScalar offsetZ = point.Z - sphere.Center.Z;
      TScalar squaredDistance = (offsetX * offsetX) + (offsetY * offsetY) + (offsetZ * offsetZ);

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


    /// <summary>Calculates the bounding box of the specified sphere</summary>
    /// <param name="sphere">Sphere of which the bounding box will be calculated</param>
    /// <returns>The bounding box of the specified sphere</returns>
    public: static Box3<TScalar> GetBoundingBox(const Sphere3<TScalar> &sphere) {
      return Box3<TScalar>::FromMinMax(
        sphere.Center.X - sphere.Radius,
        sphere.Center.Y - sphere.Radius,
        sphere.Center.Z - sphere.Radius,
        sphere.Center.X + sphere.Radius,
        sphere.Center.Y + sphere.Radius,
        sphere.Center.Z + sphere.Radius
      );
    }

    /// <summary>Calculates the bounding sphere of the specified sphere</summary>
    /// <param name="sphere">Sphere of which the bounding sphere will be calculated</param>
    /// <returns>The bounding sphere of the specified sphere</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 Sphere3<TScalar> GetBoundingSphere(const Sphere3<TScalar> &sphere) {
      return sphere;
    }

  };

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

}}}} // namespace Nuclex::Geometry::Volumes::Generators

#endif // NUCLEX_GEOMETRY_VOLUMES_GENERATORS_SPHERE3GENERATOR_H