// tmp class to implement Buffer until I can get rid of it

package org.eclipse.jetty.io;

import java.io.InputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.Channels;
import java.nio.channels.ReadableByteChannel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.eclipse.jetty.util.TypeUtil;


public final class JBuffer {
	private static final Logger LOG = LoggerFactory.getLogger(JBuffer.class);

	private final ByteBuffer bb;

	public JBuffer(ByteBuffer bb) {
		this.bb = bb;
	}

	public int position() {
		return bb.position();
	}

	public void position(int i) {
		bb.position(i);
	}

	public void limit(int i) {
		bb.limit(i);
	}

	public byte[] array() {
		return bb.array();
	}

	public boolean hasArray() {
		return bb.hasArray();
	}

	public JBuffer duplicate() {
		return new JBuffer(bb.duplicate());
	}

	public int remaining() {
		return bb.remaining();
	}

	public boolean isReadOnly() {
		return bb.isReadOnly();
	}

	public boolean hasRemaining() {
		return bb.hasRemaining();
	}

	public byte get() {
		return bb.get();
	}

	public void get(byte[] bytes) {
		bb.get(bytes);
	}

	public void compact() {
		int n = bb.remaining();
		bb.compact();
		bb.position(0);
		bb.limit(n);
	}

	public int capacity() {
		return bb.capacity();
	}



	public ByteBuffer getByteBuffer() {
		ByteBuffer dup = bb.duplicate();
		dup.limit(dup.capacity());
		return dup;
	}

	public int getIndex() {
		return bb.position();
	}

	public void clear() {
		bb.position(0);
		bb.limit(0);
	}

	public int space() {
		return bb.capacity() - bb.limit();
	}


	public int get(byte[] b, int offset, int length) {
		int remaining = bb.remaining();
		if( remaining == 0 )
			return -1;
		if( length > remaining )
			length = remaining;
		bb.get(b,offset,length);
		return length;
	}


	public int put(JBuffer src) {
		return put(src.asArray());
	}

	public void put(byte b)
	{
		ByteBuffer dup = bb.duplicate();
		dup.position(bb.limit());
		dup.limit(bb.capacity());
		dup.put(b);
		bb.limit(bb.limit()+1);
	}

	private int put(byte[] b, int offset, int length) {
		ByteBuffer dup = bb.duplicate();
		int put = bb.limit();
		int capacity = bb.capacity();
		dup.position(put);
		dup.limit(capacity);
		if( length > capacity - put )
			length = capacity - put;
		dup.put(b,offset,length);
		bb.limit(put+length);
		return length;
	}

	public int put(byte[] b) {
		return put(b,0,b.length);
	}

	public final int putIndex() {
		return bb.limit();
	}

	public void setGetIndex(int getIndex) {
		bb.position(getIndex);
	}

	public void setPutIndex(int putIndex) {
		bb.limit(putIndex);
	}

	public void skip(int n) {
		if (remaining() < n) n = remaining();
		bb.position(bb.position() + n);
	}

	public int readFrom(InputStream in,int max) throws IOException {
		ByteBuffer dup = bb.duplicate();
		int put = bb.limit();
		dup.limit( Math.min(put+max,bb.capacity()) );
		dup.position(put);

		ReadableByteChannel chan = Channels.newChannel(in);
		int n = chan.read(dup);

		if( n > 0 )
			bb.limit(put+n);
		return n;
	}

	public final byte[] asArray() {
		byte[] bytes = new byte[remaining()];
		bb.duplicate().get(bytes);
		return bytes;
	}

	@Override
	public String toString() {
//		return toString("ISO-8859-1");
//		Thread.dumpStack();
		throw new RuntimeException("toString");
	}


	private JBuffer pokeBuffer(int index) {
		JBuffer dup = duplicate();
		dup.setPutIndex(index);
		return dup;
	}

	public int poke(int index, byte b[], int offset, int length) {
		return pokeBuffer(index).put(b,offset,length);
	}

	public void poke(int index, byte b) {
		pokeBuffer(index).put(b);
	}


	public byte get(int index) {
		return bb.get(index);
	}

}