import java.util.Arrays;

public class Cloud {

	/* insert your name here */

	private Point[] points;  // Array of Points contained in this Cloud
	private int maxSize;   //  The maximum number of points allowed in this Cloud
	private int size;          //   The current number of points in this Cloud

	/**
	 * 
	 * pre:  None
	 * post: returns true if the Cloud is full
	 * 
	 * A Cloud is defined as full when the current number of points
	 * in the Cloud is equal to the maximum number of points in the
	 * Cloud.
	 */
	public boolean isFull(){
		return size == maxSize;
	}

	/**
	 * 
	 * pre: None
	 * post: returns true when the Cloud is empty
	 * 
	 * A Cloud is defined as empty when there are no Points in the
	 * Cloud.
	 */
	public boolean isEmpty(){
		return size == 0;
	}

	/**
	 * 
	 * pre: p is a Valid point
	 * post: returns true if the Point p is contained in the Cloud
	 *
	 *The intuition here is to look through the points array and
	 *discover if a point that is equal to the argument p is in that array.
	 */
	public boolean hasPoint(Point p){
		boolean found = false;
		for(int i = 0; i<size && !found; i++ ){
			if (p.equals(points[i])) found = true;
		}
		return found;	
	}

	/**
	 * pre: maxSize > 0
	 * post: a Cloud has been constructed, and a points
	 *           array has been created of size maxSize.
	 */
	public Cloud(int maxSize){
		this.size = 0;
		this.maxSize = maxSize;
		this.points = new Point[maxSize]; 
	}

	/**
	 * 
	 * pre: p is a valid Point
	 * post: 
	 *  if (size < maxSize) add p to points, increment size
	 *  return true if p added to points, 
	 *  return false if not added because size == maxSize
	 */
	public boolean addPoint(Point p){
		boolean res = true;
		if(!isFull()){
			points[size]= p;
			size++;
		}
		else
			res = false;
		return res;
	}

	/*
	 * 
	 * pre: None
	 * post: A string is returned that represents the Cloud
	 * 			This string should take the form of {a,b,c} where 
	 * 			a, b, and c are valid representations of the points
	 * 			in the Cloud
	 * 
	 * The result of an empty Cloud would be {}.
	 */
	public String toString(){
		String s = "{";
		for (int i=0; i<size; i++) {
			s = s + points[i];
			if (i < size-1)
				s = s + ",";
		}
		s = s + "}";
		return s;
	}

	/**
	 * 
	 * pre: None
	 * post: return null if Cloud is empty
	 * 			else return an array of Points: leftmost, rightmost, top, bottom
	 */
	public Point[] extremes(){
		Point[] lrtb = null;
		if(!isEmpty()) {
			Point left = points[0];
			Point rght = points[0];
			Point top = points[0];
			Point bot = points[0];
			for(int i=1; i<size; i++){
				double x = points[i].getx();
				double y = points[i].gety();
				if( x < left.getx()){
					left = points[i];
				}
				if( x > rght.getx()){
					rght = points[i];
				}
				if( y < bot.gety()){
					bot = points[i];
				}
				if( y > top.gety()){
					top = points[i];
				}		
			}
			lrtb = new Point[4];
			lrtb[0] = left;
			lrtb[1] = rght;
			lrtb[2] = top;
			lrtb[3] = bot;
		}
		return lrtb;
	}
	/**
	 * 
	 * pre: None
	 * post: return null if the Cloud is empty
	 * 			 otherwise, create and return the center point
	 * 
	 * The center point is defined as the average x and the average y for all 
	 * the points in the Cloud.
	 */
	
	private double centerX(){
		double sum = 0;
		for(int i=0; i<size; i++){
			sum += points[i].getx();
		}
		return sum/size;
	}

	/**
	 * pre: size > 0
	 * @return average Y
	 */
	private double centerY(){
		double sum = 0;
		for(int i=0; i<size; i++){
			sum += points[i].gety();
		}
		return sum/size;
	}
	public Point centerP(){
		if(isEmpty())
			return null;
		else {
			Point center = new Point(centerX(),centerY());
			return center;
		}

	}


	/**
	 * pre: None
	 * post: returns null if the Cloud is empty, 
	 *           returns an array of the two Points in the Cloud that are closest together otherwise. 
	 *           If the Cloud has only one Point, return a size 1 array with that one Point in it.
	 */
	public Point[] minDist(){
		Point[] pair = null;
		if(!isEmpty()){
			if (size==1) {
				pair = new Point[1];
				pair[0] = points[0];
			}
			else {
				pair = new Point[2];
				double minDist = Double.POSITIVE_INFINITY;
				int min1=-1, min2=-1;
				for (int i=0; i<size;i++)
					for(int j=i+1; j<size; j++){
						double distIJ =  points[i].euclidDist(points[j]);
						if( distIJ < minDist){
							min1 = i;
							min2 = j;
							minDist = distIJ;
						}
					}
				pair[0] = points[min1];
				pair[1] = points[min2];
			}
		}
		return pair;
	}


	/**
	 * @param args:no args
	 */
	public static void main(String[] args) {
		// TODO test all cloud methods
		Cloud square = new Cloud(4);
		if(!square.isEmpty())
			System.out.println("Error: square should be empty!");
		if(square.isFull())
			System.out.println("Error: square is not full yet!");

		System.out.println("initial square: " + square);
		Point p31 = new Point(3.0,1.0);


		if(square.addPoint(p31))
			System.out.println(p31 + " added");
		else
			System.out.println("Error: square should not be full yet!");

		Point p22 = new Point(2.0,2.0);
		if(square.addPoint(p22))
			System.out.println(p22 + " added");
		else
			System.out.println("Error: square should not de full yet!");

		Point p42 = new Point(4.0,2.0);
		if(square.addPoint(p42))
			System.out.println(p42 + " added");
		else
			System.out.println("Error: square should not be full yet!");

		Point p33 = new Point(3.0,3.0);
		if(square.addPoint(p33))
			System.out.println(p33 + " added");
		else
			System.out.println("Error: square should not de full yet!");


		Point p77 = new Point(7,7);
		if (square.addPoint(p77))
			System.out.print("Error: square should be full!");
		else
			System.out.println("square is full: " + p77 + " not added" );

		System.out.println("final square: " + square);

		if (square.hasPoint(p77))
			System.out.println("Error: point " + p77 + " is not in square!");
		else
			System.out.println("OK: point " + p77 + " is not in square");

		if (square.hasPoint(p22))
			System.out.println("OK: point " + p22 + " in square");
		else
			System.out.println("Error: point " + p22 + " is in square!");

		Point[] extrs = square.extremes();
		if(extrs!=null){
			System.out.println("leftmost point in square: " + extrs[0]);
			System.out.println("rightmost point in square: " + extrs[1]);
			System.out.println("highest point in square: " + extrs[2]);
			System.out.println("lowest point in square: " + extrs[3]);
			System.out.println("center point in square: " + square.centerP());
		}
		Point[] minPair = square.minDist();
		if(minPair!=null){
			System.out.println("min dist pair: (" + minPair[0] + "," + minPair[1]+")");					
		}

		System.out.println("\n\nTest cloud with 1 point");
		Cloud cloud1 = new Cloud(1);
		Point p = new Point();
		cloud1.addPoint(p);
		minPair = cloud1.minDist();
		if(minPair!=null)
			if (minPair.length==1)
				System.out.println("min dist one point: " + minPair[0]);
			else
				System.out.println("min dist pair: (" + minPair[0] + "," + minPair[1]+")");

	}

}