/*
 *  Licensed to the Apache Software Foundation (ASF) under one
 *  or more contributor license agreements.  See the NOTICE file
 *  distributed with this work for additional information
 *  regarding copyright ownership.  The ASF licenses this file
 *  to you 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 org.apache.mina.util.byteaccess;

import org.apache.mina.core.buffer.IoBuffer;

/**
 * Provides restricted, relative, write-only access to the bytes in a
 * <code>CompositeByteArray</code>.
 *
 * Using this interface has the advantage that it can be automatically
 * determined when a component <code>ByteArray</code> can no longer be written
 * to, and thus components can be automatically flushed. This makes it easier to
 * use pooling for underlying <code>ByteArray</code>s.
 *
 * By providing an appropriate <code>Expander</code> it is also possible to
 * automatically add more backing storage as more data is written.
 *<br>
 *<br>
 * TODO: Get flushing working.
 * 
 * @author <a href="http://mina.apache.org">Apache MINA Project</a>
 */
public class CompositeByteArrayRelativeWriter extends CompositeByteArrayRelativeBase implements IoRelativeWriter {

    /**
     * An object that knows how to expand a <code>CompositeByteArray</code>.
     */
    public interface Expander {
        void expand(CompositeByteArray cba, int minSize);
    }

    /**
     * No-op expander.  The overridden method does nothing.
     * 
     */
    public static class NopExpander implements Expander {
        public void expand(CompositeByteArray cba, int minSize) {
            // Do nothing.
        }
    }

    /**
     * Expands the supplied {@link CompositeByteArray} by the number of
     * bytes provided in the constructor
     * 
     */
    public static class ChunkedExpander implements Expander {

        private final ByteArrayFactory baf;

        private final int newComponentSize;

        public ChunkedExpander(ByteArrayFactory baf, int newComponentSize) {
            this.baf = baf;
            this.newComponentSize = newComponentSize;
        }

        public void expand(CompositeByteArray cba, int minSize) {
            int remaining = minSize;
            while (remaining > 0) {
                ByteArray component = baf.create(newComponentSize);
                cba.addLast(component);
                remaining -= newComponentSize;
            }
        }

    }

    /**
     * An object that knows how to flush a <code>ByteArray</code>.
     */
    public interface Flusher {
        // document free() behaviour
        void flush(ByteArray ba);
    }

    /**
     * The expander to use when the array underflows.
     */
    private final Expander expander;

    /**
     * The flusher to use when flushing component <code>ByteArray</code>s.
     */
    private final Flusher flusher;

    /**
     * Whether or not to automatically flush a component once the cursor moves
     * past it.
     */
    private final boolean autoFlush;

    /**
     * 
     * Creates a new instance of CompositeByteArrayRelativeWriter.
     *
     * @param cba
     *  The CompositeByteArray to use to back this class
     * @param expander
     *  The expander.  Will increase the size of the internal ByteArray
     * @param flusher
     *  Flushed the ByteArray when necessary
     * @param autoFlush
     *  Should this class automatically flush?
     */
    public CompositeByteArrayRelativeWriter(CompositeByteArray cba, Expander expander, Flusher flusher,
            boolean autoFlush) {
        super(cba);
        this.expander = expander;
        this.flusher = flusher;
        this.autoFlush = autoFlush;
    }

    private void prepareForAccess(int size) {
        int underflow = cursor.getIndex() + size - last();
        if (underflow > 0) {
            expander.expand(cba, underflow);
        }
    }

    /**
     * Flush to the current index.
     */
    public void flush() {
        flushTo(cursor.getIndex());
    }

    /**
     * Flush to the given index.
     * 
     * @param index The end position
     */
    public void flushTo(int index) {
        ByteArray removed = cba.removeTo(index);
        flusher.flush(removed);
    }

    /**
     * {@inheritDoc}
     */
    public void skip(int length) {
        cursor.skip(length);
    }

    @Override
    protected void cursorPassedFirstComponent() {
        if (autoFlush) {
            flushTo(cba.first() + cba.getFirst().length());
        }
    }

    /**
     * {@inheritDoc}
     */
    public void put(byte b) {
        prepareForAccess(1);
        cursor.put(b);
    }

    /**
     * {@inheritDoc}
     */
    public void put(IoBuffer bb) {
        prepareForAccess(bb.remaining());
        cursor.put(bb);
    }

    /**
     * {@inheritDoc}
     */
    public void putShort(short s) {
        prepareForAccess(2);
        cursor.putShort(s);
    }

    /**
     * {@inheritDoc}
     */
    public void putInt(int i) {
        prepareForAccess(4);
        cursor.putInt(i);
    }

    /**
     * {@inheritDoc}
     */
    public void putLong(long l) {
        prepareForAccess(8);
        cursor.putLong(l);
    }

    /**
     * {@inheritDoc}
     */
    public void putFloat(float f) {
        prepareForAccess(4);
        cursor.putFloat(f);
    }

    /**
     * {@inheritDoc}
     */
    public void putDouble(double d) {
        prepareForAccess(8);
        cursor.putDouble(d);
    }

    /**
     * {@inheritDoc}
     */
    public void putChar(char c) {
        prepareForAccess(2);
        cursor.putChar(c);
    }
}
