import java.awt.geom.Point2D;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * PointPlot ist eigentlich nichts weiter als eine Liste
 * von Punkten. Die Funktion besteht also nur aus einzelnen
 * Punkten, die dann später beim graphischen Darstellen 
 * miteinander verbunden werden.
 * 
 */
public class PointPlot implements Plot {

	private List<Point2D.Double> points;
	
	/**
	 * Erzeugt aus der übergebenen java.util.List einen
	 * PointPlot.
	 * 
	 * @param points
	 */
	public PointPlot(List<Point2D.Double> points) {
		this.points = points;
	}

	
	public List<Point2D.Double> getPoints() {
		return points;
	}

	
	/**
	 * Sucht zwischen welchen 2 angegebenen Punkten der übergebene 
	 * Wert liegt und bildet eine Geradengleichung y = mx + t.
	 * Daraus wird dann der Wert für value berechnet.
	 */
	public double compute(double value) {
		Collections.sort(points, new PointComparator());
		
		if(value < points.get(0).x || value > points.get(points.size()-1).x) {
			return Double.NaN;
		}
		
		Point2D.Double left = null, right = null;
		for(int i=0; i<points.size()-1; i++) {
			if(points.get(i).x < value) {
				left = points.get(i);
				right = points.get(i+1);
			}
		}
		
		if(left == null || right == null) {
			return Double.NaN;
		}
		
		double vec_x = right.x - left.x;
		double vec_y = right.y - left.y;
		double m = vec_y / vec_x;
		double t = left.y - m * left.x;
		double y = m * value + t;
		
		return y;
	}
	
	
	/**
	 * Da Point2D.Double nicht das Comparator<T> Interface implementiert,
	 * wir aber die Punkte sortieren müssen, brauchen wir einen eigenen
	 * Comparator<Point2D.Double> um mittels Collections.sort(List<T extends Comparator>)
	 * sortieren zu können.
	 */
	private class PointComparator implements Comparator<Point2D.Double> {

		public int compare(Point2D.Double p1, Point2D.Double p2) {
			if(p1.x < p2.x) {
				return -1;
			} else if(p1.x == p2.x) {
				return 0;
			} else {
				return 1;
			}
		}
		
	}
	
}