package algs32.kdtree;
import algs12.Point2D;
import stdlib.*;

/* ***********************************************************************
 *  Compilation:  javac RectHV.java
 *  Execution:    java RectHV
 *  Dependencies: Point2D.java
 *
 *  Implementation of 2D axis-aligned rectangle.
 *
 *************************************************************************/

public class RectHV {
	private final double xmin, ymin;   // minimum x- and y-coordinates
	private final double xmax, ymax;   // maximum x- and y-coordinates

	// construct the axis-aligned rectangle (xmin, ymin) x (xmax, ymax)
	public RectHV(double xmin, double ymin, double xmax, double ymax) {
		this.xmin = xmin;
		this.ymin = ymin;
		this.xmax = xmax;
		this.ymax = ymax;
		if (xmax < xmin || ymax < ymin) {
			throw new IllegalArgumentException("Invalid rectangle: " + this);
		}
	}

	// accessor methods for 4 coordinates
	public double xmin() { return xmin; }
	public double ymin() { return ymin; }
	public double xmax() { return xmax; }
	public double ymax() { return ymax; }

	// width and height of rectangle
	public double width()  { return xmax - xmin; }
	public double height() { return ymax - ymin; }

	// does this axis-aligned rectangle intersect that one?
	public boolean intersects(RectHV that) {
		return this.xmax >= that.xmin && this.ymax >= that.ymin
				&& that.xmax >= this.xmin && that.ymax >= this.ymin;
	}

	// draw this axis-aligned rectangle
	public void draw() {
		StdDraw.line(xmin, ymin, xmax, ymin);
		StdDraw.line(xmax, ymin, xmax, ymax);
		StdDraw.line(xmax, ymax, xmin, ymax);
		StdDraw.line(xmin, ymax, xmin, ymin);
	}

	// distance from p to closest point on this axis-aligned rectangle
	public double distanceTo(Point2D p) {
		return Math.sqrt(this.distanceSquaredTo(p));
	}

	// distance squared from p to closest point on this axis-aligned rectangle
	public double distanceSquaredTo(Point2D p) {
		double dx = 0.0, dy = 0.0;
		if      (p.x() < xmin) dx = p.x() - xmin;
		else if (p.x() > xmax) dx = p.x() - xmax;
		if      (p.y() < ymin) dy = p.y() - ymin;
		else if (p.y() > ymax) dy = p.y() - ymax;
		return dx*dx + dy*dy;
	}

	// does this axis-aligned rectangle contain p?
	public boolean contains(Point2D p) {
		return (p.x() >= xmin) && (p.x() <= xmax)
				&& (p.y() >= ymin) && (p.y() <= ymax);
	}

	// are the two axis-aligned rectangles equal?
	public boolean equals(Object y) {
		if (y == this) return true;
		if (y == null) return false;
		if (y.getClass() != this.getClass()) return false;
		final RectHV that = (RectHV) y;
		if (this.xmin != that.xmin) return false;
		if (this.ymin != that.ymin) return false;
		if (this.xmax != that.xmax) return false;
		if (this.ymax != that.ymax) return false;
		return true;
	}

	private int hashCode = 0;
	public int hashCode() {
		int hCode = hashCode;
		if (hCode != 0)
			return hCode;
		int result = 17;
		result = 37*result + Double.hashCode (xmin);
		result = 37*result + Double.hashCode (xmax);
		result = 37*result + Double.hashCode (ymin);
		result = 37*result + Double.hashCode (ymax);
		hashCode = result;
		return result;
	}

	// return a string representation of this axis-aligned rectangle
	public String toString() {
		return "(" + xmin + ", " + ymin + ") x (" + xmax + ", " + ymax + ")";
	}

}