/*
    * 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 gnu.io.SerialPortEvent.*;
  import static gnu.io.SerialPort.*;
  import static gnu.io.CommPortIdentifier.*;
  import static triptracker.client.gps.core.GPSStatusState.*;
  
  import java.io.BufferedReader;
  import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.io.PrintWriter;
  import java.util.ArrayList;
  import java.util.Date;
  import java.util.Enumeration;
  import java.util.List;
  import java.util.Set;
  import java.util.TooManyListenersException;
  import java.util.concurrent.CopyOnWriteArraySet;
  import gnu.io.CommPortIdentifier;
  import gnu.io.PortInUseException;
  import gnu.io.SerialPort;
  import gnu.io.SerialPortEvent;
  import gnu.io.SerialPortEventListener;
  import gnu.io.UnsupportedCommOperationException;
  
  import triptracker.core.Coordinate;
  import triptracker.core.Utils;
  
  public class GPSConnection {
  	/*** Listener set for Model View Controller (MVC) separation. */
  	protected Set<GPSListener> listeners = new CopyOnWriteArraySet<GPSListener>();
  
  	private BufferedReader inputStream;
  
  	private SerialPort sPort;
  
  	private boolean closePort = false;
  
  	private boolean isConnected = false;
  
  	private boolean recieve = false;
  
  	private boolean validSignal = false;
  
  	private CommPortIdentifier portId;
  
  	PrintWriter outW;
  
  	private static final String WANTED_SENTENCE = "GPRMC";
  
  	private String portOwner = null;
  
  	public static final int BAUDRATE = 4800;
  
  	public static final int TIMEOUT = 2000;
  
  	private NMEASentence nmea = new NMEASentence();
  
  	private Coordinate currentCoordinate = null;// = new Coordinate(0,0, null);
  
  	/***
  	 * Connects to the GPS-unit at the given port
  	 * 
  	 * @param port Port to connect
  	 */
  	public void open(String port) throws PortInUseException,
  			TooManyListenersException, UnsupportedCommOperationException,
  			IOException, IllegalArgumentException {
  
  		openFile();
  		if (!isConnected()) {
  			Enumeration portList = getPortIdentifiers();
  
  			if (!portList.hasMoreElements()) {
  				System.out.println("No ports"); // XXX writing to console, test
  			}
  
  			while (portList.hasMoreElements()) {
 				portId = (CommPortIdentifier) portList.nextElement();
 
 				if (portId.getPortType() == PORT_SERIAL && portId.getName().equals(port)) {
 					// Port found. Open it and setup port parameters.
 					sPort = (SerialPort) portId.open("TripTracker", TIMEOUT);
 					portOwner = portId.getCurrentOwner();
 
 					isConnected = true;
 					statusUpdate(CONNECTED);
 
 					sPort.notifyOnDataAvailable(true);
 					
 					// XXX Added for debug testing.
 					sPort.notifyOnBreakInterrupt(true);
 					sPort.notifyOnCarrierDetect(true);
 					sPort.notifyOnCTS(true);
 //					sPort.notifyOnDataAvailable();
 					sPort.notifyOnDSR(true);
 					sPort.notifyOnFramingError(true);
 					sPort.notifyOnOutputEmpty(true);
 					sPort.notifyOnOverrunError(true);
 					sPort.notifyOnParityError(true);
 					sPort.notifyOnRingIndicator(true);
 
 					sPort.setSerialPortParams(BAUDRATE, DATABITS_8, STOPBITS_1,
 							PARITY_NONE);
 
 					inputStream = new BufferedReader(new InputStreamReader(sPort
 							.getInputStream()));
 
 					sPort.addEventListener(new DataListener());
 
 					return;
 				}
 
 			}
 		}
 	}
 
 	/***
 	 * Recieve data from GPS-unit
 	 * @throws IOException 
 	 */
 	private void readGPSData() {
 		String dataFromGPS = null;
 		if (!recieve) {
 			return;
 		}
 
 		while (true) { // XXX Why loop infinitely.
 			// Reads line for line from the GPS-unit
 			try {
 				dataFromGPS = inputStream.readLine();
 			} catch (IOException e) {
 				readExcepion(e);
 				return;
 			}
 
 			// Filters out other NMEA-sentences than then wanted
 			if ((dataFromGPS.contains("$" + WANTED_SENTENCE))) {
 				// Save Raw nmea to file
 				outW.println(dataFromGPS);
 				outW.flush();
 				
 				nmea.parseSentence(dataFromGPS);
 				
 				// Checks if the GPS is able to get a fixed position
 				if (hasSignal()) {
 					generateCoordinate();
 					if (!validSignal) {
 						validSignal = true;
 						statusUpdate(HASFIXEDPOS);
 					}
 				} else if (validSignal) {
 					validSignal = false;
 					statusUpdate(HASFIXEDPOS);
 				} else {
 					statusUpdate(NOFIXEDPOS);
 					System.out.println("no fixed pos");
 				}
 
 			}
 
 			// Closing the port
 			if (closePort) {
 				statusUpdate(NOTCONNECTED);
 				sPort.close();
 			}
 		}
 	}
 
 	/***
 	 * Generates a coordinate from the NMEA class
 	 * 
 	 */
 	private void generateCoordinate() {
 		// TODO Finish method, move this out from GPSConnection?
 
 		double lat = 0, lon = 0;
 
 		try {
 			lat = Double.parseDouble(nmea.getField(3));
 			lon = Double.parseDouble(nmea.getField(5));
 		} catch (NumberFormatException e) {
 			return;
 		}
 
 		if (nmea.getField(4).contains("S")) {
 			lat = -lat;
 		}
 		if (nmea.getField(6).contains("W")) {
 			lon = -lon;
 		}
 
 		Date date = Utils.parseDate(nmea.getField(9) + nmea.getField(1),
 				"ddMMyyHHmmss");
 
 		if (date == null) {
 			throw new NullPointerException("date could not be parsed: "
 					+ nmea.getField(9) + nmea.getField(1));
 		}
 
 		// Converts to decimal format
 		lat = Coordinate.nmeaToDec(lat);
 		lon = Coordinate.nmeaToDec(lon);
 
 		currentCoordinate = new Coordinate(lat, lon, date);
 		//		System.out.println("Generated coord: " + currentCoordinate.toString());
 	}
 
 	public Coordinate getCurrentCoordinate() {
 		return currentCoordinate;
 	}
 
 	/***
 	 * Checks wheter the GPS has connection to the satellites
 	 * 
 	 * @return true if fixed position has been obtained, false if no fixed
 	 * position is available
 	 */
 	public boolean hasSignal() {
 		// if the time is specified, the gps-unit has enough data
 		// to get a fixed possition?
 		if (nmea.getField(1).length() == 6) {
 			return true;
 		} else {
 			return false;
 		}
 	}
 
 	/***
 	 * Returns a list of available serial ports.
 	 * 
 	 * @return list of available serial ports
 	 */
 	public List<String> getPorts() {
 		List<String> ports = new ArrayList<String>();
 		Enumeration portList = getPortIdentifiers();
 
 		while (portList.hasMoreElements()) {
 			portId = (CommPortIdentifier) portList.nextElement();
 
 			if (portId.getPortType() == PORT_SERIAL) {
 				ports.add(portId.getName());
 			}
 		}
 
 		if (ports.isEmpty()) {
 			ports.add("NONE, PLEASE RESTART");
 		}
 		return ports;
 	}
 
 	/***
 	 * Checks if connected to the COM port
 	 * 
 	 * @return true if connected to the com port, else false
 	 */
 	public boolean isConnected() {
 		return isConnected;
 	}
 
 	/***
 	 * Reports a broken listener, removes it from the listener queue and logs
 	 * the error.
 	 * 
 	 * @param listener broken listener
 	 * @param exception exception thrown by listener
 	 */
 	protected void brokenListener(GPSListener listener,
 			RuntimeException exception) {
 		System.err.println("Unexpected exception in listener");
 		exception.printStackTrace(); // XXX Temp error logging. Add log to file?
 
 		// Remove listener from queue.
 		listeners.remove(listener);
 	}
 
 	/***
 	 * Publish a connected event. 
 	 * 
 	 * @param connected true if connected, false if disconnected
 	 */
 	protected void connectedEvent(boolean connected) {
 		for (GPSListener listener : listeners) {
 			try {
 				listener.connected(connected);
 			} catch (RuntimeException e) {
 				brokenListener(listener, e);
 			}
 		}
 	}
 
 	/***
 	 * Register a listener for server events.
 	 * 
 	 * @param listener event receiver to register
 	 */
 	public void addListener(GPSListener listener) {
 		listeners.add(listener);
 	}
 
 	/***
 	 * Remove listener from listener queue.
 	 * 
 	 * @param listener event receiver to remove
 	 */
 	public void removeListener(GPSListener listener) {
 		listeners.remove(listener);
 	}
 
 	private class DataListener implements SerialPortEventListener {
 		/***
 		 * Handle serial port events
 		 */
 		public void serialEvent(SerialPortEvent event) {
 			switch (event.getEventType()) {
 			case BI:
 				System.out.println("serialEvent: BI " + event.toString());
 				break;
 			case CD:
 				System.out.println("serialEvent: CD " + event.toString());
 				break;
 			case CTS:
 				System.out.println("serialEvent: CTS " + event.toString());
 				break;
 			case DATA_AVAILABLE: // The GPS-unit is transmitting data
 				readGPSData();
 				break;
 			case DSR:
 				System.out.println("serialEvent: DSR " + event.toString());
 				break;
 			case FE:
 				System.out.println("serialEvent: FE " + event.toString());
 				break;
 			case OE:
 				System.out.println("serialEvent: OE " + event.toString());
 				break;
 			case OUTPUT_BUFFER_EMPTY:
 				System.out.println("serialEvent: OUTPUT_BUFFER_EMPTY " + event.toString());
 				break;
 			case PE:
 				System.out.println("serialEvent: PE " + event.toString());
 				break;
 			case RI:
 				System.out.println("serialEvent: RI " + event.toString());
 				break;
 			}
 		}
 	}
 
 	private void statusUpdate(GPSStatusState state) {
 		for (GPSListener listener : listeners) {
 			try {
 				listener.statusUpdate(state);
 			} catch (RuntimeException e) {
 				brokenListener(listener, e);
 			}
 		}
 	}
 
 	/***
 	 * Closes the current COM port
 	 *
 	 */
 	public void closePort() {
 		if (sPort == null) {
 			return;
 		}
 
 		statusUpdate(NOTCONNECTED);
 		System.out.println("CLOOS");
 		sPort.close();
 	}
 
 	/***
 	 * 
 	 * @return the ports owner
 	 */
 	public String getPortOwner() {
 		if (portOwner == null) {
 			portOwner = "Noone";
 		}
 		return portOwner;
 	}
 
 	public boolean currCoordSet() {
 		if (currentCoordinate == null) {
 			return false;
 		} else {
 			return true;
 		}
 	}
 
 	/***
 	 * Start recieve from the GPS-unit
 	 *
 	 */
 	public void startRecieve() {
 		System.out.println("recieve set to true");
 		recieve = true;
 	}
 
 	/***
 	 * Stop/pause recieve from the GPS-unit
 	 *
 	 */
 	public void stopRecieve() {
 		System.out.println("recieve set to false");
 		recieve = false;
 	}
 
 	/***
 	 * Checks if the signal is valid
 	 * 
 	 * @return true if valid signal
 	 */
 	public boolean isValidSignal() {
 		return validSignal;
 	}
 
 	/***
 	 * Opens the given file
 	 * 
 	 * @throws FileNotFoundException 
 	 */
 	public void openFile() throws FileNotFoundException {
 		outW = new PrintWriter(new FileOutputStream("nmeaout.txt"));
 	}
 
 	/***
 	 * Read exception has occured.
 	 */
 	protected void readExcepion(IOException ioe) {
 		for (GPSListener listener : listeners) {
 			try {
 				listener.readExcepion(ioe);
 			} catch (RuntimeException e) {
 				brokenListener(listener, e);
 			}
 		}
 
 	}
 }