import java.util.Vector;
import java.util.Observer;
import java.util.Observable;
import java.awt.*;

public class Grapher extends Canvas implements Observer
{
	Vector graphs=new Vector(0,1);
	protected GraphicsWrapper gw=null;
	protected float xInc, yInc;
	protected boolean showAxes;
	protected boolean showLabels;
	protected boolean scroll;
	protected float xMin;
	protected long minRedrawTime;
	protected long lastRedrawTime=0;
	public Grapher(int rw, int rh, float minX, float maxX, float minY, float maxY)
	{
		setAbsoluteMetrics(rw,rh,minX,maxX,minY,maxY);
		setMinRedrawTime(500);
		noAxes();
	}
	public void setMinRedrawTime(long millis)
	{
		minRedrawTime=millis;
	}
	protected boolean canRedraw()
	{
		long time=System.currentTimeMillis();
		if (time-lastRedrawTime>minRedrawTime)
		{
			lastRedrawTime=time;
			return true;
		}
		return false;
	}
	public Grapher(int rw, int rh, float xWidth, float minY, float maxY)
	{
		setScrollMetrics(rw,rh,xWidth,minY,maxY);
	}
	public Grapher(float minX, float maxX, float minY, float maxY)
	{
		this(0,0,minX,maxX,minY,maxY);
	}
	public Grapher(float xWidth, float minY, float maxY)
	{
		this(0,0,xWidth,minY,maxY);
	}
	public void addGraph(Graph g)
	{
		graphs.addElement(g);
		g.addObserver(this);
	}
	public void removeGraph(Graph g)
	{
		if (graphs.removeElement(g))
			g.deleteObserver(this);
	}
	public void removeGraphs()
	{
		Graph g;
		for (int i=0; i<graphs.size(); i++)
		{
			g=(Graph)graphs.elementAt(i);
			g.deleteObserver(this);
		}
		graphs=new Vector(0,1);
	}
	public void setAbsoluteMetrics(int realWidth, int realHeight, float minX, float maxX, float minY, float maxY)
	{
		scroll=false;
		setMetrics(realWidth,realHeight,minX,maxX,minY,maxY);
	}
	public void setScrollMetrics(int realWidth, int realHeight, float minX, float xWidth, float minY, float maxY)
	{
		scroll=true;
		setMetrics(realWidth,realHeight,minX,minX+xWidth,minY,maxY);
		xMin=minX;
	}
	public void setScrollMetrics(int realWidth, int realHeight, float xWidth, float minY, float maxY)
	{
		setScrollMetrics(realWidth, realHeight, 0, xWidth, minY, maxY);
	}
	protected void setMetrics(int realWidth, int realHeight, float minX, float maxX, float minY, float maxY)
	{
		if (gw==null)
			gw=new GraphicsWrapper(realWidth, realHeight, minX, maxX, minY, maxY);		
		else
			gw.getGraphWindow().setMetrics(realWidth,realHeight,minX,maxX,minY,maxY);
	}
	public void setDimensions(int realWidth, int realHeight)
	{
		if (gw!=null)
		{
			GraphWindow win=gw.getGraphWindow();
			win.setMetrics(realWidth,realHeight,
				win.getMinX(),win.getMaxX(),
				win.getMinY(),win.getMaxY());
		}
		else
		{
			setMetrics(realWidth,realHeight,0,0,0,0);
		}
	}	
	public GraphWindow getGraphWindow()
	{
		return gw.getGraphWindow();
	}
	public void setShowLabels(boolean show)
	{
		showLabels=show;
	}
	public boolean getShowLabels()
	{
		return showLabels;
	}
	public void setAxes(float xInc, float yInc)
	{
		this.xInc=xInc;
		this.yInc=yInc;
		this.showAxes=true;
		showAxes=(xInc!=0)&&(yInc!=0);
	}
	public void noAxes()
	{
		showAxes=false;
	}
	public void paint(Graphics g)
	{
		//System.out.println("Ran grapher paint");
		if (canRedraw())
		{
			clear(g);
			if (scroll)
			{
				GraphWindow win=gw.getGraphWindow();
				float max=getMaxX();
				float width=win.getMaxX()-win.getMinX();
				float min=max-width;
				if (min < xMin)
				{
					max=xMin+width;
					min=0;
				}		
				setMetrics(win.getRealWidth(),win.getRealHeight(),
					min,max,win.getMinY(),win.getMaxY());			
			}
			gw.setGraphics(g);
			if (showAxes)
				drawAxes(g);
			int len=graphs.size();
			for (int i=0; i<len; i++)
				render((Graph)graphs.elementAt(i),g);
		}
	}
	public void update (Observable o, Object arg)
	{
		if (o instanceof Graph)
			repaint();
			//paint(this.getGraphics());
	}
	protected float getMaxX()
	{
		float max=0;
		int len=graphs.size();
		if (len!=0)
		{
			float x;
			for (int i=0; i<len; i++)
			{
				x=((Graph)graphs.elementAt(i)).getMaxX();
				if (x > max) max=x;
			}
		}
		return max;
	}		
	protected void drawAxes(Graphics g)
	{
		gw.setColor(Color.black);
		gw.setGraphics(g);
		GraphWindow win=gw.getGraphWindow();
		float minx=win.getMinX();
		float maxx=win.getMaxX();
		float miny=win.getMinY();
		float maxy=win.getMaxY();
		if (0>=minx&&0<=maxx)
			gw.drawLine(new GraphPoint(0,miny), new GraphPoint(0,maxy));
		if (0>=miny&&0<=maxy)
			gw.drawLine(new GraphPoint(minx,0), new GraphPoint(maxx,0));
		float pty = 0 > miny ? 0 : miny;
		float ptx = 0 > minx ? 0 : minx;
		float inix=((int)(minx/xInc))*xInc;
		float iniy=((int)(miny/yInc))*yInc;

		GraphPoint a;
		int x, y;
		for (float cx=inix; cx<=maxx; cx+=xInc)
		{
			a=gw.getGraphWindow().translate(new GraphPoint(cx,pty));
			x = (int)a.getX();
			y = (int)a.getY();
			g.drawLine(x,y,x,y-5);
			if (showLabels)
				if (cx==0)
					g.drawString("O",x+5,y-5);
				else	
					g.drawString(String.valueOf(cx),x,y-5);
		}
		for (float cy=iniy; cy<=maxy; cy+=yInc)
		{
			a=gw.getGraphWindow().translate(new GraphPoint(ptx,cy));
			x = (int)a.getX();
			y = (int)a.getY();
			g.drawLine(x,y,x+5,y);
			if (showLabels)
				if (cy!=0)
					g.drawString(String.valueOf(cy),x+5,y);
				else
					if (ptx!=0)
						g.drawString(String.valueOf(cy),x+5,y);
		}
	}
	protected void clear(Graphics g)
	{
		g.setColor(Color.white);
		GraphWindow win=gw.getGraphWindow();
		g.fillRect(0,0,win.getRealWidth(),win.getRealHeight());
	}
	protected void render(Graph graph, Graphics graphics)
	{
		gw.setGraphics(graphics);
		GraphWindow win=gw.getGraphWindow();
		Vector points=graph.getPointsBetween(win.getMinX(),win.getMaxX());
		int style=graph.getStyle();
		//System.out.println(graph.getName()+" : "+graph.getColor());
		graphics.setColor(graph.getColor());
		GraphPoint ptA;
		for (int i=0; i<points.size(); i++)
		{
			ptA=(GraphPoint)points.elementAt(i);
			if (style==Graph.DOTTED)
				gw.drawPoint(ptA);
			if (style==Graph.LINE)
				if (i!=0)
					gw.drawLineSegment(ptA,(GraphPoint)points.elementAt(i-1));
				else
					gw.drawPoint(ptA);
		}
	}
	public void finalize() throws Throwable
	{
		removeGraphs();
		super.finalize();
	}
	public Dimension preferredSize()
	{
		GraphWindow win=gw.getGraphWindow();
		return new Dimension (win.getRealWidth(), win.getRealHeight());
	}
	public Dimension minimumSize()
	{
		return preferredSize();
	}
}