/*
    * Trip Tracker, a real-time position tracking system for the Internet.
    * Copyright (C) 2006  Team Trip Tracker
    *
    * This program is free software; you can redistribute it and/or modify it
    * under the terms of the GNU General Public License as published by the
    * Free Software Foundation; either version 2 of the License, or (at your
    * option) any later version.
    *
   * This program is distributed in the hope that it will be useful, but
   * WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
   * General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License along
   * with this program; if not, write to the Free Software Foundation, Inc.,
   * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
   */
  
  package triptracker.client.map.ui;
  
  import java.awt.BasicStroke;
  import java.awt.Color;
  import java.awt.Graphics;
  import java.awt.Graphics2D;
  import java.awt.Shape;
  import java.awt.event.MouseListener;
  import java.awt.geom.QuadCurve2D;
  import java.awt.geom.CubicCurve2D;
  import java.util.Iterator;
  import java.util.List;
  
  import javax.swing.ImageIcon;
  
  import triptracker.client.map.core.WMSMapProvider;
  import triptracker.client.net.MapSocket;
  import triptracker.client.net.MapSocketAdapter;
  import triptracker.core.Coordinate;
  
  @SuppressWarnings("serial")
  public class Map extends SuperPanel {
  	private BasicStroke stroke = new BasicStroke(2.0f);
  	private boolean drawNumbers = false;
  	private boolean drawPoints = true;
  	private boolean drawMap = true;
  	
  	private MapViewPanel view;
  	
  	private int OVAL_SIZE = 2;
  	private Graphics2D g2;
  //	private Coordinate lastCoord;
  	private int follow = 2; // 1 = Don't follow, 2 = Always inside, 3 = Center on last
  	private boolean update = true;
  	private int action = 1; //1 = move, 2 = zoom
  //	private final double weight = 3;
  	private double centerX, centerY;
  //	limits[0] = xMin, limits[1] = yMin, limits[2] = xMax, limits[3] = yMax
  	private double[] limits, mapLim;
  	private double ratio = 1;
  	
  	private WMSMapProvider mapProvider;
  	private ImageIcon mapImage;
  	
  	public Map(MapSocket model, MapViewPanel view) {
  		this.view = view;
  		this.setBackground(Color.white);
  		
  		mapProvider = new WMSMapProvider(getHeight(), getWidth());
  		
  		new MapController(this);
  		model.addListener(new MapListener());
  	}
  	
  	public void addMapListener(MouseListener listener) {
  		this.addMouseListener(listener);
  	}
  	
  	private void update() {
  		update = true;
  	}
  	
  	/***
  	 * Update the map image in the background.
  	 */
  	private void updateMap() {
  		if (limits == null) {
  			return;
  		}
  
  		double minX, minY, maxX, maxY;
  			minX = mapLim[0];
  			minY = mapLim[1];
  			maxX = mapLim[2];
  			maxY = mapLim[3];
  		mapProvider.setSize(getWidth(), getHeight());
  		mapImage = mapProvider.getMap(minX, minY, maxX, maxY);
  	}
  	
  	@Override
     protected void paintComponent(Graphics g) {
 		super.paintComponent(g);
 		g2 = (Graphics2D) g;
 		g2.setColor(Color.red);
 		g2.drawRect(0, 0, getSize().width - 1, getSize().height - 1);
 		g2.setColor(Color.black);
 		if (!coordList.isEmpty()) {
 			ratio = getRatio(limits);
 			if (action != 3 && follow != 3 && update && drawMap)
 				updateMap();
 				update = false;
 		}
 
 		if (mapImage != null && follow != 3 && action != 3 && drawMap) {
 			g2.drawImage(mapImage.getImage(), 0, 0, getWidth(), getHeight(),
 					this);
 		}
 		
 		g2.setStroke(stroke);
 		if (!coordList.isEmpty()) {
 			drawStraightRoute(coordList);
 		}
 	}
 	
 	/*** Sets route to plot */
     public void setCoordList(List<Coordinate> coordList) {
 //    	limits[0] = xMin, limits[1] = yMin, limits[2] = xMax, limits[3] = yMax	
     		update();
 		this.coordList = coordList;
 		limits = getLimits(coordList);
 		ratio = getRatio(limits);
 		mapLim = getLimits(coordList);
 //		lastCoord = coordList.get(coordList.size() -1);
 		double x = calcX(limits[2]);
 		double y = calcY(limits[1]);
 		mapLim[2] = mapLim[2] + (((getWidth() - x)/ratio));
 		mapLim[1] = mapLim[1] - (((getHeight() - y)/ratio));
 		
 //		System.out.println("mapLim: " + Arrays.toString(mapLim));
 //		System.out.println("limits: " + Arrays.toString(limits));
 		repaint();
 	}
     
     /*** Resets map to initial size */
     public void reset(){
     		setCoordList(coordList);
     }
     
     /*** Sets realtime if route is plotted realtime */
 	public void setRealtime(boolean realtime) {
 		this.realtime = realtime;
 	}
 
 	public void setView(boolean nr, boolean dot, boolean map, int thick){
 		drawNumbers = nr;
 		drawPoints = dot;
 		drawMap = map;
 		stroke = new BasicStroke(thick);
 	}
 	
 	/*** Sets mouseklick to zoom to position */
 	public void setZoom() {
 		action = 2;
 	}
 
 	/*** Sets mouseklick to move to position */
 	public void setMove() {
 		action = 1;
     }
     
 	/*** If selected, will follow coordinates under realtime plotting */
 	public void setFollow(int follow) {
 //		if (follow)
 //			action = 3;
 //		else {
 //			action = 1;
 //		}
 		this.follow = follow;
 		if (follow != 3){
 			update();
 			repaint();
 		}
 		
 	}
 	
     /***
 	 * Return edge limits for the given set of coordinates.
 	 * 
 	 * @param coordList list of coordinates
 	 * @return edge limits for coordinate set
 	 */
     public double[] getLimits(List<Coordinate> coordList) {
 //    	limits[0] = xMin, limits[1] = yMin, limits[2] = xMax, limits[3] = yMax
 		double[] limits = { Double.MAX_VALUE, Double.MAX_VALUE,
 				Double.MIN_VALUE, Double.MIN_VALUE };
 		for (Coordinate coord : coordList) {
 			if (coord.getX() < limits[0]) {
 				limits[0] = coord.getX();
 			}
 			if (coord.getY() < limits[1]) {
 				limits[1] = coord.getY();
 			}
 			if (coord.getX() > limits[2]) {
 				limits[2] = coord.getX();
 			}
 			if (coord.getY() > limits[3]) {
 				limits[3] = coord.getY();
 			}
 		}
 		int factor = 10;
 		double width = limits[2] - limits[0];
 		double height = limits[3] - limits[1];
 		limits[0] -= width/factor;
 		limits[1] -= height/factor;
 		limits[2] += width/factor;
 		limits[3] += height/factor;
 		return limits;
 	}
     
     /*** Returns borders of what to show */
     public double[] setBorders(double[] limits) {
 		double[] borders = { Double.MAX_VALUE, Double.MAX_VALUE,
 				Double.MIN_VALUE, Double.MIN_VALUE };
 		borders[0] = 0; // limits[0] - limits[0];
 		borders[1] = 0; // limits[1] - limits[1];
 		borders[2] = limits[2] - limits[0];
 		borders[3] = limits[3] - limits[1];
 		return borders;
 	}
 
     /***
      * Sets the ratio between route bounds and actual window size. Used for
      * scaling route.
      * 
      * @param limits = limits of route
      * @return ratio
      */
 	public double getRatio(double[] limits) {
 		double ratio;
 		double xWidth = limits[2] - limits[0];
 		double yWidth = limits[3] - limits[1];
 
 		if ((xWidth / getWidth()) > yWidth / (getHeight())) {
 			ratio = getWidth() / xWidth;
 		} else {
 			ratio = getHeight() / yWidth;
 		}
 //		System.out.println("Ratio: " + ratio + ", width: " + xWidth
 //				+ ", " + yWidth + " size: " + getWidth() + ", " + getHeight());
 		return ratio;
 	}
     
 	/***
 	 * Draw route.
 	 * 
 	 * @param coordList list of coordinates for route
 	 */
     public void drawStraightRoute(List<Coordinate> coordList) {
 		int x = 0, y = 0, prevX = 0, prevY = 0;
 		int nr = 0;
 		Iterator itr = coordList.iterator();
 		Coordinate coord = (Coordinate) itr.next();
 		
 		//Draw first point
 		x = (int) calcX(coord.getX());
 		y = (int) calcY(coord.getY());
 		nr ++;
 		if (drawPoints)
 			g2.drawOval(x,y,OVAL_SIZE,OVAL_SIZE);	
 		if (drawNumbers)
 			g2.drawString(nr + "",x,y);
 		
 		//Draw rest of route
 		while (itr.hasNext()) {
 			coord = (Coordinate) itr.next();
 			prevX = x;
 			prevY = y;
 			nr++;
 
 			x = (int) calcX(coord.getX());
 			y = (int) calcY(coord.getY());
 
 //			System.out.println("Drawing: " + x + ", " + y + ", " + prevX
 //					+ ", " + prevY);
 			g2.drawLine(x, y, prevX, prevY);// (startx, starty, prevx, prevy);
 			if (drawPoints)
 				g2.drawOval(x, y, OVAL_SIZE, OVAL_SIZE);									
 			//g2.drawString("Pos: " + coord.getX() + ", " + coord.getY(),x,y);
 			if (drawNumbers)
 				g2.drawString(nr + "", x, y);
 			// + coord.getX() + ", " + coord.getY(), x, y);
 //			drawBezierRoute(coordList);
 		}
 	}
     
     /*** Drawing route in bezier splines */
     // TODO make this work nicely
     public void drawBezierRoute(List<Coordinate> coordList) {
 		double x1, x2, x3, x4, y1, y2, y3, y4;
 		Shape curve = null;
 
 		Iterator itr = coordList.iterator();
 		Coordinate coord = (Coordinate) itr.next();
 		x2 = calcX(coord.getX());
 		y2 = calcY(coord.getY());
 		
 		coord = (Coordinate) itr.next();
 		x3 = calcX(coord.getX());
 		y3 = calcY(coord.getY());
 		
 		coord = (Coordinate) itr.next();
 		x4 = calcX(coord.getX());
 		y4 = calcY(coord.getY());
     		
 	    	for (Coordinate coordz : coordList) {
 				x1 = x2; x2 = x3; x3 = x4; x4 = calcX(coordz.getX());
 				y1 = y2; y2 = y3; y3 = y4; y4 = calcY(coordz.getY());
 	//    		curve = new QuadCurve2D.Double(x1, y1, x2, y2, x3, y3);
 //				double wx1 = x2 + (sqrt(pow(x1 - x2, 2))) / weight * x1 - x3;
 //				double wy1 = y2 + (sqrt(pow(y1 - y2, 2))) / weight * y1 - y3;
 //				double wx2 = x3 + (sqrt(pow(x2 - x3, 2))) / weight * x2 - x4;
 //				double wy2 = y3 + (sqrt(pow(y2 - y3, 2))) / weight * y2 - y4;
 				
 				double wx1 = x2 + (x2-x1);
 				double wy1 = y2 + (y2-y1);
 				double wx2 = x3 + (x4-x3);
 				double wy2 = y3 + (y4-y3);
 	    			
 	//			double wx1 = x2 + (sqrt(pow(x2 - x1, 2)
 	//					+ (pow(y2 - y1, 2)))) / weight * x3 - x1;
 	//			double wy1 = y2 + (sqrt(pow((x2 - x1), 2)
 	//					+ (pow(y2 - y1, 2)))) / weight * y3 - y1;
 	//			double wx2 = x3 + (sqrt(pow((x3 - x2), 2)
 	//					+ (pow(y3 - y2, 2)))) / weight * x4 - x2;
 	//			double wy2 = y3 + (sqrt(pow((x3 - x2), 2)
 	//					+ (pow(y3 - y2, 2)))) / weight * y4 - y2;
 	    			
 	//    		curve = new CubicCurve2D.Double(x1,y1,x2,y2,x3,y3,x4,y4);
 				curve = new CubicCurve2D.Double(x2, y2, wx1, wy1,
 						wx2, wy2, x3, y3);
 				g2.draw(curve);
 	    	}
 //		curve = new QuadCurve2D.Float(x, y, prevX, prevY, w * .9f, yy);
 		curve = new QuadCurve2D.Double(100, 100, 150, 150, 200, 100);
     		
 		g2.draw(curve);
     }
     
     /*** For adding coordinate while route is beeing plotted realtime. */
     public void addCoordinate(Coordinate coord) {
 		double x = calcX(coord.getX());
 		double y = calcY(coord.getY());
 //		double prevX = calcX(lastCoord.getX());
 //		double prevY = calcY(lastCoord.getY());
 		coordList.add(coord);
 //		System.out.println("Added coordinate, " + coordList.size());
 		
 		switch(follow) {
 			case 1:
 				repaint();
 				break;
 			case 2:
 				checkLimits((int) x ,(int) y);
 				repaint();
 				break;
 			case 3:
 				setCenter(x, y);
 				break;		
 		}
     }
     
    
     /*** Checking if coordinate is outside of window */
     public void checkLimits(int x, int y){
     	int factor = 10;
     	int w = (getWidth() / factor);
     	int h = (getHeight() / factor);
     		if ( x < (0 + w) || x > (getWidth() - w) || y < (0 + h) || y > (getHeight() - h))
     			setCenter(x,y);
     }
     
     /*** Calculates x coordinate for plotting */
     public double calcX(double x) {
  		return (ratio * (x - limits[0]));
     }
     
     /*** Calculates y coordinate for plotting */
     public double calcY(double y) {
 		return -(ratio * (y - limits[3]));
 	}
     
     /***
      * Magnifies route with specified zoomRatio
      *
      */
     public void zoomIn() {
     		limits = zoomInMatrix(limits);
 		mapLim = zoomInMatrix(mapLim);
 		update();
 		repaint();
     }
     
     /*** Zooms out route with specified zoomRatio */
     public void zoomOut() {
     		limits = zoomOutMatrix(limits);
 		mapLim = zoomOutMatrix(mapLim);
 		update();
 		repaint();
     }
     
     /*** Handles action for mouseclick. */
 	public void mouseClick(double x, double y, int button) {
 		switch (action) {
 		case 1:
 			if (!coordList.isEmpty())
 				setCenter(x, y);
 			else 
 				view.setState("No route is set!  ");
 			break;
 		case 2:
 			if (!coordList.isEmpty() && button != 3){
 				setCenter(x, y);
 				zoomIn();
 			}
 			else if (!coordList.isEmpty()) {
 				setCenter(x, y);
 				zoomOut();
 			}
 			else 
 				view.setState("No route is set!  ");
 			break;
 		}
 	}
     
     /*** Sets position x,y to center of view */
 	public void setCenter(double x, double y) throws NullPointerException {
 		centerX = getWidth() / 2;
 		centerY = getHeight() / 2;
 		double moveX = x - centerX;
 		double moveY = y - centerY;
 		go(moveX, moveY);
 	}
     
     /*** Moves window specified pixel length, from center. */
 	public void go(double mvX, double mvY) {
 		double moveXFactor, moveYFactor;
 		moveXFactor = mvX / (getWidth()/2);
 		moveYFactor = mvY / (getHeight()/2);
 		mvX = (((mapLim[2] - mapLim[0])/2) * moveXFactor) ;
 		mvY = -(((mapLim[3] - mapLim[1])/2) * moveYFactor) ;
 		mapLim = moveMatrix(mapLim, mvX,mvY);
 		limits = moveMatrix(limits, mvX,mvY);
 
 		update();
 		repaint();
 	}
     
     public double[] zoomInMatrix(double[] x) {
 //		limits[0] = xMin, limits[1] = yMin, limits[2] = xMax, limits[3] = yMax
     		double distX = (mapLim[2] - mapLim[0])/2;
     		double distY = (mapLim[3] - mapLim[1])/2;
 //		double distX = (x[2] - x[0])/2;
 //		double distY = (x[3] - x[1])/2;
     		x[0] = x[0] + (distX/2);
     		x[1] = x[1] + (distY/2);
     		x[2] = x[2] - (distX/2);
     		x[3] = x[3] - (distY/2);
     		return x;
     }
     
     public double[] zoomOutMatrix(double[] x) {
 //		limits[0] = xMin, limits[1] = yMin, limits[2] = xMax, limits[3] = yMax
 //		double distX = (x[2] - x[0])/2;
 //		double distY = (x[3] - x[1])/2;
 		double distX = (mapLim[2] - mapLim[0])/2;
 		double distY = (mapLim[3] - mapLim[1])/2;
 		x[0] = x[0] - distX;
 		x[1] = x[1] - distY;
 		x[2] = x[2] + distX;
 		x[3] = x[3] + distY;
 		return x;
     }
 	
     public double[] moveMatrix(double[] matrix, double mvX, double mvY) {
 		matrix[0] = matrix[0] + mvX;
 		matrix[1] = matrix[1] + mvY;
 		matrix[2] = matrix[2] + mvX;
 		matrix[3] = matrix[3] + mvY;
 		return matrix;
     }
     
     /*** Listens for events from MapSocket */
 	private class MapListener extends MapSocketAdapter {
 		/*** {@inheritDoc} */
 		@Override
 		public void coordReceived(int routeId, Coordinate coord) {
 		//	if (coordList == null){
 			int limit = 40;
 //			System.out.println("Size: " + coordList.size());
 			if (coordList.size() < limit){
 //				System.out.println("CoordList is < " + limit);
 				coordList.add(coord);
 				view.setCoordList(coordList);
 				return;
 			} else if (coordList.size() == limit){
 //				System.out.println("Setting coordList");
 				setCoordList(coordList);
 				view.setState("Received route");
 			}
 			addCoordinate(coord);
 		}
 		
 		/*** {@inheritDoc} */
 		@Override
 		public void coordsReceived(List<Coordinate> coords) {
 //			System.out.println("Size: " + coordList.size());
 			int limit = 30;
 			if ((coordList.size() + coords.size()) < limit){
 //				System.out.println("CoordList is < " + limit);
 				coordList.addAll(coords);
 				view.setCoordList(coordList);
 				return;
 			} else if ((coordList.size() + coords.size()) >= limit){
 //				System.out.println("Setting coordList");
 				coordList.addAll(coords);
 				setCoordList(coordList);
 				view.setState("Received route");
 			}
 		}
 	}
 }