#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_TRIANGLE3_H
#define NUCLEX_GEOMETRY_AREAS_TRIANGLE3_H

#include "Nuclex/Geometry/Config.h"
#include "Nuclex/Geometry/Point3.h"
#include "Nuclex/Geometry/Vector3.h"

namespace Nuclex { namespace Geometry { namespace Areas {

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

  /// <summary>Triangle in 3D space constructed from its 3 corner vertices</summary>
  template <typename TScalar>
  struct Triangle3 {

    /// <summary>Initializes a triangle using the specified corner points</summary>
    /// <param name="a">First corner of the triangle</param>
    /// <param name="b">Second corner of the triangle</param>
    /// <param name="c">Third corner of the triangle</param>
    public: Triangle3(
      const Point3<TScalar> &a,
      const Point3<TScalar> &b,
      const Point3<TScalar> &c
    ) : A(a), B(b), C(c) {}

    /// <summary>Returns the center point of the triangle</summary>
    /// <returns>The center of the triangle</returns>
    public: Point3<TScalar> GetCenter() const {
      return Point3<TScalar>(
        (this->A.X + this->B.X + this->C.X) / 3,
        (this->A.Y + this->B.Y + this->C.Y) / 3,
        (this->A.Z + this->B.Z + this->C.Z) / 3
      );
    }

    /// <summary>Calculates the area of the triangle</summary>
    /// <returns>The area of the triangle</returns>
    ///   <para>
    ///     Heron's triangle area formular states that, given s = (a + b + c) / 2
    ///     (semiperimeter), the area of a triangle can be calculated as
    ///   </para>
    ///   <code>
    ///              _________________________________
    ///     area = \/ s * (s - a) * (s - b) * (s - c)
    ///
    ///   </code>
    ///   <para>
    ///     In a paper by W. Kahan this method is proven to be numerically unstable
    ///     for floating point numbers. He recommends to use the following formula
    ///     instead, where the lengths a, b and c have to be sorted in ascending order.
    ///   </para>
    ///   <code>
    ///                     ______________________________________________________________
    ///     area = 0.25 * \/ (a + (b + c)) * (c - (a - b)) * (c + (a - b)) * (a + b - c))
    ///
    ///   </code>
    /// </remarks>
    public: TScalar GetArea() const {
      TScalar a = Point3<TScalar>::DistanceBetween(A, B);
      TScalar b = Point3<TScalar>::DistanceBetween(B, C);
      TScalar c = Point3<TScalar>::DistanceBetween(C, A);

      TScalar s = (a + b + c) / 2;
      return Math<TScalar>::SquareRoot(s * (s - a) * (s - b) * (s - c));
    }

    /// <summary>Calculates the perimeter of the triangle</summary>
    /// <returns>The triangle's perimeter</returns>
    public: TScalar GetPerimeter() const {
      return (
        Point3<TScalar>::DistanceBetween(A, B) +
        Point3<TScalar>::DistanceBetween(B, C) +
        Point3<TScalar>::DistanceBetween(C, A)
      );
    }

    /// <summary>Offsets the entire triangle by the specified amount</summary>
    /// <param name="amountX">Amount the triangle will be offset on the X axis</param>
    /// <param name="amountY">Amount the triangle will be offset on the Y axis</param>
    /// <param name="amountZ">Amount the triangle will be offset on the Z axis</param>
    public: void ShiftBy(TScalar amountX, TScalar amountY, TScalar amountZ) {
      this->A.X += amountX;
      this->B.X += amountX;
      this->C.X += amountX;
      this->A.Y += amountY;
      this->B.Y += amountY;
      this->C.Y += amountY;
      this->A.Z += amountZ;
      this->B.Z += amountZ;
      this->C.Z += amountZ;
    }

    /// <summary>Offsets the entire triangle by the specified amount</summary>
    /// <param name="amount">Amount the triangle will be offset</param>
    public: void ShiftBy(const Vector3<TScalar> &amount) {
      this->A += amount;
      this->B += amount;
      this->C += amount;
    }

    /// <summary>Coordinates of the triangle's first corner</summary>
    public: Point3<TScalar> A;
    /// <summary>Coordinates of the triangle's second corner</summary>
    public: Point3<TScalar> B;
    /// <summary>Coordinates of the triangle's third corner</summary>
    public: Point3<TScalar> C;

  };

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

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

#endif // NUCLEX_GEOMETRY_AREAS_TRIANGLE3_H