/**

 * Copyright 2002-2006 the original author or authors.

 * 

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 * 

 *      http://www.apache.org/licenses/LICENSE-2.0

 * 

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package opentss;



import java.io.EOFException;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.UTFDataFormatException;



import org.apache.commons.lang.StringUtils;



/**

 * ?????????????????

 * 

 * @author <a href="mailto:max.h.chen@hotmail.com">Max Chen</a>

 */

public final class StreamUtil {



	private StreamUtil() {}

	

    public static void writeByte(OutputStream out, byte b) throws IOException {

        out.write(b);

    }

    

    public static byte readByte(InputStream in) throws IOException {

        return (byte) (in.read() & 0xFF);

    }

    

    public static void writeBoolean(OutputStream out, boolean b) throws IOException {

        out.write(b ? 1 : 0);

    }

    

    public static boolean readBoolean(InputStream in) throws IOException {

	    return in.read() != 0;

	}

    

    public static void writeChar(OutputStream out, char c) throws IOException {

        out.write((c >>> 8) & 0xFF);

        out.write((c >>> 0) & 0xFF);

    }

    

    public static char readChar(InputStream in) throws IOException {

	    int ch1 = in.read();

	    int ch2 = in.read();

	    if ((ch1 | ch2) < 0)

	        throw new EOFException();

	    return (char) ((ch1 << 8) + (ch2 << 0));

	}

    

    public static void writeShort(OutputStream out, short s) throws IOException {

        out.write((s >>> 8) & 0xFF);

        out.write((s >>> 0) & 0xFF);

    }

    

    public static short readShort(InputStream in) throws IOException {

	    int ch1 = in.read();

	    int ch2 = in.read();

	    if ((ch1 | ch2) < 0)

	        throw new EOFException();

	    return (short) ((ch1 << 8) + (ch2 << 0));

	}

    

    public static void writeInt(OutputStream out, int i) throws IOException {

        out.write((i >>> 24) & 0xFF);

        out.write((i >>> 16) & 0xFF);

        out.write((i >>> 8) & 0xFF);

        out.write((i >>> 0) & 0xFF);

    }

    

    public static int readInt(InputStream in) throws IOException {

	    int ch1 = in.read();

	    int ch2 = in.read();

	    int ch3 = in.read();

	    int ch4 = in.read();

	    if ((ch1 | ch2 | ch3 | ch4) < 0)

	        throw new EOFException();

	    return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4 << 0));

	}

    

    public static void writeLong(OutputStream out, long l) throws IOException {

        out.write((int) (l >>> 56) & 0xFF);

        out.write((int) (l >>> 48) & 0xFF);

        out.write((int) (l >>> 40) & 0xFF);

        out.write((int) (l >>> 32) & 0xFF);

        out.write((int) (l >>> 24) & 0xFF);

        out.write((int) (l >>> 16) & 0xFF);

        out.write((int) (l >>> 8) & 0xFF);

        out.write((int) (l >>> 0) & 0xFF);

    }

    

    public static long readLong(InputStream in) throws IOException {

	    return ((long) (readInt(in)) << 32) + (readInt(in) & 0xFFFFFFFFL);

	}

    

    public static void writeFloat(OutputStream out, float f) throws IOException {

        writeInt(out, Float.floatToIntBits(f));

    }

    

    public static float readFloat(InputStream in) throws IOException {

	    return Float.intBitsToFloat(readInt(in));

	}

    

    public static void writeDouble(OutputStream out, double d) throws IOException {

        writeLong(out, Double.doubleToLongBits(d));

    }

    

    public static double readDouble(InputStream in) throws IOException {

	    return Double.longBitsToDouble(readLong(in));

	}

    

    public static void writeUTF(OutputStream out, String str) throws IOException {

    	if (str == null) {

            writeInt(out, -1);

            return ;

        }

        else if (str.length() == 0) {

            writeInt(out, 0);

            return ;

        }

    	byte[] buf = toUTF(str);

        out.write(buf, 0, buf.length);

    }

    

    static final byte[] toUTF(String str) throws IOException {

	    int strlen = str.length();

	    int utflen = 0;

	    char[] chars = str.toCharArray();



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

	        int c = chars[i];

	        if ((c >= 0x0001) && (c <= 0x007F)) {

	            utflen++;

	        }

	        else if (c > 0x07FF) {

	            utflen += 3;

	        }

	        else {

	            utflen += 2;

	        }

	    }

	    

	    if (utflen > 65535)

	        throw new UTFDataFormatException();

	    

	    int size = utflen + 8;

	    byte[] bytes = new byte[size];

	    int offset = 0;



	    bytes[offset++] = (byte) (strlen >> 24);

        bytes[offset++] = (byte) (strlen >> 16);

        bytes[offset++] = (byte) (strlen >> 8);

        bytes[offset++] = (byte) (strlen >> 0);

        bytes[offset++] = (byte) (utflen >> 24);

        bytes[offset++] = (byte) (utflen >> 16);

        bytes[offset++] = (byte) (utflen >> 8);

        bytes[offset++] = (byte) (utflen >> 0);



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

	        int c = chars[i];

	        if ((c >= 0x0001) && (c <= 0x007F)) {

	            bytes[offset++] = (byte) c;

	        }

	        else if (c > 0x07FF) {

	            bytes[offset++] = (byte) (0xE0 | ((c >> 12) & 0x0F));

	            bytes[offset++] = (byte) (0x80 | ((c >> 6) & 0x3F));

	            bytes[offset++] = (byte) (0x80 | ((c >> 0) & 0x3F));

	        }

	        else {

	            bytes[offset++] = (byte) (0xC0 | ((c >> 6) & 0x1F));

	            bytes[offset++] = (byte) (0x80 | ((c >> 0) & 0x3F));

	        }

	    }

	    return bytes;

	}

    

    public static String readUTF(InputStream in) throws IOException {

    	int strlen = readInt(in);

        if (strlen == -1)

            return null;

        else if (strlen == 0)

            return StringUtils.EMPTY;



        int utflen = readInt(in);

        StringBuffer sb = new StringBuffer(strlen);

        byte[] bytes = new byte[utflen];



        StreamUtil.readFully(in, bytes, 0, utflen);



        toString(bytes, utflen, sb);

        return sb.toString();

    }

    

    static final void toString(byte[] bytes, int utflen, StringBuffer sb) throws IOException {

		int char2, char3;

		int offset = 0;



		while (offset < utflen) {

			int c = bytes[offset] & 0xff;

			switch (c >> 4) {

				case 0:

				case 1:

				case 2:

				case 3:

				case 4:

				case 5:

				case 6:

				case 7:

					/* 0xxxxxxx */

					offset++;

					sb.append((char) c);

					break;

				case 12:

				case 13:

					/* 110x xxxx 10xx xxxx */

					offset += 2;

					if (offset > utflen)

						throw new UTFDataFormatException();

					char2 = bytes[offset - 1];

					if ((char2 & 0xC0) != 0x80)

						throw new UTFDataFormatException();

					sb.append((char) (((c & 0x1F) << 6) | (char2 & 0x3F)));

					break;

				case 14:

					/* 1110 xxxx 10xx xxxx 10xx xxxx */

					offset += 3;

					if (offset > utflen)

						throw new UTFDataFormatException();

					char2 = bytes[offset - 2];

					char3 = bytes[offset - 1];

					if (((char2 & 0xC0) != 0x80) || ((char3 & 0xC0) != 0x80))

						throw new UTFDataFormatException();

					sb.append((char) (((c & 0x0F) << 12) | ((char2 & 0x3F) << 6) | ((char3 & 0x3F) << 0)));

					break;

				default:

					/* 10xx xxxx, 1111 xxxx */

					throw new UTFDataFormatException();

			}

		}

	}

    

    public static int readFully(InputStream in, byte[] bytes) throws IOException {

        return readFully(in, bytes, 0, bytes.length);

    }

    

    public static int readFully(InputStream in, byte[] bytes, int off, int len) throws IOException {

        if (len < 0)

            throw new IndexOutOfBoundsException();



        int n = 0;

        int read = 0;

        while (n < len) {

            read = in.read(bytes, off + n, len - n);

            if (read <= 0)

                break;

            n += read;

        }

        return n;

    }

    

    public static boolean close(InputStream input) {

        if (input == null) {

            return true;

        }

        try {

            input.close();

            return true;

        } catch (Exception e) {

            return false;

        }

    }

    

    public static boolean close(OutputStream output) {

        if (output == null) {

            return true;

        }

        try {

            output.flush();

            output.close();

            return true;

        } catch (Exception e) {

            return false;

        }

    }

}