using System;
using System.Text;

using UnityEngine;

namespace Framework.Geometry.Areas {

	/// <summary>Axis aligned rectangle in 2D</summary>
	public struct Rectangle2 {

		/// <summary>A rectangle with no area</summary>
		public static Rectangle2 Empty = Rectangle2.FromMinMax(0.0f, 0.0f, 0.0f, 0.0f);

		/// <summary>Coordinates of the rectangle's lesser corner</summary>
		public Vector2 Min;
		/// <summary>Coordinates of the rectangle's larger corner</summary>
		public Vector2 Max;

		/// <summary>Initializes a new rectangle using the specified coordinates</summary>
		/// <param name="minX">Minimum X coordinate of the rectangle</param>
		/// <param name="minY">Minimum Y coordinate of the rectangle</param>
		/// <param name="maxX">Maximum X coordinate of the rectangle</param>
		/// <param name="maxY">Maximum Y coordinate of the rectangle</param>
		/// <returns>The rectangle constructed from the specified boundaries</returns>
		public static Rectangle2 FromMinMax(float minX, float minY, float maxX, float maxY) {
			return new Rectangle2() {
				Min = new Vector2(minX, minY),
				Max = new Vector2(maxX, maxY)
			};
		}

		/// <summary>Initializes a rectangle from a starting point, width and height</summary>
		/// <param name="x">Starting point X coordinate</param>
		/// <param name="y">Starting point Y coordinate</param>
		/// <param name="width">Width of the rectangle</param>
		/// <param name="height">Height of the rectangle</param>
		/// <returns>A rectangle with the specified starting point, width and height</returns>
		public static Rectangle2 FromPointAndSize(float x, float y, float width, float height) {
			return new Rectangle2() {
				Min = new Vector2(x, y),
				Max = new Vector2(x + width, y + height)
			};
		}

		/// <summary>Initializes a new rectangle using the specified min max points</summary>
		/// <param name="min">Minimum coordinates of the rectangle</param>
		/// <param name="max">Maximum coordinates of the rectangle</param>
		/// <returns>The rectangle constructed from the specified boundaries</returns>
		public static Rectangle2 FromMinMax(Vector2 min, Vector2 max) {
			return new Rectangle2() {
				Min = min,
				Max = max
			};
		}

		/// <summary>Initializes a rectangle from a starting corner, width and height</summary>
		/// <param name="min">Starting point</param>
		/// <param name="size">Size of the rectangle</param>
		/// <returns>A rectangle with the specified starting point, width and height</returns>
		public static Rectangle2 FromPointAndSize(Vector2 min, Vector2 size) {
			return new Rectangle2() {
				Min = min,
				Max = min + size
			};
		}

		/// <summary>Width of the rectangle</summary>
		public float Width {
			get { return Math.Abs(this.Max.x - this.Min.x); }
		}

		/// <summary>Height of the rectangle</summary>
		public float Height {
			get { return Math.Abs(this.Max.y - this.Min.y); }
		}

		/// <summary>Area contained within the rectangle</summary>
		public float Area {
			get { return Width * Height; }
		}

		/// <summary>Circumference of the rectangle's outline</summary>
		public float Circumference {
			get { return (Width * 2) + (Height * 2); }
		}

		/// <summary>Checks two rectangles for inequality</summary>
		/// <param name="first">First instance to be compared</param>
		/// <param name="second">Second instance fo tbe compared</param>
		/// <returns>True if the instances differ or exactly one reference is set to null</returns>
		public static bool operator !=(Rectangle2 first, Rectangle2 second) {
      return (
        (first.Min.x != second.Min.x) ||
        (first.Min.y != second.Min.y) ||
        (first.Max.x != second.Max.x) ||
        (first.Max.y != second.Max.y)
      );
		}

		/// <summary>Checks two rectangles for equality</summary>
		/// <param name="first">First instance to be compared</param>
		/// <param name="second">Second instance fo tbe compared</param>
		/// <returns>True if both instances are equal or both references are null</returns>
		public static bool operator ==(Rectangle2 first, Rectangle2 second) {
      return (
        (first.Min.x == second.Min.x) &&
        (first.Min.y == second.Min.y) &&
        (first.Max.x == second.Max.x) &&
        (first.Max.y == second.Max.y)
      );
		}

		/// <summary>Checks whether this rectangle is equal to another rectangle</summary>
		/// <param name="otherAsObject">Other rectangle, boxed into an object</param>
		/// <returns>True if the other object is a rectangle with the same attributes</returns>
		public override bool Equals(object otherAsObject) {
			if(otherAsObject is Rectangle2) {
				return (this == (Rectangle2)otherAsObject);
			} else {
				return false;
			}
		}

		/// <summary>
		///   Generates a hash code that is identical for instances with the same state
		/// </summary>
		/// <returns>A hash code for the instance</returns>
		public override int GetHashCode() {
      return (
        (this.Min.x.GetHashCode()) ^
        (this.Min.y.GetHashCode() << 8) ^
        (this.Max.x.GetHashCode() << 16) ^
        (this.Max.y.GetHashCode() << 24)
      );
		}

		/// <summary>Describes the 2D rectangle as a string</summary>
		/// <returns>A string describing the 2D rectangle</returns>
		public override string ToString() {
			var builder = new StringBuilder();
			builder.Append('{');
			builder.Append(this.Min.x);
			builder.Append(';');
			builder.Append(this.Min.y);
			builder.Append("} - {");
			builder.Append(this.Max.x);
			builder.Append(';');
			builder.Append(this.Max.y);
			builder.Append('}');
			return builder.ToString();
		}

	}

} // namespace Framework.Geometry.Areas