/* $Id: OSCByteArrayToJavaConverter.java,v 1.1.1.1 2006/11/13 14:47:22 modin Exp $

 * Created on 28.10.2003

 */

package com.illposed.osc.utility;

import java.math.BigInteger;

import java.util.Date;

import com.illposed.osc.*;

/**

 * @author cramakrishnan

 *

 * Copyright (C) 2003, C. Ramakrishnan / Auracle

 * All rights reserved.

 * 

 * See license.txt (or license.rtf) for license information.

 */

public class OSCByteArrayToJavaConverter {

	byte[] bytes;

	int bytesLength;

	int streamPosition;

	private byte[] intBytes   = new byte[4];

	private byte[] floatBytes = new byte[4];

	private	byte[] secondBytes = new byte[8];

	private	byte[] picosecBytes = new byte[8];

	/**

	 * Helper object for converting from a byte array to Java objects

	 */

	/*public OSCByteArrayToJavaConverter() {

		super();

	}*/

	public OSCPacket convert(byte[] byteArray, int bytesLength) {

		bytes = byteArray;

		this.bytesLength = bytesLength;

		streamPosition = 0;

		if (isBundle())

			return convertBundle();

		else

			return convertMessage();

	}

	private boolean isBundle() {

		// only need the first 7 to check if it is a bundle

		String bytesAsString = new String(bytes, 0, 7);

		return bytesAsString.startsWith("#bundle");

	}                               

	private OSCBundle convertBundle() {

		// skip the "#bundle " stuff

		streamPosition = 8;

		Date timestamp = readTimeTag();

		OSCBundle bundle = new OSCBundle(timestamp);

		OSCByteArrayToJavaConverter myConverter = new OSCByteArrayToJavaConverter();

		while (streamPosition < bytesLength) {

			// recursively read through the stream and convert packets you find

			int packetLength = ((Integer) readInteger()).intValue();

			byte[] packetBytes = new byte[packetLength];

			//streamPosition++;

			System.arraycopy(bytes,streamPosition,packetBytes,0,packetLength);

			streamPosition+=packetLength;

			//for (int i = 0; i < packetLength; i++)

			//	packetBytes[i] = bytes[streamPosition++];

			OSCPacket packet = myConverter.convert(packetBytes, packetLength);

			bundle.addPacket(packet);

		}

		return bundle;

	}

	private OSCMessage convertMessage() {

		OSCMessage message = new OSCMessage();

		message.setAddress(readString());

		char[] types = readTypes();

		if (null == types) {

			// we are done

			return message;

		}

		moveToFourByteBoundry();

		for (int i = 0; i < types.length; i++) {

			if ('[' == types[i]) {

				// we're looking at an array -- read it in

				message.addArgument(readArray(types, i));

				// then increment i to the end of the array

				while (']' != types[i])

					i++;

			} else

				message.addArgument(readArgument(types[i]));

		}

		return message;

	}

	private String readString() {

		int strLen = lengthOfCurrentString();

		char[] stringChars = new char[strLen];

		//System.arraycopy(bytes,streamPosition,stringChars,0,strLen);

		//streamPosition+=strLen;

		for (int i = 0; i < strLen; i++)

			stringChars[i] = (char) bytes[streamPosition++];

		moveToFourByteBoundry();

		return new String(stringChars);

	}

	/**

	 * @return a char array with the types of the arguments

	 */

	private char[] readTypes() {

		// the next byte should be a ","

		if (bytes[streamPosition] != 0x2C)

			return null;

		streamPosition++;

		// find out how long the list of types is

		int typesLen = lengthOfCurrentString();

		if (0 == typesLen) {

			return null;

		}

		// read in the types

		char[] typesChars = new char[typesLen];

		for (int i = 0; i < typesLen; i++) {

			typesChars[i] = (char) bytes[streamPosition++];

		}

		return typesChars;

	}

	/**

	 * @param c type of argument

	 * @return a Java representation of the argument

	 */

	private Object readArgument(char c) {

		switch (c) {

			case 'i' :

				return readInteger();

			case 'h' :

				return readBigInteger();

			case 'f' :

				return readFloat();

			case 'd' :

				return readDouble();

			case 's' :

				return readString();

			case 'c' :

				return readChar();

			case 'T' :

				return Boolean.TRUE;

			case 'F' :

				return Boolean.FALSE;

		}

		return null;

	}

	/**

	 * @return a Character

	 */

	private Object readChar() {

		return new Character((char) bytes[streamPosition++]);

	}

	/**

	 * @return a Double

	 */

	private Object readDouble() {

		return readFloat();

	}

	/**

	 * @return a Float

	 */

	private Object readFloat() {

		//byte[] floatBytes = new byte[4];

		floatBytes[0] = bytes[streamPosition++];

		floatBytes[1] = bytes[streamPosition++];

		floatBytes[2] = bytes[streamPosition++];

		floatBytes[3] = bytes[streamPosition++];

		int floatBits = 

			((floatBytes[3] & 0xFF) ) +

			((floatBytes[2] & 0xFF) << 8) +

			((floatBytes[1] & 0xFF) << 16) +

			((floatBytes[0] & 0xFF) << 24);

		return new Float(Float.intBitsToFloat(floatBits));

	}

	/**

	 * @return a BigInteger

	 */

	private Object readBigInteger() {

		//byte[] intBytes = new byte[4];

		intBytes[0] = bytes[streamPosition++];

		intBytes[1] = bytes[streamPosition++];

		intBytes[2] = bytes[streamPosition++];

		intBytes[3] = bytes[streamPosition++];

		int intBits = 

			((intBytes[3] & 0xFF) ) +

			((intBytes[2] & 0xFF) << 8) +

			((intBytes[1] & 0xFF) << 16) +

			((intBytes[0] & 0xFF) << 24);

		return new Integer(intBits);

	}

	/**

	 * @return an Integer

	 */

	private Object readInteger() {

		//byte[] intBytes = new byte[4];

		intBytes[0] = bytes[streamPosition++];

		intBytes[1] = bytes[streamPosition++];

		intBytes[2] = bytes[streamPosition++];

		intBytes[3] = bytes[streamPosition++];

		int intBits = 

			((intBytes[3] & 0xFF) ) +

			((intBytes[2] & 0xFF) << 8) +

			((intBytes[1] & 0xFF) << 16) +

			((intBytes[0] & 0xFF) << 24);

		return new Integer(intBits);

	}

	/**

	 * @return a Date

	 */

	private Date readTimeTag() {

		//byte[] secondBytes = new byte[8];

		//byte[] picosecBytes = new byte[8];

		/*for (int i = 4; i < 8; i++)

			secondBytes[i] = bytes[streamPosition++];

		for (int i = 4; i < 8; i++)

			picosecBytes[i] = bytes[streamPosition++];*/

		System.arraycopy(bytes,streamPosition,secondBytes,4,4);

		streamPosition+=4;

		System.arraycopy(bytes,streamPosition,picosecBytes,4,4);

		streamPosition+=4;

		BigInteger secsSince1900 = new BigInteger(secondBytes);

		long secsSince1970 =  secsSince1900.longValue() - OSCBundle.SECONDS_FROM_1900_to_1970.longValue();

		if (secsSince1970 < 0) secsSince1970 = 0; // no point maintaining times in the distant past

		BigInteger picosecs = new BigInteger(picosecBytes);

		long millisecs = (secsSince1970 * 1000) + (picosecs.longValue() / 1000);

		return new Date(millisecs);

	}

	/**

	 * @param types

	 * @param i

	 * @return an Array

	 */

	private Object[] readArray(char[] types, int i) {

		int arrayLen = 0;

		while (types[i + arrayLen] != ']')

			arrayLen++;

		Object[] array = new Object[arrayLen];

		for (int j = 0; i < arrayLen; j++) {

			array[j] = readArgument(types[i + j]);

		}

		return array;

	}

	private int lengthOfCurrentString() {

		int i = 0;

		while (bytes[streamPosition + i] != 0)

			i++;

		return i;

	}

	private void moveToFourByteBoundry() {

		// If i'm already at a 4 byte boundry, I need to move to the next one

		int mod = streamPosition % 4;

		streamPosition += (4 - mod);

	}

}