package usbcomm1;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.DoubleBuffer;
import java.nio.IntBuffer;
import java.util.List;

import javax.usb.UsbClaimException;
import javax.usb.UsbConfiguration;
import javax.usb.UsbConst;
import javax.usb.UsbControlIrp;
import javax.usb.UsbDevice;
import javax.usb.UsbDeviceDescriptor;
import javax.usb.UsbDisconnectedException;
import javax.usb.UsbEndpoint;
import javax.usb.UsbException;
import javax.usb.UsbHostManager;
import javax.usb.UsbHub;
import javax.usb.UsbInterface;
import javax.usb.UsbInterfacePolicy;
import javax.usb.UsbIrp;
import javax.usb.UsbNotActiveException;
import javax.usb.UsbNotClaimedException;
import javax.usb.UsbPipe;

import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.LineNumberReader;

public class UsbComm {

	/**
	 * @param args
	 * @throws UsbDisconnectedException
	 * @throws IllegalArgumentException
	 * @throws UsbException
	 * @throws SecurityException
	 */

	// variable declaration
	public static UsbDevice myDevice;
	public UsbControlIrp irp;
	final short vendor = 0x1cbe;
	final short product = 0x0003;
	public double sent, numBodies, mode, weeks, days;
	public FileReader fr;
	public double Mass, Px, Py, Vx, Vy;
	public double sendarr[] = new double[5];
	public byte[] senddata = new byte[40];
	public byte[] sendinit = new byte[24];
	byte[] body_params = new byte[40];
	public double[] send_Init = new double[3];
	public byte[] init_params = new byte[24];
	public byte[] recvData = new byte[40];
	public FileWriter fw;
	public BufferedWriter bw;
	public double[] recvval;
	int count = 0;

	// constructor to initialize my device and create controlIrp
	public UsbComm() throws IllegalArgumentException, UsbDisconnectedException,
			UsbException {

		myDevice = findDevice(UsbHostManager.getUsbServices().getRootUsbHub(),
				vendor, product);
		//System.out.println(myDevice);

		irp = myDevice
				.createUsbControlIrp(
						(byte) (UsbConst.REQUESTTYPE_DIRECTION_IN
								| UsbConst.REQUESTTYPE_TYPE_STANDARD | UsbConst.REQUESTTYPE_RECIPIENT_DEVICE),
						UsbConst.REQUEST_GET_CONFIGURATION, (short) 0,
						(short) 0);

		irp.setData(new byte[1]);
		myDevice.syncSubmit(irp);
	}

	// method to send initial values to the controller
	public void sendInitialParams() throws UsbNotActiveException,
			UsbNotClaimedException, UsbDisconnectedException, UsbException,
			IOException {
		UsbConfiguration configuration = myDevice.getActiveUsbConfiguration();
		//System.out.println(configuration);
		UsbInterface iface = configuration.getUsbInterface((byte) 0);
		//System.out.println(iface);
		iface.claim();

		try {
			UsbEndpoint endpoint = iface.getUsbEndpoint((byte) 1);
			UsbPipe pipe = endpoint.getUsbPipe();
			pipe.open();
			try {
				fr = new FileReader("F:/eclipseworkspace/GUI/src/init.txt");
				LineNumberReader lnr = new LineNumberReader(fr);
				String str = lnr.readLine();
				mode = Double.parseDouble(str);
				str = lnr.readLine();
				numBodies = Double.parseDouble(str);
				str = lnr.readLine();
				weeks = Double.parseDouble(str);
				str = lnr.readLine();
				days = Double.parseDouble(str);
				send_Init[0] = mode;
				send_Init[1] = numBodies;
				double iteration = ((weeks * 7) + days);
				send_Init[2] = iteration;
				// send_Init[3] = days;
				init_params = DoubleArray2ByteArray(send_Init);
				ByteBuffer.wrap(sendinit).order(ByteOrder.LITTLE_ENDIAN)
						.put(init_params);
				sent = pipe.syncSubmit(sendinit);
				//System.out.println("sent initial params");
				String line = lnr.readLine();
				try {
					while (line.isEmpty()) {
						int num = lnr.getLineNumber();
						lnr.setLineNumber(num);
						String string = lnr.readLine();
						if ((!string.isEmpty())) {
							Mass = Double.parseDouble(string);
							string = lnr.readLine();
							Px = Double.parseDouble(string);
							string = lnr.readLine();
							Py = Double.parseDouble(string);
							string = lnr.readLine();
							Vx = Double.parseDouble(string);
							string = lnr.readLine();
							Vy = Double.parseDouble(string);
							line = lnr.readLine();
							sendarr[0] = Mass;
							sendarr[1] = Px;
							sendarr[2] = Py;
							sendarr[3] = Vx;
							sendarr[4] = Vy;
							body_params = DoubleArray2ByteArray(sendarr);
							ByteBuffer.wrap(senddata)
									.order(ByteOrder.LITTLE_ENDIAN)
									.put(body_params);
							sent = pipe.syncSubmit(senddata);
							//System.out.println("Sent Mass values");
						} else {
							System.out.println("EOF");
						}
					}
				} catch (Exception e) {
					//System.out.println("end");
				}
				fr.close();
			} finally {
				pipe.close();
			}
		} finally {
			iface.release();
		}
		//return send_Init;
	}

	// method to convert double array to byte array
	public static byte[] DoubleArray2ByteArray(double[] values) {
		ByteBuffer buffer = ByteBuffer.allocate(8 * values.length);
		for (double value : values) {
			buffer.order(ByteOrder.LITTLE_ENDIAN).putDouble(value);
		}
		return buffer.array();
	}

	// method to convert int array to byte array
	public static byte[] IntArray2ByteArray(int[] values) {
		ByteBuffer buffer = ByteBuffer.allocate(4 * values.length);
		for (int value : values) {
			buffer.putInt(value);
		}
		return buffer.array();

	}

	// method to receive data from the controller

	public double[] receiveValFromCont() throws UsbClaimException,
			UsbNotActiveException, UsbDisconnectedException, UsbException,
			IOException {
		double[] returnval = new double[3];
		UsbConfiguration configuration = myDevice.getActiveUsbConfiguration();
		//System.out.println(configuration);
		UsbInterface iface = configuration.getUsbInterface((byte) 0);
		//System.out.println(iface);
		iface.claim();
		try {

			UsbEndpoint endpoint = iface.getUsbEndpoint((byte) 0x81);
			UsbPipe pipe = endpoint.getUsbPipe();
			pipe.open();
			try {
				
				int received = pipe.syncSubmit(recvData);
				DoubleBuffer recv;
				// for(int m = 0; m<numBodies; m++){
				// recv =
				// ByteBuffer.wrap(recvData).order(ByteOrder.LITTLE_ENDIAN).get(body_final).asDoubleBuffer();
				// double recve =
				// ByteBuffer.wrap(recvData).order(ByteOrder.LITTLE_ENDIAN).getDouble();
				// double[] copy = new double[recv.remaining()];
				ByteBuffer buf2 = ByteBuffer.wrap(recvData).order(
						ByteOrder.LITTLE_ENDIAN);
				recvval = new double[recvData.length / 8];
				//System.out.println("receive val" + recvval.length);
				for (int i = 0; i < recvval.length; i++) {
					recvval[i] = buf2.getDouble(i * 8);
					//System.out.println(recvval[i]);
					if(count==0 && i==0){
						//System.out.println(recvval[i]);
					}
					count++;
					if(count==numBodies){
						count = 0;
					}
					// }
					if(mode==0){
						//System.out.println("entered");
						fw = new FileWriter(
								"F:/eclipseworkspace/GUI/src/final.txt", true);
						bw = new BufferedWriter(fw);
						for (int k = 0; k < recvval.length; k++) {
							//System.out.println(recvval[k]);
							String str = String.valueOf(recvval[k]);
							//bw.write(k);
							bw.write(str);
							bw.newLine();
						}
						bw.newLine();
					}
					else{
						
						fw = new FileWriter(
								"F:/eclipseworkspace/GUI/src/viz.txt", true);
						bw = new BufferedWriter(fw);
						//int index = (int)recvval[0];
						returnval[0] = recvval[0];
						returnval[1] = recvval[2];
						returnval[2] = recvval[3];
						
						for (int k = 0; k < recvval.length; k++) {
							String str = String.valueOf(recvval[k]);
							//bw.write(k);
							bw.write(str);
							bw.newLine();
						}
						bw.newLine();
					}
					

				}

				//System.out.println(received + " bytes received");
			} finally {
				pipe.close();
				bw.close();
				fw.close();
			}
		} finally {
			iface.release();
		}
		if((returnval[0] > numBodies) && (returnval[0] < 0)){
			return null;
		}
		else
		return returnval;
	}

	// method to find my device
	public static UsbDevice findDevice(UsbHub hub, short vendorId,
			short productId) {
		for (UsbDevice device : (List<UsbDevice>) hub.getAttachedUsbDevices()) {
			UsbDeviceDescriptor desc = device.getUsbDeviceDescriptor();
			if (desc.idVendor() == vendorId && desc.idProduct() == productId)
				return device;
			if (device.isUsbHub()) {
				device = findDevice((UsbHub) device, vendorId, productId);
				if (device != null)
					return device;
			}
		}
		return null;
	}

}