using System;
using System.Text;

using UnityEngine;

namespace Framework.Geometry.Volumes {

	/// <summary>Axis aligned box in 2D</summary>
	public struct Box3 {

		/// <summary>A box with no volume</summary>
		public static Box3 Empty = Box3.FromMinMax(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);

		/// <summary>Coordinates of the box' lesser corner</summary>
		public Vector3 Min;
		/// <summary>Coordinates of the box' larger corner</summary>
		public Vector3 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="minZ">Minimum Z 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>
		/// <param name="maxZ">Maximum Z coordinate of the rectangle</param>
		/// <returns>The rectangle constructed from the specified boundaries</returns>
		public static Box3 FromMinMax(
			float minX, float minY, float minZ, float maxX, float maxY, float maxZ
		) {
			return new Box3() {
				Min = new Vector3(minX, minY, minZ),
				Max = new Vector3(maxX, maxY, maxZ)
			};
		}

		/// <summary>Initializes a box 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="z">Starting point Z coordinate</param>
		/// <param name="width">Width of the box</param>
		/// <param name="height">Height of the box</param>
		/// <param name="depth">Depth of the box</param>
		/// <returns>A rectangle with the specified starting point, width and height</returns>
		public static Box3 FromPointAndSize(
			float x, float y, float z, float width, float height, float depth
		) {
			return new Box3() {
				Min = new Vector3(x, y, z),
				Max = new Vector3(x + width, y + height, z + depth)
			};
		}

		/// <summary>Initializes a new box using the specified min max points</summary>
		/// <param name="min">Minimum coordinates of the box</param>
		/// <param name="max">Maximum coordinates of the box</param>
		/// <returns>The box constructed from the specified boundaries</returns>
		public static Box3 FromMinMax(Vector3 min, Vector3 max) {
			return new Box3() {
				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 Box3 FromPointAndSize(Vector3 min, Vector3 size) {
			return new Box3() {
				Min = min,
				Max = min + size
			};
		}

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

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

		/// <summary>Depth of the box</summary>
		public float Depth {
			get { return Math.Abs(this.Max.z - this.Min.z); }
		}

		/// <summary>Volume occupied by the box</summary>
		public float Volume {
			get { return Width * Height * Depth; }
		}

		/// <summary>Area of the box' surface</summary>
		public float Area {
			get { return (Width * Height * 2) + (Width * Depth * 2) + (Height * Depth * 2); }
		}

		/// <summary>Checks two boxes 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 !=(Box3 first, Box3 second) {
      return (
        (first.Min.x != second.Min.x) ||
        (first.Min.y != second.Min.y) ||
        (first.Min.z != second.Min.z) ||
        (first.Max.x != second.Max.x) ||
        (first.Max.y != second.Max.y) ||
        (first.Max.z != second.Max.z)
      );
		}

		/// <summary>Checks two points 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 ==(Box3 first, Box3 second) {
      return (
        (first.Min.x == second.Min.x) &&
        (first.Min.y == second.Min.y) &&
        (first.Min.z == second.Min.z) &&
        (first.Max.x == second.Max.x) &&
        (first.Max.y == second.Max.y) &&
        (first.Max.z == second.Max.z)
      );
		}

		/// <summary>Checks whether this box is equal to another box</summary>
		/// <param name="otherAsObject">Other box, boxed into an object</param>
		/// <returns>True if the other object is a box with the same attributes</returns>
		public override bool Equals(object otherAsObject) {
			if(otherAsObject is Box3) {
				return (this == (Box3)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() << 5) ^
        (this.Min.z.GetHashCode() << 10) ^
        (this.Max.x.GetHashCode() << 15) ^
	      (this.Max.y.GetHashCode() << 20) ^
	      (this.Max.z.GetHashCode() << 25)
      );
		}

		/// <summary>Describes the 3D box as a string</summary>
		/// <returns>A string describing the 3D box</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.Min.z);
			builder.Append("} - {");
			builder.Append(this.Max.x);
			builder.Append(';');
			builder.Append(this.Max.y);
			builder.Append(';');
			builder.Append(this.Max.z);
			builder.Append('}');
			return builder.ToString();
		}

	}

} // namespace Framework.Geometry.Volumes