/*
    *  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.
      */
     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);
     }
 }