/**

 * @author cramakrishnan

 *

 * Copyright (C) 2003, C. Ramakrishnan / Illposed Software

 * All rights reserved.

 * 

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

 * 

 * 

 * OSCJavaToByteArrayConverter is a helper class that translates

 * from Java types to the format the OSC spec specifies for those

 * types.

 *

 * This implementation is based on Markus Gaelli and

 * Iannis Zannos' OSC implementation in Squeak:

 * http://www.emergent.de/Goodies/

 */

package com.illposed.osc.utility;

import java.io.IOException;

import java.io.ByteArrayOutputStream;

import java.math.BigInteger;

import java.util.Enumeration;

import java.util.Vector;

public class OSCJavaToByteArrayConverter {

    protected ByteArrayOutputStream stream = new ByteArrayOutputStream();

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

    /*public OSCJavaToByteArrayConverter() {

        super();

    }*/

    /**

     * Creation date: (2/23/2001 2:43:25 AM)

     * @param anArray java.lang.Object[]

     *

     */

    public void appendNullCharToAlignStream() {

        int mod = stream.size() % 4;

        int pad = 4 - mod;

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

            stream.write(0);

    }

    /**

     * Creation date: (2/23/2001 2:21:53 AM)

     * @return byte[]

     */

    public byte[] toByteArray() {

        return stream.toByteArray();

    }

    /**

     * Creation date: (2/23/2001 2:14:23 AM)

     * @param bytes byte[]

     */

    public void write(byte[] bytes) {

        writeBigEndToFourByteBoundry(bytes);

    }

    /**

     * Creation date: (2/23/2001 2:21:04 AM)

     * @param i int

     */

    public void write(int i) {

        writeIntegerToByteArray(i);

    }

    /**

     * Creation date: (2/23/2001 2:03:57 AM)

     * @param f java.lang.Float

     */

    public void write(Float f) {

        writeIntegerToByteArray(Float.floatToIntBits(f.floatValue()));

    }

    /**

     * Creation date: (2/23/2001 2:08:36 AM)

     * @param i java.lang.Integer

     */

    public void write(Integer i) {

        writeIntegerToByteArray(i.intValue());

    }

    /**

     * Creation date: (2/23/2001 1:57:35 AM)

     * @param str java.lang.String

     */

    public void write(String str) {

        writeLittleEndToFourByteBoundry(str.getBytes());

    }

    /**

     * Creation date: (2/23/2001 2:08:36 AM)

     * @param c char

     */

    public void write(char c) {

        stream.write(c);

    }

    /**

     * Creation date: (2/23/2001 2:02:54 AM)

     * @param anObject java.lang.Object

     */

    public void write(Object anObject) {

        // Can't do switch on class

        if (null == anObject)

            return;

        if (anObject instanceof Float) {

            write((Float) anObject);

            return;

        }

        if (anObject instanceof String) {

            write((String) anObject);

            return;

        }

        if (anObject instanceof Integer) {

            write((Integer) anObject);

            return;

        }

    }

    /**

     * Creation date: (2/23/2001 2:43:25 AM)

     * @param aClass Class

     */

    public void writeType(Class c) {

        // A big ol' case statement -- what's polymorphism mean, again?

        // I really wish I could extend the base classes!

        // use the appropriate flags to tell SuperCollider what kind of 

        // thing it is looking at

        if (Integer.class.equals(c)) {

            stream.write('i');

            return;

        }

        if (java.math.BigInteger.class.equals(c)) {

            stream.write('h');

            return;

        }

        if (Float.class.equals(c)) {

            stream.write('f');

            return;

        }

        if (Double.class.equals(c)) {

            stream.write('d');

            return;

        }

        if (String.class.equals(c)) {

            stream.write('s');

            return;

        }

        if (Character.class.equals(c)) {

            stream.write('c');

            return;

        }

    }

    /**

     * Creation date: (2/23/2001 2:43:25 AM)

     * @param anArray java.lang.Object[]

     */

    public void writeTypesArray(Object[] array) {

        // A big ol' case statement in a for loop -- what's polymorphism mean, again?

        // I really wish I could extend the base classes!

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

            if (null == array[i])

                continue;

            // if the array at i is a type of array write a [

            // This is used for nested arguments

            if (array[i].getClass().isArray()) {

                stream.write('[');

                // fill the [] with the SuperCollider types corresponding to the object

                // (i.e. Object of type String needs -s).

                writeTypesArray((Object[]) array[i]);

                // close the array

                stream.write(']');

                continue;

            }

            // Create a way to deal with Boolean type objects

            if (Boolean.TRUE.equals(array[i])) {

                stream.write('T');

                continue;

            }

            if (Boolean.FALSE.equals(array[i])) {

                stream.write('F');

                continue;

            }

            // go through the array and write the superCollider types as shown in the 

            // above method. the Classes derived here are used as the arg to the above method

            writeType(array[i].getClass());

        }

        // align the stream with padded bytes

        appendNullCharToAlignStream();

    }

    /**

     * Same as writeSuperColliderTypes(Object[]), just that it takes a vector (for jdk1.1

     * compatibility), rather than an array.

     * @param vector  the collection I am to write out types for

     */

    public void writeTypes(Vector vector) {

        // A big ol' case statement in a for loop -- what's polymorphism mean, again?

        // I really wish I could extend the base classes!

        Enumeration enm = vector.elements();

        Object nextObject;

        while (enm.hasMoreElements()) {

            nextObject = enm.nextElement();

            if (null == nextObject)

                continue;

            // if the array at i is a type of array write a [

            // This is used for nested arguments

            if (nextObject.getClass().isArray()) {

                stream.write('[');

                // fill the [] with the SuperCollider types corresponding to the object

                // (e.g., Object of type String needs -s).

                writeTypesArray((Object[]) nextObject);

                // close the array

                stream.write(']');

                continue;

            }

            // Create a way to deal with Boolean type objects

            if (Boolean.TRUE.equals(nextObject)) {

                stream.write('T');

                continue;

            }

            if (Boolean.FALSE.equals(nextObject)) {

                stream.write('F');

                continue;

            }

            // go through the array and write the superCollider types as shown in the 

            // above method. the Classes derived here are used as the arg to the above method

            writeType(nextObject.getClass());

        }

        // align the stream with padded bytes

        appendNullCharToAlignStream();

    }

    /**

     * convert an integer to byte array

     *

     * @param value int

     */

    private void writeIntegerToByteArray(int value) {

        byte[] intBytes = new byte[4];

        intBytes[3] = (byte)value; value>>>=8;

        intBytes[2] = (byte)value; value>>>=8;

        intBytes[1] = (byte)value; value>>>=8;

        intBytes[0] = (byte)value;

        try {

            stream.write(intBytes);

        } catch (IOException e) {

            throw new RuntimeException("You're screwed: IOException writing to a ByteArrayOutputStream");

        }

    }

    /**

     * Line up the BigEnd of the bytes to a 4 byte boundry

     *

     * @param bytes byte[]

     */

    private void writeBigEndToFourByteBoundry(byte[] bytes) {

        int mod = bytes.length % 4;

        // if the remainder == 0 write the bytes

        if (mod == 0) {

            try { stream.write(bytes); } catch (IOException e)

            { throw new RuntimeException("You're screwed: IOException writing to a ByteArrayOutputStream"); }

            return;

        }

        // pad the bytes to lineup correctly

        int pad = 4 - mod;

        byte[] newBytes = new byte[pad + bytes.length];

        System.arraycopy(bytes,0,newBytes,pad,bytes.length);

        try { stream.write(newBytes); } catch (IOException e)

        { throw new RuntimeException("You're screwed: IOException writing to a ByteArrayOutputStream"); }

    }

    /**

     * Line up the LittleEnd of the bytes to a 4 byte boundry

     * 

     * @param bytes byte[]

     */

    private void writeLittleEndToFourByteBoundry(byte[] bytes) {

        int mod = bytes.length % 4;

        // if the remainder == 0 write the bytes

        if (mod == 4) {

            try { stream.write(bytes); } catch (IOException e)

            { throw new RuntimeException("You're screwed: IOException writing to a ByteArrayOutputStream"); }

            return;

        }

        // pad the bytes to lineup correctly

        int pad = 4 - mod;

        byte[] newBytes = new byte[pad + bytes.length];

        System.arraycopy(bytes,0,newBytes,0,bytes.length);

        try { stream.write(newBytes); } catch (IOException e)

        { throw new RuntimeException("You're screwed: IOException writing to a ByteArrayOutputStream"); }

    }

}