/*
    * 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.gps.core;
  
  import static triptracker.core.Protocol.*;
  
  import java.io.BufferedReader;
  import java.io.File;
  import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.FileReader;
  import java.io.FileWriter;
  import java.io.IOException;
  import java.io.OutputStreamWriter;
  import java.io.PrintWriter;
  import java.util.List;
  import java.util.TooManyListenersException;
  
  import gnu.io.PortInUseException;
  import gnu.io.UnsupportedCommOperationException;
  
  import triptracker.client.net.GPSSocket;
  import triptracker.client.net.GPSSocketListener;
  import triptracker.core.Coordinate;
  import triptracker.core.Route;
  
  /***
   * GPS Client sends coordinates to a server. This is the model for the GPS
   * client in the MVC separation.
   */
  public class GPSClientModel {
  	private final String TMP_FILE = "tmpBuffer.tmp";
  	private File outputFile = new File(TMP_FILE);
  	private OutputStreamWriter outW = null;
  	private final GPSConnection gps = new GPSConnection();
  	private final GPSSocket socket = new GPSSocket();
  
  	private Coordinate gpsCoord;
  	private Coordinate oldCoord;
  
  	private static String comPort;
  
  	private int interval = 2;
  
  	private boolean transferToServer = false;
  	private boolean recieveFromGPS = false;
  	private boolean autoTransfer = false;
  	private boolean enableCompression = false;
  	private Route activeRoute = new Route(-1, -1, null);
  
  	/***
  	 * Stores temporary coordinates while without internet connection.
  	 */
  	public void storeTmpCoords(Coordinate coord) throws IOException {
  		String message = makeMsg(coord.getY(), coord.getX(), coord
  				.getDateString());
  
  		// Creates the buffer file if it doesent exist
  		if (!outputFile.exists())
  			outputFile.createNewFile();
  
  		// Stores the message to bufferfile
  		PrintWriter tmpOut = new PrintWriter(new FileWriter(outputFile, true));
  		tmpOut.print(message);
  		tmpOut.flush();
  	}
  
  	/***
  	 * Transfers coordinates stored in a temporary file while network was
  	 * unreachable.
  	 */
  	public boolean transferTmpCoords() throws FileNotFoundException,
  			IllegalStateException, IOException {
  		FileReader inputFile;
  		StringBuilder coordBuffer = new StringBuilder();
  
  		inputFile = new FileReader(outputFile);
  		BufferedReader inFile = new BufferedReader(inputFile);
  
  		// Reads from file to StringBuilder
  		String x;
  		while ((x = inFile.readLine()) != null) {
 			System.out.println("Read: " + x);
 			coordBuffer.append(x + DELIMITER);
 		}
 
 		// Closes the file
 		inFile.close();
 
 		// Sends the buffer to server
 		if (socket.sendTmpCoords(coordBuffer)) {
 			inFile.close();
 			if (outputFile.delete())
 				System.out.println("Deleted " + outputFile.toString()
 						+ " file ..");
 			else {
 				System.out.println("Could not delete " + outputFile.toString());
 				throw new IllegalStateException();
 			}
 			return true;
 		} else
 			return false;
 	}
 
 	/***
 	 * Opens the given file
 	 * 
 	 * @param file the given file
 	 * @throws FileNotFoundException 
 	 */
 	public void openFile(String file) throws FileNotFoundException {
 		outW = new OutputStreamWriter(new FileOutputStream("nmeaout.txt"));
 	}
 
 	/***
 	 * Write data from GPS-reciever to a file.
 	 * 
 	 * @param data GPS data to write to file
 	 * @throws IOException if write fails
 	 */
 	public void writeGPSData(String data) throws IOException {
 		// Write ALL data from device to file
 		outW.write(data + "\n");
 	}
 
 	/***
 	 * Logs on to the server.
 	 * 
 	 * @param user username
 	 * @param pass password
 	 */
 	public void logon(String user, String pass) throws IOException {
 		socket.logon(user, pass);
 	}
 
 	/***
 	 * Connects to the GPS on the set serial port.
 	 */
 	public void openGPSPort() throws PortInUseException,
 			TooManyListenersException, UnsupportedCommOperationException,
 			IOException {
 		gps.open(getPort());
 		System.out.println("opening port");
 	}
 
 	/***
 	 * Register a listener for GPS device events.
 	 * 
 	 * @param listener event receiver to register
 	 */
 	public void addGPSListener(GPSListener listener) {
 		gps.addListener(listener);
 	}
 
 	/***
 	 * Remove listener from listener queue.
 	 * 
 	 * @param listener event receiver to remove
 	 */
 	public void removeGPSListener(GPSListener listener) {
 		gps.removeListener(listener);
 	}
 
 	/***
 	 * Register a listener for server events.
 	 * 
 	 * @param listener event receiver to register
 	 */
 	public void addSocketListener(GPSSocketListener listener) {
 		socket.addListener(listener);
 	}
 
 	/***
 	 * Remove listener from listener queue.
 	 * @param listener event receiver to remove
 	 */
 	public void removeSocketListener(GPSSocketListener listener) {
 		socket.removeListener(listener);
 	}
 
 	/***
 	 * Disconnects from socket.
 	 * @throws IOException 
 	 */
 	public void disconnectFromSocket() throws IOException {
 		socket.disconnect();
 	}
 
 	/***
 	 * Gets a list of the available COM ports.
 	 * 
 	 * @return a list of COM ports
 	 */
 	public List<String> getComPorts() {
 		return gps.getPorts();
 	}
 
 	/***
 	 * Get the COM-port
 	 * @return active COM-port
 	 */
 	public String getPort() {
 		return comPort;
 	}
 
 	/***
 	 * Sets a port to the active COM-port
 	 * @param port the port you want to set as active
 	 */
 	public void setPort(String port) {
 		System.out.println("port: " + port);
 		comPort = port;
 	}
 
 	/***
 	 * Set if you want compression or not.
 	 * 
 	 * @param compression true for compression, otherwise false
 	 */
 	public void setCompression(boolean compression) {
 		enableCompression = compression;
 	}
 
 	/***
 	 * Checks if the client should use compression to send the
 	 * buffered coordinates to the server
 	 * 
 	 * @return true if compression
 	 */
 	public boolean getCompression() {
 		return enableCompression;
 	}
 
 	/***
 	 * Set interval for recieving coordinates from the GPS-unit
 	 * @param inte the interval in s.
 	 */
 	public void setInterval(int inte) {
 		interval = inte;
 	}
 
 	/***
 	 * Gets the interval for recieving coordinates from the GPS-unit
 	 * @return the interval in s.
 	 */
 	public int getInterval() {
 		return interval;
 	}
 
 	/***
 	 * Checks if connected to socket.
 	 * 
 	 * @return true if connected
 	 */
 	public boolean isConnected() {
 		return socket.isConnected();
 	}
 
 	/***
 	 * Checks if logged in to server
 	 * @return true if logged in
 	 */
 	public boolean isLoggedIn() {
 		return socket.isLoggedIn();
 	}
 
 	/***
 	 * Gets the date/time the coordinate was recieved.
 	 * 
 	 * @return date and time of current coordinate
 	 */
 	public String getCoordDate() {
 		if (gpsCoord == null)
 			syncCoords();
 		return gpsCoord.getDateString();
 	}
 
 	public String getStringLat() {
 		return gpsCoord.getStringLat();
 	}
 
 	public String getStringLon() {
 		return gpsCoord.getStringLon();
 	}
 
 	/***
 	 * Gets the current coordinate from the GPS.
 	 *
 	 */
 	public void syncCoords() {
 		oldCoord = gpsCoord;
 		gpsCoord = gps.getCurrentCoordinate();
 	}
 
 	/***
 	 * Gets the current coordinate
 	 * 
 	 * @return the current coordinate
 	 */
 	public Coordinate getCurrentCoord() {
 		if (oldCoord != null)
 			return gpsCoord;
 		else
 			return null;
 	}
 
 	/***
 	 * Gets the old coordinate
 	 * 
 	 * @return the old coordinate
 	 */
 	public Coordinate getOldCoord() {
 		if (oldCoord != null)
 			return oldCoord;
 		else
 			return null;
 	}
 
 	/***
 	 * Saves the coordinates, based on connected to server or not.
 	 * @throws IOException 
 	 */
 	public void saveCoord() throws IOException {
 		if (oldCoord != null && gpsCoord.getDate().equals(oldCoord.getDate())) {
 			System.out.println("Dropping duplicate coord: " + gpsCoord);
 			return;
 		} else {
 			//oldCoord = gpsCoord;
 		}
 
 		if (socket.isLoggedIn() && transferToServer
 				&& activeRoute.getRouteId() != -1) {
 			// Send to server
 			socket.sendCoord(gpsCoord);
 			System.out.println("@@ Transferring");
 		} else {
 			// Buffer to file
 			storeTmpCoords(gpsCoord);
 			System.out.println("** Buffering ..");
 		}
 	}
 
 	/***
 	 * Changes the state of transferToServer, 
 	 * this decides if the coordinates should 
 	 * be buffered locally, og sent to server
 	 */
 	public void changeTransferState() {
 		transferToServer = !transferToServer;
 		System.out.println("Transfer To Server is set to " + transferToServer);
 	}
 
 	/***
 	 * Gets the state of transferToServer
 	 * 
 	 * @return true if transfer to server, else false
 	 */
 	public boolean getTransferState() {
 		return transferToServer;
 	}
 
 	/***
 	 * Creates a new route on server with the 
 	 * given description.
 	 * 
 	 * @param routeDesc the description of the route
 	 */
 	public void createRoute(String routeDesc) {
 		socket.makeRoute(routeDesc);
 	}
 
 	/***
 	 * Gets the routes for a given user
 	 * 
 	 * @param user get this users routes
 	 */
 	public void getRoutes(String user) {
 		socket.getRoutes(user);
 	}
 
 	/***
 	 * Gets the current username
 	 * 
 	 * @return current username
 	 */
 	public String getUsername() {
 		return socket.getUsername();
 	}
 
 	/***
 	 * Sets the given route as the active route on server
 	 * 
 	 * @param route the active route
 	 */
 	public void setRouteOnServer(Route route) {
 		socket.setRoute(route);
 	}
 
 	/***
 	 * Returns a route's id
 	 * 
 	 * @param route the route to get id from
 	 * @return the route's id
 	 */
 	public int getRouteId(Route route) {
 		return route.getRouteId();
 	}
 
 	/***
 	 * Returns a route's desciption
 	 * 
 	 * @param route the route to get description from
 	 * @return the route's description
 	 */
 	public String getRouteDesc(Route route) {
 		Route r = route;
 		return r.getDescription();
 	}
 
 	/***
 	 * Sets current route as active route locally.
 	 * Note that active route has to be set on the 
 	 * server too, except if a new route is created.
 	 * 
 	 * @param route route to set active
 	 */
 	public void setActiveRoute(Route route) {
 		System.out.println(route);
 		activeRoute = route;
 		System.out.println("Active route is now: "
 				+ activeRoute.getDescription());
 	}
 
 	/***
 	 * Returns the active route
 	 * 
 	 * @return the active route
 	 */
 	public Route getActiveRoute() {
 		return activeRoute;
 	}
 
 	/***
 	 * Checks if the GPS-unit has a fixed position from 
 	 * the satellites.
 	 * 
 	 * @return true if fixed position
 	 */
 	public boolean hasSignal() {
 		return gps.hasSignal();
 	}
 
 	/***
 	 * Checks wheter the buffer file exists or not. 
 	 * 
 	 * @return true if the file exists.
 	 */
 	public boolean bufferFileExists() {
 		return outputFile.exists();
 	}
 
 	/***
 	 * Changes the state of recieving from GPS-unit.
 	 * State is set to opposit of the current.
 	 * (i.e true if it was false)
 	 */
 	public void changeGPSState() {
 		recieveFromGPS = !recieveFromGPS;
 		System.out.println("Transfer To Server is set to " + transferToServer);
 	}
 
 	/***
 	 * Gets the state of recieving from GPS-unit
 	 * 
 	 * @return true if recieve
 	 */
 	public boolean getGPSState() {
 		return recieveFromGPS;
 	}
 
 	/***
 	 * Closes the GPS port
 	 */
 	public void closeGPSPort() {
 		gps.closePort();
 	}
 
 	/***
 	 * Gets the current coordinates
 	 * 
 	 * @return current coordinates recieved from GPS
 	 */
 	public boolean currCoordSet() {
 		return gps.currCoordSet();
 	}
 
 	/***
 	 * Starts recieving from the GPS-unit
 	 */
 	public void startRecieveFromGPS() {
 		gps.startRecieve();
 		System.out.println("* Starting recieve from GPS");
 	}
 
 	/***
 	 * Stops recieving from the GPS-unit
 	 * @throws IOException 
 	 * @throws UnsupportedCommOperationException 
 	 * @throws TooManyListenersException 
 	 * @throws PortInUseException 
 	 * @throws IllegalArgumentException 
 	 */
 	public void stopRecieveFromGPS() throws IllegalArgumentException, PortInUseException, TooManyListenersException, UnsupportedCommOperationException, IOException {
 		// XXX tried to add close/open port here
 		// to fix problem with disconnecting the port if 
 		// the plug is pulled out while the app runs 
 		// (Would not normally occour if you have an "normal"
 		// serial port (not an usb-> serial adapter as we use 
 		// for testing).
 		gps.closePort();
 		gps.open(getPort());
 		gps.stopRecieve();
 	}
 
 	/***
 	 * Checks if connected to the GPS-unit
 	 * 
 	 * @return true if connected
 	 */
 	public boolean isConnectedToGPS() {
 		return gps.isConnected();
 	}
 
 	/***
 	 * Checks if autotransfer is set
 	 * 
 	 * @return true if autotransfer
 	 */
 	public boolean getAutoTransferState() {
 		return autoTransfer;
 	}
 
 	/***
 	 * Sets the autotransfer variable
 	 * 
 	 * @param enable true if autotransfer, else false
 	 */
 	public void autoTransfer(boolean enable) {
 		autoTransfer = enable;
 	}
 
 	/***
 	 * Checks if active route is set locally.
 	 * 
 	 * @return true if active route exist
 	 */
 	public boolean hasActiveRoute() {
 		return (activeRoute.getRouteId() != -1);
 	}
 
 	public void setHost(String host) {
 		socket.setHost(host);
 	}
 
 	public void setPort(int port) {
 		socket.setPort(port);
 	}
 }