//PlotPanel.java

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.text.*; 

public class PlotPanel extends JPanel {

    double [] X, Y;
    double a, b, c;
    double x1, x2, vertexX, vertexY, focusX, focusY, directrix;
    double xLo,  xHi,  yLo,  yHi, tickInterval;
    boolean newplot;

    int spx, spy;
    boolean newMouseDrag;
    
    public void paintComponent(Graphics g) {

	addMouseMotionListener(
	       new MouseMotionAdapter() {
		   public void mouseDragged( MouseEvent event) {
	               spx = event.getX();
	               spy = event.getY();
	               newMouseDrag = true;
		       repaint();    
		   } 
	       }
	 );    

	g.setFont( new Font( "SansSerif", Font.BOLD, 12 ) );
	//	if (newplot) 
	super.paintComponent(g);   //otherwise add to existing grid
	//seems to have no effect???  i.e. always cleared
	
	int w=getWidth();     //panel size
	int h=getHeight();    
	double xWidth = xHi - xLo;   //user grid size
	double yHeight = yHi - yLo;
	double xScale = w / xWidth;   //scale user to panel
	double yScale = h / yHeight;
	double xOffset = xLo * xScale;
	double yOffset = yLo * yScale;
        DecimalFormat d3;
	d3 = new DecimalFormat ("0.000");

	g.setColor(Color.WHITE);
	g.fillRect(0,0,w,h);

	g.setColor(Color.BLACK);
	g.drawString("Drag point on curve to see tangent", 0,20);
	
	int xAxis = (int)(h+yOffset);
	int yAxis = (int)(-xOffset);
	g.drawLine(0,xAxis,w,xAxis );   //x axis
	g.drawLine(yAxis,0,yAxis,h);    //y axis

	for (double tick=tickInterval; tick<=xHi; tick+=tickInterval) {
	    g.setColor(Color.LIGHT_GRAY);
	    g.drawLine((int)(tick * xScale - xOffset),0,(int)(tick * xScale - xOffset),h);
	    g.setColor(Color.BLACK);
	    g.drawLine((int)(tick * xScale - xOffset),xAxis-3,(int)(tick * xScale - xOffset),xAxis+3);
	}
	for (double tick=-tickInterval; tick>=xLo; tick-=tickInterval) {
	    g.setColor(Color.LIGHT_GRAY);
	    g.drawLine((int)(tick * xScale - xOffset),0,(int)(tick * xScale - xOffset),h);
	    g.setColor(Color.BLACK);
	    g.drawLine((int)(tick * xScale - xOffset),xAxis-3,(int)(tick * xScale - xOffset),xAxis+3);
	}
	for (double tick=tickInterval; tick<=yHi; tick+=tickInterval) {
	    g.setColor(Color.LIGHT_GRAY);
	    g.drawLine(0,h-(int)(tick * yScale - yOffset), w,h-(int)(tick * yScale - yOffset));
	    g.setColor(Color.BLACK);
	    g.drawLine(yAxis-3,h-(int)(tick * yScale - yOffset),yAxis+3,h-(int)(tick * yScale - yOffset));
	}
	for (double tick=-tickInterval; tick>=yLo; tick-=tickInterval) {
	    g.setColor(Color.LIGHT_GRAY);
	    g.drawLine(0,h-(int)(tick * yScale - yOffset), w,h-(int)(tick * yScale - yOffset));
	    g.setColor(Color.BLACK);
	    g.drawLine(yAxis-3,h-(int)(tick * yScale - yOffset),yAxis+3,h-(int)(tick * yScale - yOffset));
	}

	int x, y;
	//if (X != null) {     //won't happen now

	    double distanceFV = Math.abs(focusY-vertexY);
	    g.setColor(Color.PINK);   //latus rectum
	    g.drawLine((int)(focusX * xScale - xOffset), h - (int)(focusY * yScale - yOffset), 
	    	       (int)((focusX-2*distanceFV) * xScale - xOffset), h - (int)(focusY * yScale - yOffset));
	    g.drawLine((int)(focusX * xScale - xOffset), h - (int)(focusY * yScale - yOffset), 
	    	       (int)((focusX+2*distanceFV) * xScale - xOffset), h - (int)(focusY * yScale - yOffset));

	    g.setColor(Color.RED);
	    for (int i=0; i<X.length; i++) {
		x = (int)(X[i] * xScale - xOffset);
		y = h - (int)(Y[i] * yScale - yOffset);
		//g.drawLine(x,y,x,y);
		g.fillRect(x-1,y-1,2,2);
	    }
	    
	 
	    g.setColor(Color.GREEN);   //focus
	    g.fillRect((int)(focusX * xScale - xOffset)-2,h - (int)(focusY * yScale - yOffset)-2, 4,4);

	    g.setColor(Color.YELLOW);   //directrix
	    g.drawLine(0, h-(int)(directrix * yScale - yOffset), w,h-(int)(directrix * yScale - yOffset));	               

	    g.setColor(Color.CYAN);   //zeroes
	    if (x1 != Double.POSITIVE_INFINITY)
		g.fillRect((int)(x1 * xScale - xOffset)-2,h - (int)(0 * yScale - yOffset)-2, 4,4);
	    if (x2 != Double.POSITIVE_INFINITY)
		g.fillRect((int)(x2 * xScale - xOffset)-2,h - (int)(0 * yScale - yOffset)-2, 4,4);

	    g.setColor(Color.MAGENTA);   //vertex
	    g.fillRect((int)(vertexX * xScale - xOffset)-2,h - (int)(vertexY * yScale - yOffset)-2, 4,4);
	//}

	if (newMouseDrag) {
	    newMouseDrag = false;  //one time only per drag
	    
	    double rpx=(spx+xOffset)/xScale;   //convert from screen pixel to real coords
	    double rpy=(-spy+yOffset+h)/yScale;
	    
	    int sDirectrixY=h-(int)(directrix * yScale - yOffset); //convert from real to screen
	    int sFocusX=(int)(focusX * xScale - xOffset);
	    int sFocusY=h-(int)(focusY * yScale - yOffset);
	    g.setColor(Color.BLACK);
	    //g.drawString("(spx,spy)="+spx+" "+spy+"   "+rpx+" "+rpy, 0,20);
	    //g.drawString("(Fx,Fy)="+sFocusX+" "+sFocusY+"   "+sDirectrixY, 0,40);
	    
	    //must use real coords, screen coords are not scaled 
	    double distMouseFocus =     distanceFormula(rpx,rpy, focusX,focusY);
	    double distMouseDirectrix = distanceFormula(rpx,rpy, rpx,directrix);
	    if (Math.abs(distMouseFocus-distMouseDirectrix)*xScale < 10) {  //within 10 pixels of curve
	        //g.drawString("here",spx,spy);
	        //g.drawString("(pointX,pointY)=("+d3.format(rpx)+","+d3.format(rpy)+")", 0,20);
	        //g.drawString("|Point-Focus|="+d3.format(distMouseFocus)+
	        //	     "    |Point-Directrix|="+d3.format(distMouseDirectrix), 0,40);
	        //g.fillRect(spx,spy   ,2,2);
	        int minDistIndex=0;
	        double thisDist=distanceFormula(X[0],Y[0], rpx,rpy);
	        double minDist=thisDist;
	        for (int i=1; i<Y.length; i++) {    //find y closest to mouse
	            thisDist = distanceFormula(X[i],Y[i], rpx,rpy);
	            if (thisDist < minDist) {
	            	minDistIndex = i;
			minDist = thisDist;
	            }
	        }

		double curveX=X[minDistIndex];
		double curveY=Y[minDistIndex];
		x = (int)(curveX * xScale - xOffset);
		y = h - (int)(curveY * yScale - yOffset);
		g.fillRect(x-2,y-2,3,3);
	  
	        g.drawString("(pointX,pointY)=("+d3.format(curveX)+","+d3.format(curveY)+")", 0,40);
	        distMouseFocus =     distanceFormula(curveX,curveY, focusX,focusY);
	        distMouseDirectrix = distanceFormula(curveX,curveY, curveX,directrix);
	        g.drawString("|Point-Focus|="+d3.format(distMouseFocus)+
	        	     "    |Point-Directrix|="+d3.format(distMouseDirectrix), 0,60);

	        g.setColor(Color.GRAY);   //equidistant lines from point to focus and directrix
	        g.drawLine((int)(focusX * xScale - xOffset), h - (int)(focusY * yScale - yOffset), x,y);
	        g.drawLine(x, h - (int)(directrix * yScale - yOffset), x,y);

		double m = 2*a*curveX + b;
		double yIntercept = curveY - m*curveX;
		double y1 = m*xLo + yIntercept;
		double y2 = m*xHi + yIntercept;;
	        g.setColor(Color.BLUE);
	        g.drawLine((int)(xLo * xScale - xOffset), h - (int)(y1 * yScale - yOffset), x,y);
	        g.drawLine((int)(xHi * xScale - xOffset), h - (int)(y2 * yScale - yOffset), x,y);
	        g.drawString("tangent line: y="+d3.format(m)+"x + "+d3.format(yIntercept), 0,80);
		
	    }
	}

    }
    
    public void newPlot(double[] X, double[] Y, double a, double b, double c,
    	                double x1, double x2, double vertexX, double vertexY, 
    	                double focusX, double focusY, double directrix,
    	                double xLo, double xHi, double yLo, double yHi, double tickInterval) {

	this.xLo = xLo;
	this.xHi = xHi;
	this.a = a;
	this.b = b;
	this.c = c;
	this.yLo = yLo;
	this.yHi = yHi;
	this.tickInterval = tickInterval;
	this.X = X;
	this.Y = Y;
	this.x1 = x1;
	this.x2 = x2;
	this.vertexX = vertexX;
	this.vertexY = vertexY;
	this.focusX = focusX;
	this.focusY = focusY;
	this.directrix = directrix;
	this.newplot = true;
	repaint();    
    }

    //not good.  repaint clears ??
    public void addPlot(double[] X, double[] Y) {

	this.X = X;
	this.Y = Y;
	this.newplot = false;
	repaint();    
    }

   public double distanceFormula (double x1, double y1, double x2, double y2){
    	return Math.sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1));
    }
}