#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_BOX3_H
#define NUCLEX_GEOMETRY_VOLUMES_BOX3_H

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

namespace Nuclex { namespace Geometry { namespace Volumes {

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

  /// <summary>3D box defined through minimum and a maximum corner coordinates</summary>
  template <typename TScalar>
  struct Box3 {

    /// <summary>Builds a box from given minimum and maximum cordinates</summary>
    /// <param name="left">X coordinate of the box's left side</param>
    /// <param name="top">Y coordinate of the box's top side</param>
    /// <param name="back">Z coordinate of the box's back side</param>
    /// <param name="right">X coordinate of the box's right side</param>
    /// <param name="bottom">Y coordinate of the box's bottom side</param>
    /// <param name="front">Z coordinate of the box's front side</param>
    /// <returns>A new box using the specified coordinates</returns>
    public: static Box3 FromMinAndMax(
      TScalar left, TScalar top, TScalar back,
      TScalar right, TScalar bottom, TScalar front
    ) {
      return Box3(
        Point3<TScalar>(left, top, back),
        Point3<TScalar>(right, bottom, front)
      );
    }

    /// <summary>Builds a box from a given location and size</summary>
    /// <param name="left">X coordinate of the box's left side</param>
    /// <param name="top">Y coordinate of the box's top side</param>
    /// <param name="back">Z coordinate of the box's back side</param>
    /// <param name="width">Width of the box on the X axis</param>
    /// <param name="height">Height of the box on the Y axis</param>
    /// <param name="length">Length of the box on the Z axis</param>
    /// <returns>A new box using the specified coordinates</returns>
    public: static Box3 FromPointAndSize(
      TScalar left, TScalar top, TScalar back,
      TScalar width, TScalar height, TScalar length
    ) {
      return Box3(
        Point3<TScalar>(left, top, back),
        Vector3<TScalar>(width, height, length)
      );
    }

#if WANT_CONFUSING_CONSTRUCTOR
    /// <summary>Initializes a box using the specified position and size</summary>
    /// <param name="position">Position of the box's upper left corner</param>
    /// <param name="size">Size of the box</param>
    public: Box3(const Point3<TScalar> &position, const Vector3<TScalar> &size) :
      Min(position), Max(position + size) {}
#endif

    /// <summary>Constructs an uninitialized box</summary>
    public: Box3() {}

    /// <summary>Initializes a box using the specified corner coordinates</summary>
    /// <param name="min">Position of the box's upper left corner</param>
    /// <param name="max">Position of the box's lower right corner</param>
    public: Box3(const Point3<TScalar> &min, const Point3<TScalar> &max) :
      Min(min), Max(max) {}

    /// <summary>Returns the width of the box</summary>
    /// <returns>The box' width</returns>
    public: TScalar GetWidth() const { return this->Max.X - this->Min.X; }

    /// <summary>Returns the length of the box</summary>
    /// <returns>The box' length</returns>
    public: TScalar GetLength() const { return this->Max.Y - this->Min.Y; }

    /// <summary>Returns the height of the box</summary>
    /// <returns>The box' height</returns>
    public: TScalar GetHeight() const { return this->Max.Z - this->Min.Z; }

    /// <summary>Calculates the center of the box</summary>
    /// <returns>The center of the box</returns>
    public: Point3<TScalar> GetCenter() const {
      return Point3<TScalar>(
        (this->Min.X + this->Max.X) / 2,
        (this->Min.Y + this->Max.Y) / 2,
        (this->Min.Z + this->Max.Z) / 2
      );
    }

    /// <summary>Ensures that the box is not flipped on any axis</summary>
    public: void Unflip() {
      if(this->Min.X > this->Max.X) {
        std::swap(this->Min.X, this->Max.X);
      }
      if(this->Min.Y > this->Max.Y) {
        std::swap(this->Min.Y, this->Max.Y);
      }
      if(this->Min.Z > this->Max.Z) {
        std::swap(this->Min.Z, this->Max.Z);
      }
    }

    /// <summary>Offsets the entire box by the specified amount</summary>
    /// <param name="offsetX">Amount the box will be offset on the X axis</param>
    /// <param name="offsetY">Amount the box will be offset on the Y axis</param>
    /// <param name="offsetZ">Amount the box will be offset on the Z axis</param>
    public: void ShiftBy(TScalar offsetX, TScalar offsetY, TScalar offsetZ) {
      this->Min.X += offsetX;
      this->Min.Y += offsetY;
      this->Min.Z += offsetZ;
      this->Max.X += offsetX;
      this->Max.Y += offsetY;
      this->Max.Z += offsetZ;
    }

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

    /// <summary>Triggers an assertion if the box is flipped on any axis</summary>
    public: void EnforceNotFlipped() const {
      using namespace std;
      assert((this->Min.X <= this->Max.X) && "Box must not be flipped on the X axis");
      assert((this->Min.Y <= this->Max.Y) && "Box must not be flipped on the Y axis");
      assert((this->Min.Z <= this->Max.Z) && "Box must not be flipped on the Z axis");
    }

    /// <summary>Coordinates of the box's near lower left corner</summary>
    public: Point3<TScalar> Min;
    /// <summary>Coordinates of the box's far upper right corner</summary>
    public: Point3<TScalar> Max;

  };

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

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

#endif // NUCLEX_GEOMETRY_VOLUMES_BOX3_H