package altimeter;

import gnu.io.CommPortIdentifier;
import gnu.io.PortInUseException;
import gnu.io.SerialPort;
import gnu.io.UnsupportedCommOperationException;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.nio.charset.Charset;
import java.text.DateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Enumeration;
import java.util.TimeZone;

/**
 * Class to interface the PerfectFlite Alt15K/WD altimeter.
 * 
 * Also includes a main method that retrieves all flight profiles and saves them to files.
 * 
 * @author Sampo Niskanen <sampo.niskanen@iki.fi>
 */

public class Alt15K {
	public static final int TIMEOUT = 500;
	public static final int RWDELAY = 5;
	
	private static final boolean DEBUG = false;
	
	private static final Charset CHARSET = Charset.forName("ISO-8859-1");
	
	private final CommPortIdentifier portID;
	private SerialPort port = null;
	private InputStream is = null;
	private OutputStream os = null;
	
	

	@SuppressWarnings("unchecked")
	public static String[] getNames() {
		ArrayList<String> list = new ArrayList<String>();;
		
		Enumeration pids = CommPortIdentifier.getPortIdentifiers();

		while (pids.hasMoreElements()) {
		    CommPortIdentifier pid = (CommPortIdentifier) pids.nextElement();

		    if (pid.getPortType() == CommPortIdentifier.PORT_SERIAL)
		    	list.add(pid.getName());
		}
		return list.toArray(new String[0]);
	}

	

	@SuppressWarnings("unchecked")
	public Alt15K(String name) throws IOException {
		CommPortIdentifier pID = null;
		
		Enumeration portIdentifiers = CommPortIdentifier.getPortIdentifiers();
		while (portIdentifiers.hasMoreElements()) {
		    CommPortIdentifier pid = (CommPortIdentifier) portIdentifiers.nextElement();
		    
		    if(pid.getPortType() == CommPortIdentifier.PORT_SERIAL &&
		       pid.getName().equals(name)) {
		        pID = pid;
		        break;
		    }
		}
		
		if (pID==null) {
			throw new IOException("Port '"+name+"' not found.");
		}
		this.portID = pID;
	}
	

	/**
	 * Get altimeter flight data.  The flight profile is chosen by the parameter n,
	 * 0 = latest flight, 1 = second latest, etc.
	 * 
	 * @param n  Which flight profile to use (0=newest, 1=second newest, etc)
	 * @return   The altimeter flight data
	 * @throws IOException			in case of IOException
	 * @throws PortInUseException	in case of PortInUseException
	 */
	public AltData getData(int n) throws IOException, PortInUseException {
		AltData alt = new AltData();
		ArrayList<Integer> data = new ArrayList<Integer>();
		byte[] buf;
		byte[] buf2 = new byte[0];
		boolean identical = false;  // Whether identical lines have been read
		
		if (DEBUG)
			System.out.println("  Retrieving altimeter data n="+n);
		
		try {
			open();

			// Get version and position data
			byte[] ver = getVersionData();
			alt.setVersion(new byte[] { ver[0],ver[1] });

			// Calculate the position requested
			if (n > 2)
				n = 2;
			int position = ver[2] - n;
			while (position < 0)
				position += 3;

			if (DEBUG)
				System.out.println("  Requesting data from position "+position);
			
			// Request the data
			write("D");
			write((byte)position);
			write("PS");

			sleep();

			// Read preliminary data
			buf = read(4);
			int msl_level = combine(buf[0],buf[1]);
			int datacount = combine(buf[2],buf[3]);

			if (DEBUG)
				System.out.println("  Preliminary data msl="+msl_level+" count="+datacount);
			
			alt.setMslLevel(msl_level-6000);
			alt.setDataSamples(datacount);

			if (DEBUG)
				System.out.println("  Retrieving "+datacount+" samples");

			long t = System.currentTimeMillis();

			int count = 0;
			while (count < datacount) {
				sleep();
				write("G");
				sleep();
				buf = read(17);

				if (buf.length == 17) {
					// Checksum = sum of all bytes + 1
					// (signedness does not change the result)
					byte checksum = 1;
					for (int i=0; i<16; i++)
						checksum += buf[i];
					if (checksum != buf[16]) {
						printBytes("ERROR: Checksum fail on data (computed="+checksum+
								" orig="+buf[16]+")",buf);
						System.out.println("Ignoring error");
					}
				} else {
					System.err.println("ERROR:  Only "+buf.length+" bytes read, should be 17");
				}
				
				for (int i=0; i<buf.length-1; i+=2) {
					data.add(combine(buf[i],buf[i+1]));
					count++;
				}
				
				/*
				 * Check whether the data is identical to the previous data batch.  If reading
				 * too fast, the data seems to become duplicated in the transfer.  We need to check
				 * whether this has happened by attempting to read more data than is normally
				 * available.
				 */
				int c, l=Math.min(buf.length, buf2.length);
				for (c=0; c<l; c++) {
					if (buf[c] != buf2[c])
						break;
				}
				if (c==l && buf.length == buf2.length)
					identical = true;
				buf2 = buf.clone();
			}

			if (DEBUG)
				System.out.println("  Retrieved "+data.size()+" samples in "+
						(System.currentTimeMillis()-t)+" ms");


			// In case of identical lines, check for more data.  This would mean that the
			// transfer was corrupted.
			if (identical) {
				System.err.println("WARNING:  Duplicate data detected, possible error");
			}

			// Test for more data
			if (DEBUG)
				System.out.println("  Testing for more data");
			sleep();
			write("G");
			sleep();
			buf = read(17);
			if (buf.length > 0) {
				System.err.println("ERROR: Data available after transfer! (length="+buf.length+")");
			}

			
			
			
			
			
			// Create an int[] array and set it
			int[] d = new int[data.size()];
			for (int i=0; i<d.length; i++)
				d[i] = data.get(i);
			alt.setData(d);
			
		//  Catch all exceptions, close the port and re-throw the exception
		} catch (PortInUseException e) {
			close();
			throw e;
		} catch (IOException e) {
			close();
			throw e;
		} catch (UnsupportedCommOperationException e) {
			close();
			throw new RuntimeException("Required function of RxTx library not supported",e);
		} catch (RuntimeException e) {
			// Catch-all for all other types of exceptions
			close();
			throw e;
		}

		close();
		return alt;
	}
	

	
	
	private byte[] getVersionData() throws PortInUseException, IOException, 
										   UnsupportedCommOperationException {
		byte[] ver = new byte[3];
		byte[] buf;

		if (DEBUG)
			System.out.println("  Retrieving altimeter version information");
		
		// Signal to altimeter we are here
		write((byte)0);
		sleep(15);  // Sleep for 15ms, data is incoming at 10 samples/sec
		
		// Get altimeter version, skip zeros
		write("PV");
		sleep();
		buf = readSkipZero(2);
		sleep();
		if (buf.length != 2) {
			close();
			throw new IOException("Communication with altimeter failed.");
		}
		ver[0] = buf[0];
		ver[1] = buf[1];
		
		// Get position of newest data
		write("M");
		sleep();
		buf = read(1);
		if (buf.length != 1) {
			close();
			throw new IOException("Communication with altimeter failed.");
		}
		ver[2] = buf[0];

		if (DEBUG)
			System.out.println("  Received version info "+ver[0]+"."+ver[1]+", position "+ver[2]);
		
		return ver;
	}
	
	
	/**
	 * Delay the communication by a small delay (RWDELAY ms).
	 */
	private void sleep() {
		sleep(RWDELAY);
	}
	
	/**
	 * Sleep for the given amount of milliseconds.
	 */
	private void sleep(int n) {
		try {
			Thread.sleep(n);
		} catch (InterruptedException ignore) { }
	}
	
	
	private void open() 
	throws PortInUseException, IOException, UnsupportedCommOperationException {
		if (port != null) {
			System.err.println("ERROR: open() called with port="+port);
			Thread.dumpStack();
			close();
		}
		
		if (DEBUG) {
			System.out.println("  Opening port...");
		}

		port = (SerialPort)portID.open("OpenRocket",1000);
		
		port.setSerialPortParams(9600, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, 
				SerialPort.PARITY_NONE);

		port.setInputBufferSize(1);
		port.setOutputBufferSize(1);

		port.enableReceiveTimeout(TIMEOUT);

		is = port.getInputStream();
		os = port.getOutputStream();
	}
	
	
	private byte[] readSkipZero(int n) throws IOException, UnsupportedCommOperationException {
		long t = System.currentTimeMillis() + TIMEOUT*2;
		
		if (DEBUG) {
			System.out.println("    readSkipZero "+n+" bytes");
		}
		
		while (System.currentTimeMillis() < t) {
			byte[] buf = read(n);
			if (DEBUG)
				printBytes("      Received",buf);
			
			if (buf.length == 0)  // No data available
				return buf;
			
			// Skip zeros
			int i;
			for (i=0; i<buf.length; i++)
				if (buf[i] != 0)
					break;
			
			if (i==0)   // No zeros to skip
				return buf;
			
			if (i < buf.length) {
				// Partially read
				int count = buf.length-i;  // No. of data bytes
				byte[] array = new byte[n];
				System.arraycopy(buf, i, array, 0, count);
				buf = read(n-count);
				if (DEBUG)
					printBytes("      Received (partial)",buf);
				System.arraycopy(buf, 0, array, count, buf.length);
				
				if (DEBUG)
					printBytes("    Returning",array);
				return array;
			}
		}
		
		if (DEBUG)
			System.out.println("  No data read, returning empty");
		return new byte[0];  // no data, only zeros
	}
	

	private byte[] read(int n) throws IOException, UnsupportedCommOperationException {
		byte[] bytes = new byte[n];
		
		port.enableReceiveThreshold(n);
		
		long t = System.currentTimeMillis() + TIMEOUT;
		int count = 0;

		if (DEBUG)
			System.out.println("    Reading "+n+" bytes");

		while (count < n && System.currentTimeMillis() < t) {
			byte[] buf = new byte[n-count];
			int c = is.read(buf);
			System.arraycopy(buf, 0, bytes, count, c);
			count += c;
		}
		
		byte[] array = new byte[count];
		System.arraycopy(bytes, 0, array, 0, count);
		
		if (DEBUG)
			printBytes("    Returning",array);
		
		return array;
	}
	
	private void write(String s) throws IOException {
		write(s.getBytes(CHARSET));
	}
	
	private void write(byte ... bytes) throws IOException {
		if (DEBUG)
			printBytes("    Writing",bytes);
		os.write(bytes);
	}
	
	private void close() {
		if (DEBUG)
			System.out.println("  Closing port");
		
		SerialPort p = port;
		port = null;
		is = null;
		os = null;
		if (p != null)
			p.close();
	}
	
	
	

	
	public static void main(String[] arg) {
		
		if (arg.length != 1) {
			System.err.println("Usage:  java Alt15K <basename>");
			System.err.println("Files will be saved <basename>-old.log, -med and -new");
			return;
		}
		
		
		String device = null;
		String[] devices = Alt15K.getNames();
		for (int i=0; i<devices.length; i++) {
			if (devices[i].matches(".*USB.*")) {
				device = devices[i];
				break;
			}
		}
		if (device == null) {
			System.out.println("Device not found.");
			return;
		}
		
		
		System.out.println("Selected device "+device);
		
		AltData alt = null;
		String file;
		try {
			Alt15K p = new Alt15K(device);

			System.out.println("Retrieving newest data...");
			alt = p.getData(0);
			System.out.println("Apogee at "+alt.getApogee()+" feet");

			file = arg[0]+"-new.log";
			System.out.println("Saving data to "+file+"...");
			savefile(file,alt);
			
			
			System.out.println("Retrieving medium data...");
			alt = p.getData(1);
			System.out.println("Apogee at "+alt.getApogee()+" feet");

			file = arg[0]+"-med.log";
			System.out.println("Saving data to "+file+"...");
			savefile(file,alt);
			
			
			System.out.println("Retrieving oldest data...");
			alt = p.getData(2);
			System.out.println("Apogee at "+alt.getApogee()+" feet");

			file = arg[0]+"-old.log";
			System.out.println("Saving data to "+file+"...");
			savefile(file,alt);
			
		} catch (IOException e) {
			e.printStackTrace();
		} catch (PortInUseException e) {
			e.printStackTrace();
		}

//		System.out.println(alt);
//		alt.printData();
		
	}
	
	
	static private void savefile(String file, AltData data) throws FileNotFoundException {
		
		PrintStream output = new PrintStream(file);
		
		// WTF is this so difficult?!?
		DateFormat fmt = DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM);
		TimeZone tz=TimeZone.getTimeZone("GMT+3");
		fmt.setTimeZone(tz);

		output.println("# Alt15K data, file "+file);
		output.println("# Data retrieved at: "+fmt.format(new Date()));
		output.println("# Values are in feet above launch level");
		output.println("# ");
		output.println("# Apogee = "+data.getApogee());
		output.println("# MSL level = "+data.getMslLevel());
		output.println("# Data count = "+data.getDataSamples());
		
		byte[] b = data.getVersion();
		String s="";
		for (int i=0; i<b.length; i++) {
			if (s.equals(""))
				s = ""+((int)b[i]);
			else 
				s = s+"."+((int)b[i]);
		}
		output.println("# Altimeter version = " + s);
		
		int[] values = data.getData();
		for (int i=0; i < values.length; i++) {
			output.println(""+values[i]);
		}
		
		output.close();
	}
	
	
	static private void printBytes(String str, byte[] b) {
		printBytes(str, b,b.length);
	}
	
	static private void printBytes(String str, byte[] b, int n) {
		String s;
		s = str+" "+n+" bytes:";
		for (int i=0; i<n; i++) {
			s += " "+unsign(b[i]);
		}
		System.out.println(s);
	}
	
	static private int unsign(byte b) {
		if (b >= 0)
			return b;
		else
			return 256 + b;
	}
	
	@SuppressWarnings("unused")
	static private int combine(int a, int b) {
		return 256*a + b;
	}
	
	static private int combine(byte a, byte b) {
		int val = 256*unsign(a)+unsign(b);
		if (val <= 32767)
			return val;
		else
			return val-65536;
			
	}
	
}