package org.jgroups.nio;

import java.io.EOFException;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.GatheringByteChannel;
import java.nio.channels.NotYetConnectedException;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.NoSuchElementException;

/**
 * Class to do scattering reads or gathering writes on a sequence of {@link ByteBuffer} instances. The buffers are
 * kept in an array with fixed capacity (max Short.MAX_VALUE).
 * Buffers can be added and removed dynamically (they're dropped when the capacity is exceeded).<p/>
 * A read is successful when all non-null buffers from left to right are filled, ie. all {@link ByteBuffer#remaining()}
 * methods return 0.<p/>
 * Same for writes: when all non-null buffers (from left to right) have been written ({@link ByteBuffer#remaining()} == 0),
 * a write is considered successful; otherwise it is partial.<p/>
 * Individual buffers can be accessed; e.g. for reading its value after a read. It is also possible to add buffers
 * dynamically, e.g. after reading a 'length' buffer, a user may want to add a new buffer allocated for reading
 * 'length' bytes.<p/>
 * This class is not synchronized.
 * @author Bela Ban
 * @since  3.6.5
 */
public class Buffers implements Iterable<ByteBuffer> {
    protected final ByteBuffer[] bufs; // the buffers to be written or read
    protected short position;          // points to the next buffer in bufs to be read or written
    protected short limit;             // points beyond the last buffer in bufs that was read or written
    protected short next_to_copy;      // index of the next buffer to copy, set by copy(): position <= last_copied <= limit

    /**
     * Creates a new instance with an array of capacity buffers
     * @param capacity Must be an unsigned positive short [1 .. Short.MAX_VALUE]
     */
    public Buffers(int capacity) {
        bufs=new ByteBuffer[toPositiveUnsignedShort(capacity)];
    }

    public Buffers(ByteBuffer ... data) {
        if(data == null)
            throw new IllegalArgumentException("null buffer array");
        assertPositiveUnsignedShort(data.length);
        this.bufs=data;
        for(ByteBuffer b: this.bufs) {
            if(b == null)
                break;
            limit++;
        }
    }

    public int     position()              {return position;}
    public Buffers position(int new_pos)   {this.position=toPositiveUnsignedShort(new_pos); nextToCopy(new_pos); return this;}
    public int     limit()                 {return limit;}
    public Buffers limit(int new_limit)    {this.limit=toPositiveUnsignedShort(new_limit); return this;}
    public int     nextToCopy()            {return next_to_copy;}
    public Buffers nextToCopy(int next)    {next_to_copy=toPositiveUnsignedShort(next); return this;}


    public int remaining() {
        int remaining=0;
        for(int i=position; i < limit; i++) {
            ByteBuffer buf=bufs[i];
            if(buf != null)
                remaining+=buf.remaining();
        }
        return remaining;
    }

    public boolean hasRemaining() {
        for(int i=position; i < limit; i++) {
            ByteBuffer buf=bufs[i];
            if(buf != null && buf.hasRemaining())
                return true;
        }
        return false;
    }


    public Buffers add(ByteBuffer ... buffers) {
        if(buffers == null)
            return this;
        assertPositiveUnsignedShort(buffers.length);
        int len=buffers.length;
        if(spaceAvailable(len) || (makeSpace() && spaceAvailable(len))) {
            for(ByteBuffer buf: buffers)
                bufs[limit++]=buf;
        }
        return this;
    }

    public Buffers add(ByteBuffer buf) {
        if(buf == null)
            return this;
        if(spaceAvailable(1) || (makeSpace() && spaceAvailable(1)))
            bufs[limit++]=buf;
        return this;
    }


    public ByteBuffer get(int index) {
        return this.bufs[index];
    }

    public Buffers set(int index, ByteBuffer buf) {
        this.bufs[index]=buf; return this;
    }

    /** Nulls the buffer at index */
    public Buffers remove(int index) {
        return set(index, null);
    }



    /**
     * Reads length and then length bytes into the data buffer, which is grown if needed.
     * @param ch The channel to read data from
     * @return The data buffer (position is 0 and limit is length), or null if not all data could be read.
     */
    public ByteBuffer readLengthAndData(SocketChannel ch) throws Exception {
        if(bufs[0].hasRemaining() && ch.read(bufs[0]) < 0)
            throw new EOFException();

        if(bufs[0].hasRemaining())
            return null;

        int len=bufs[0].getInt(0);
        if(bufs[1] == null || len > bufs[1].capacity())
            bufs[1]=ByteBuffer.allocate(len);
        bufs[1].limit(len);

        if(bufs[1].hasRemaining() && ch.read(bufs[1]) < 0)
            throw new EOFException();

        if(bufs[1].hasRemaining())
            return null;

        try {
            return (ByteBuffer)bufs[1].duplicate().flip();
        }
        finally {
            bufs[0].clear();
            bufs[1].clear();
        }
    }

    /**
     * Performs a scattering read into all (contiguous) non-null buffers in range [position .. limit]. Returns true if
     * the scattering read was successful, else false. Note that to read the contents of the individual buffers,
     * {@link ByteBuffer#clear()} has to be called (all buffers have their position == limit on a successfull read).
     */
    public boolean read(SocketChannel ch) throws Exception {
        long bytes=ch.read(bufs, position, limit-position);
        if(bytes == -1)
            throw new EOFException();
        return adjustPosition(false);
    }

    /** Helper method which adds the buffers passed as arguments and then calls write() */
    public boolean write(GatheringByteChannel ch, ByteBuffer ... buffers) throws Exception {
        return add(buffers).write(ch);
    }

    /**
     * Writes the buffers from position to limit to the given channel. Note that all buffers need to have
     * their {@link ByteBuffer#position} at the start of the data to be written
     * be at the start of the data to be written.
     * @param ch The channel to write to
     * @return True if all the bytes of the buffer were written successfully, false otherwise (partial write).
     * @throws Exception Thrown if the write failed
     */
    public boolean write(GatheringByteChannel ch) throws Exception {
        int num_buffers_to_write=size();
        if(num_buffers_to_write == 0)
            return true;

        if(ch != null) {
            try {
                ch.write(bufs, position, num_buffers_to_write);
            }
            catch(ClosedChannelException closed_ex) {
                throw closed_ex;
            }
            catch(NotYetConnectedException | IOException others) {
                ; // ignore, we'll queue 1 write
            }
        }

        return nullData();
    }

    /** Copies the data that has not yet been written and moves last_copied. Typically done after an unsuccessful
     * write, if copying is required. This is typically needed if the output buffer is reused. Note that
     * direct buffers will be converted to heap-based buffers */
    public Buffers copy() {
        for(int i=Math.max(position, next_to_copy); i < limit; i++) {
            this.bufs[i]=copyBuffer(this.bufs[i]);
            next_to_copy=(short)(i+1);
        }
        return this;
    }

    /** Returns the number of elements that have not yet been read or written */
    public int size() {
        return limit - position;
    }

    public String toString() {
        return String.format("[%d bufs pos=%d lim=%d cap=%d rem=%d]", size(), position, limit, bufs.length, remaining());
    }

    protected boolean spaceAvailable(int num_buffers) {
        return bufs.length - limit >= num_buffers;
    }

    protected boolean makeSpace() {
        if(position == limit) { // easy case: no pending writes, but pos and limit are not at the head of the buffer
            position=limit=next_to_copy=0;   // redundant if position == 0, but who cares
            return true;
        }
        // limit > position: copy to head of buffer if position > 0
        if(position == 0) // cannot copy to head as position is already at head
            return false;

        // move data to the head of the buffer
        int buffers_to_move=size();
        for(int dest_index=0, src_index=position; dest_index < buffers_to_move; dest_index++, src_index++) {
            bufs[dest_index]=bufs[src_index];
        }
        // null buffers
        for(int i=buffers_to_move; i < limit; i++)
            bufs[i]=null;
        next_to_copy-=position;
        limit=(short)buffers_to_move; // same as limit-=position
        position=0;
        next_to_copy=(short)Math.max(next_to_copy, position);
        return true;
    }

     /** Looks at all buffers in range [position .. limit-1] and nulls buffers that have no remaining data.
     * Returns true if all buffers could be nulled, and false otherwise */
    protected boolean nullData() {
        if(!adjustPosition(true))
            return false;
        if(position >= bufs.length)
            makeSpace();
        return true;
    }

    protected boolean adjustPosition(boolean null_complete_data) {
        while(position < limit) {
            ByteBuffer buf=bufs[position];
            if(buf.remaining() > 0)
                return false;
            if(null_complete_data)
                bufs[position]=null;
            position++;
            if(next_to_copy < position)
                next_to_copy=position;
        }
        return true;
    }

    protected static short toPositiveUnsignedShort(int num) {
        assertPositiveUnsignedShort(num);
        return (short)num;
    }

    protected static void assertPositiveUnsignedShort(int num) {
        if(num < 1 || num > Short.MAX_VALUE) {
            short tmp=(short)num;
            throw new IllegalArgumentException(String.format("number %d must be a positive unsigned short", tmp));
        }
    }

    /*protected void assertNextToCopy() {
        boolean condition=position <= next_to_copy && next_to_copy <= limit;
        assert condition
          : String.format("position=%d next_to_copy=%d limit=%d\n", position, next_to_copy, limit);
    }*/

    /** Copies a ByteBuffer by copying and wrapping the underlying array of a heap-based buffer. Direct buffers
        are converted to heap-based buffers */
    public static ByteBuffer copyBuffer(final ByteBuffer buf) {
        if(buf == null)
            return null;
        int offset=buf.hasArray()? buf.arrayOffset() + buf.position() : buf.position(), len=buf.remaining();
        byte[] tmp=new byte[len];
        if(!buf.isDirect())
            System.arraycopy(buf.array(), offset, tmp, 0, len);
        else {
         //   buf.get(tmp, 0, len);
            for(int i=0; i < len; i++)
                tmp[i]=buf.get(i+offset);
        }
        return ByteBuffer.wrap(tmp);
    }

    @Override
    public Iterator<ByteBuffer> iterator() {
        return new BuffersIterator();
    }

    /** Iterates over the non-null buffers */
    protected class BuffersIterator implements Iterator<ByteBuffer> {
        protected int index=-1;

        @Override
        public boolean hasNext() {
            for(int i=index+1; i < bufs.length; i++)
                if(bufs[i] != null)
                    return true;
            return false;
        }

       // @SuppressWarnings("IteratorNextCanNotThrowNoSuchElementException")
        @Override
        public ByteBuffer next() {
            while(true) {
                if(++index >= bufs.length)
                    throw new NoSuchElementException(String.format("index %d is out of range (%d buffers)", index, bufs.length));
                if(bufs[index] != null)
                    return bufs[index];
            }
        }

        @Override
        public void remove() { // todo: remove when baselining on Java 8
            ;
        }
    }
}
