/**

 * 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.ByteArrayInputStream;

import java.io.EOFException;

import java.io.IOException;

import java.net.SocketException;

import java.nio.ByteBuffer;

import java.nio.channels.SocketChannel;



import org.apache.commons.lang.StringUtils;



/**

 * Reader on top of channel.

 * 

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

 */

public class ChannelReader implements Reader {

	

	ReadLock lock = new ReadLock();

	private SocketChannel channel;

	private ByteBuffer readBuffer;

	private int soTimeout = 180000; // 3??

	

	public ChannelReader(SocketChannel channel, int readBufSize) {

		this.channel = channel;

		try {

			if (channel.socket().getSoTimeout() > 0)

				this.soTimeout = channel.socket().getSoTimeout();

		} catch (SocketException e) {

			// ignore;

		}

		

		this.readBuffer = ByteBuffer.allocate(readBufSize);

	}



	public byte readByte() throws IOException {

		byte[] bytes = new byte[1];

		read(bytes, 0, bytes.length);

		

		ByteArrayInputStream bis = new ByteArrayInputStream(bytes);

		return StreamUtil.readByte(bis);

	}

	

	public boolean readBoolean() throws IOException {

		byte[] bytes = new byte[1];

		read(bytes, 0, bytes.length);

		

		ByteArrayInputStream bis = new ByteArrayInputStream(bytes);

		return StreamUtil.readBoolean(bis);

	}

	

	public char readChar() throws IOException {

		byte[] bytes = new byte[2];

		read(bytes, 0, bytes.length);

		

		ByteArrayInputStream bis = new ByteArrayInputStream(bytes);

		return StreamUtil.readChar(bis);

	}

	

	public short readShort() throws IOException {

		byte[] bytes = new byte[2];

		read(bytes, 0, bytes.length);

		

		ByteArrayInputStream bis = new ByteArrayInputStream(bytes);

		return StreamUtil.readShort(bis);

	}

	

	public int readInt() throws IOException {

		byte[] bytes = new byte[4];

		read(bytes, 0, bytes.length);

		

		ByteArrayInputStream bis = new ByteArrayInputStream(bytes);

		return StreamUtil.readInt(bis);

	}

	

	public long readLong() throws IOException {

		byte[] bytes = new byte[8];

		read(bytes, 0, bytes.length);

		

		ByteArrayInputStream bis = new ByteArrayInputStream(bytes);

		return StreamUtil.readLong(bis);

	}

	

	public float readFloat() throws IOException {

		return Float.intBitsToFloat(readInt());

	}

	

	public double readDouble() throws IOException {

		return Double.longBitsToDouble(readLong());

	}

	

	public String readUTF() throws IOException {

		int strlen = readInt();

        if (strlen == -1)

            return null;

        else if (strlen == 0)

            return StringUtils.EMPTY;

        

        int utflen = readInt();

        StringBuffer sb = new StringBuffer(strlen);

        byte[] bytes = new byte[utflen];

        read(bytes, 0, utflen);

        

        StreamUtil.toString(bytes, utflen, sb);

		return sb.toString();

	}

	

	public int read(byte[] bytes, int offset, int length) throws IOException {

		if (bytes == null) {

		    throw new NullPointerException();

		} else if (offset < 0 || length < 0 || length > bytes.length - offset) {

		    throw new IndexOutOfBoundsException();

		} else if (length == 0) {

		    return 0;

		}

		

		int read = 0;

		int capacity = readBuffer.capacity();

		long startTime = System.currentTimeMillis();

		while (length > 0 && (System.currentTimeMillis() - startTime) < soTimeout) {

			lock.readyToReadData(); // ??channel?????????????????????

			try {

				while (length > capacity) {

					while (readBuffer.hasRemaining())

						channel.read(readBuffer);

					readBuffer.rewind();

					readBuffer.get(bytes, offset, capacity);

					offset += capacity;

					read += capacity;

					length -= capacity;

					readBuffer.clear();

				}

				

				readBuffer.limit(length);

				while (readBuffer.hasRemaining())

					channel.read(readBuffer);

				readBuffer.flip();

				readBuffer.get(bytes, offset, length);

				read += length;

				length = 0;

				readBuffer.clear();

			}

			catch (EOFException e) {

				lock.blockedReading();

			}

		}

		if (length != 0)

			throw new SocketException("Expect " + (read + length) + " bytes in channel, but was " + read + " bytes.");

		return read;

	}



	public void close() {

		readBuffer = null;

		

		try {

			channel.close();

        } catch (Throwable t) {

        }

	}

}