/*
    * 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.server;
  
  import static triptracker.core.Protocol.*;
  
  import java.io.IOException;
  import java.net.Socket;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.concurrent.CopyOnWriteArrayList;
  
  import triptracker.core.Coordinate;
  import triptracker.core.User;
  import triptracker.core.Utils;
  
  /***
   * Handler for coordinate submitter/sender clients.
   */
  public class GPSHandler extends ClientHandler {
  	/*** Listener list for coordinate update events.  */
  	private List<CoordListener> coordListeners =
  		new CopyOnWriteArrayList<CoordListener>();
  	
  	/***
  	 * Sets up socket streams for communication with a GPS client and creates
  	 * the message reader thread for message processing. 
  	 * 
  	 * @param server main server instance
  	 * @param socket client communication socket
  	 * @param user client user data
  	 * @throws IOException on connection failure
  	 */
  	public GPSHandler(Server server, Socket socket, User user)
  			throws IOException {
  		super(server, socket, user);
  	}
  	
  	/***
  	 * The method making sure everything is being shutdown before the handler
  	 * deletes itself.
  	 */
  	// TODO (harald) Not finished yet!!!
  	@Override
  	protected void stopHandler() {	
  		if (coordListeners != null){
  			for (CoordListener listener : coordListeners) {
  				listener.stopLogging(this);
  			}
  		}
  		server.removeGPSHandler(this);
  		coordListeners = null;
  	}
  
  	/***
  	 * {@inheritDoc}
  	 */
  	@Override
  	protected boolean messageHandler(String message) {
  		String[] msg = message.split(DELIMITER);
  		
  		msg = message.split(DELIMITER);
  		try {
  			// Handle message based on first field (msg[0]).
  			switch (Integer.parseInt(msg[0])) {
  			case QUIT:
  				log("Exiting thread and closing connection.");
  				stopLogging();
  				//stopHandler();
  				return false;
  			case COORD_ADD:
  //				 For storing one specific coordinate.
  				double latitude = Double.parseDouble(msg[1]);
  				double longitude = Double.parseDouble(msg[2]);
  				String time = msg[3];
  				Coordinate coord = new Coordinate(latitude, longitude,
  						Utils.parseDate(time));
  
  //				log("latitude: " + latitude + ", longitude "
  //						+ longitude + ", tidspunkt: " + time);
  				storeCoordinate(coord);
  				break;
 			case COORD_BUFFER_ADD:
 				coordBufferAdd(Integer.parseInt(msg[1]));
 				break;
 			case MAKE_ROUTE:
 				String description = msg[1];
 				route = db.makeRoute(user.getUserId(), description, false);
 				sendMessage(out,MAKE_ROUTE,route.getRouteId());
 				log("Has set route to: " + route.toString());
 				break;
 			case SET_ROUTE:
 				 // Set active route.
 				route = db.getRoute(Integer.parseInt(msg[1]));
 				log("Is tracking route: " + route.getRouteId() + ", desc: "
 						+ route.toString());
 				server.checkMapHandler(this);
 				break;
 			case VIEW_ROUTES:
 				viewRoutes(user.getUsername());
 				break;
 			case ROUTE_LOCK:
 				// This will lock the route for further logging.
 				// TODO Check for unlocking too.
 				db.lockRoute(route.getRouteId(), true); 
 				log("Just locked route " + route.getRouteId());
 				break;
 //			case ROUTE_VISIBILITY:
 //				db.setVisible(route.getRouteId(), Utils.strToBool(msg[1]));
 //				break;
 			default:
 				// Invalid/unsupported message.
 				log("Invalid message: " + message);
 				server.invalidMessage(this, message);
 				break;
 			}
 		} catch (NumberFormatException num) {
 			server.invalidMessage(this, message);
 			log("NumberFormatException: " + num);
 			num.printStackTrace();
 		}
 		return true;
 	}
 	
 	/***
 	 * Publish a coordinate to all coordinate listeners and then lets the
 	 * persistency layer store it permanently. The coordinate listeners is
 	 * usually map clients listening in on a route in realtime.   
 	 * 
 	 * @param coord coordinate to publish and permanently store 
 	 */
 	public void storeCoordinate(Coordinate coord) {
 		// Lagre koordinat i database
 		coordinateUpdate(coord);
 		//System.out.println("Route: " + route + ", coord: " + coord);
 		db.storeCoordinate(route.getRouteId(), coord);
 	}
 
 	/***
 	 * For storing coordinates that have been buffered on
 	 * the client for some time. Will recieve them packed in
 	 * gzip, to save transmitt rate.
 	 */
 	public void coordBufferAdd(int size) {
 		System.out.println("Starting buffer add, buffer size: " + size);
 
 		try {
 			String buffIn = in.readLine();
 //			System.out.println("buffIn: " + buffIn);
 			String[] msg = buffIn.split(DELIMITER);
 			
 			List<Coordinate> coords = new ArrayList<Coordinate>();
 			for (int i = 0; i < msg.length; i += 3) {
 				double latitude = Double.parseDouble(msg[i]);
 				double longitude = Double.parseDouble(msg[i + 1]);
 				String time = msg[i + 2];
 //				log("latitude: " + latitude + ", longitude " + longitude
 //						+ ", tidspunkt: " + time);
 				coords.add(new Coordinate(latitude, longitude,
 						Utils.parseDate(time)));
 			}
 			db.storeCoordinate(route.getRouteId(), coords);
 			
 			log("Received buffered coords, size: " + msg.length );
 			coordinateBufferUpdate(msg);
 			
 		} catch (IOException e) {
 			log("Exception recieving stored coordinates: ");
 			e.printStackTrace();
 		}
 		
 //		StringBuilder buffInput = new StringBuilder();
 		
 /*		try {
 //			ZipInputStream gzipBuffer = new ZipInputStream(input);//, size);
 			InflaterInputStream gzipBuffer = new InflaterInputStream(input);
 			
 			byte[] buffer = new byte[2];//size];
 			System.out.println("Started buffer");
 			
 			gzipBuffer.read(buffer);//,0,size);
 			System.out.println("Array: " + buffer[0] + " " + buffer[1]);
 //			String coordBuffer = new String(buffer);
 //			System.out.println("Stringbuffer = " + coordBuffer);
 			
 		} catch (IOException e) {
 			System.out.println("Exception adding buffred coordinates: ");
 			e.printStackTrace();
 		}
 */
 //		int bytesRead = 0;
 //		System.out.println("Entering while loop");
 //		while (bytesRead < 0){
 //			bytesRead = gzipBuffer.read(buffer);
 //			bytesRead = gzipBuffer.read(buffer,0,size);
 //			System.out.println("Read: " + bytesRead);
 //		}
 
 //		byte[] buffer = new byte[256];
 //		while (true) {
 //			int bytesRead = in.read(buffer);
 //			if (bytesRead == -1) break;
 //			out.write(buffer, 0, bytesRead);
 //		}
 
 
 //		while (gzipBuffer.ready()) {
 //			System.out.println("Start of loop.");
 //			String coordBuff = (gzipBuffer.readLine());
 //			System.out.println("Line read!");
 //			String[] coordTable = new String[3];
 //			System.out.println("Coordtable generated");
 //			coordTable = coordBuff.split("" + DELIMITER);
 //										 	
 //			System.out.println("Buffered: " + coordTable[0] +","
 //					+ coordTable[1] +","+ coordTable[2]);
 //			db.storeCoordinate(route,
 //			Double.parseDouble(coordTable[0]),
 //			Double.parseDouble(coordTable[1]), coordTable[2]);
 //		}
 //		gzipBuffer = null;
 	}
 	
 	/***
 	 * Notifies all listeners and send them the coordinate.
 	 * 
 	 * @param coord
 	 */
 	public void coordinateUpdate(Coordinate coord){
 		for (CoordListener listener : coordListeners){
 			listener.coordinateUpdate(coord);
 		}
 	}
 	
 	/***
 	 * Notifies all listeners and send them the buffered coordinates.
 	 * 
 	 * @param coord
 	 */
 	public void coordinateBufferUpdate(String[] coords){
 		for (CoordListener listener : coordListeners){
 			listener.coordinateBufferUpdate(coords);
 		}
 	}
 	
 	public void stopLogging(){
 		for (CoordListener listener : coordListeners) {
 			listener.stopLogging(this);
 		}
 	}
 	
 	/***
 	 * MapHandlers can add themselves to the listener list and recieve updates
 	 * when coordinates are added.
 	 * 
 	 * @param listener listener to add for notification events
 	 */
 	public void addCoordListener(CoordListener listener) {
 		coordListeners.add(listener);
 	}
 	
 	/***
 	 * MapHandlers can add themselves to the listener list and recieve updates
 	 * when coordinates are added.
 	 * 
 	 * @param listener listener to add for notification events
 	 */
 	public void removeCoordListener(CoordListener listener) {
 		coordListeners.remove(listener);
 	}
 	
 }