#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_RECTANGLE2_H
#define NUCLEX_GEOMETRY_AREAS_RECTANGLE2_H

#include "../Point2.h"
#include "../Vector2.h"
#include "../Math.h"
#include <cassert>

namespace Nuclex { namespace Geometry { namespace Areas {

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

  /// <summary>2D rectangle defined through minimum and a maximum corner coordinates</summary>
  template <typename TScalar>
  struct Rectangle2 {

    /// <summary>A rectangle with zero area</summary>
    public: static const Rectangle2 Empty;

    /// <summary>Builds a rectangle from given minimum and maximum cordinates</summary>
    /// <param name="minX">X coordinate of the rectangle's left side</param>
    /// <param name="minY">Y coordinate of the rectangle's top side</param>
    /// <param name="maxX">X coordinate of the rectangle's right side</param>
    /// <param name="maxY">Y coordinate of the rectangle's bottom side</param>
    /// <returns>A new rectangle using the specified coordinates</returns>
    public: static Rectangle2 FromMinAndMax(
      TScalar minX, TScalar minY, TScalar maxX, TScalar maxY
    ) {
      Rectangle2 rectangle;
      rectangle.Min.X = minX;
      rectangle.Min.Y = minY;
      rectangle.Max.X = maxX;
      rectangle.Max.Y = maxY;
      return rectangle;
    }

    /// <summary>Builds a rectangle from a given location and size</summary>
    /// <param name="minX">X coordinate of the rectangle's corner</param>
    /// <param name="minY">Y coordinate of the rectangle's corner</param>
    /// <param name="width">Width of the rectangle on the X axis</param>
    /// <param name="height">Height of the rectangle on the Y axis</param>
    /// <returns>A new rectangle using the specified coordinates</returns>
    public: static Rectangle2 FromPointAndSize(
      TScalar minX, TScalar minY, TScalar width, TScalar height
    ) {
      Rectangle2 rectangle;
      rectangle.Min.X = minX;
      rectangle.Min.Y = minY;
      rectangle.Max.X = minX + width;
      rectangle.Max.Y = minY + height;
      return rectangle;
    }

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

    /// <summary>Constructs an uninitialized rectangle</summary>
    public: Rectangle2() {}

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

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

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

    /// <summary>Returns a point that lies in the center of the rectangle</summary>
    /// <returns>The center of the rectangle</returns>
    public: Point2<TScalar> GetCenter() const {
      return Point2<TScalar>(
        (this->Min.X + this->Max.X) / 2, (this->Min.Y + this->Max.Y) / 2
      );
    }

    /// <summary>Calculates the area of the rectangle</summary>
    /// <returns>The area of the rectangle</returns>
    public: TScalar GetArea() const {
      EnforceNotFlipped();

      return (this->Max.X - this->Min.X) * (this->Max.Y - this->Min.Y);
    }

    /// <summary>Calculates the perimeter of the rectangle</summary>
    /// <returns>The rectangle's perimeter</returns>
    public: TScalar GetPerimeter() const {
      EnforceNotFlipped();

      TScalar horizontal = (this->Max.X - this->Min.X) * 2;
      TScalar vertical = (this->Max.Y - this->Min.Y) * 2;

      return horizontal + vertical;
    }

    /// <summary>Ensures that the rectangle 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);
      }
    }

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

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

#if WANT_CONFUSING_PLACEMENT
    /// <summary>Moves the rectangle to the specified location</summary>
    /// <param name="x">X coordinate the rectangle's minimum corner will end up at</param>
    /// <param name="y">Y coordinate the rectangle's minimum corner will end up at</param>
    public: void PlaceAt(TScalar x, TScalar y) {
      this->Max.X = x + (this->Max.X - this->Min.X);
      this->Max.Y = y + (this->Max.Y - this->Min.Y);
      this->Min.X = x;
      this->Min.Y = y;
    }

    /// <summary>Moves the rectangle to the specified location</summary>
    /// <param name="position">Position the rectangle's minimum corner will end up at</param>
    public: void PlaceAt(const Point2<TScalar> &position) {
      this->Max = position + (this->Max - this->Min);
      this->Min = position;
    }
#endif // WANT_CONFUSING_PLACEMENT

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

    /// <summary>Coordinates of the rectangle's lower left corner</summary>
    public: Point2<TScalar> Min;
    /// <summary>Coordinates of the rectangle's upper right corner</summary>
    public: Point2<TScalar> Max;

  };

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

  template<typename TScalar>
  const Rectangle2<TScalar> Rectangle2<TScalar>::Empty(
    Point2<TScalar>::Zero, Point2<TScalar>::Zero
  );

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

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

#endif // NUCLEX_GEOMETRY_AREAS_RECTANGLE2_H