/*
    * 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.commons.flatfile;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.ObjectInputStream;
  import java.io.ObjectOutputStream;
  import java.io.OutputStream;
  import java.io.Serializable;
  import java.util.Arrays;
  
  import org.apache.commons.io.IOUtils;
  import org.apache.commons.io.output.ByteArrayOutputStream;
  import org.apache.commons.lang3.ArrayUtils;
  import org.apache.commons.lang3.ObjectUtils;
  import org.apache.commons.lang3.Validate;
  import org.apache.commons.lang3.builder.HashCodeBuilder;
  
  import org.apache.commons.flatfile.util.ThresholdingInputStream;
  
  /**
   * Dynamically-resizable field. Supports pad/justify, but only relevant when an assigned value is too small for the
   * field AND underflow == IGNORE.
   * @version $Revision: 1301248 $ $Date: 2012-03-15 17:20:49 -0500 (Thu, 15 Mar 2012) $
   */
  public class DynamicField extends PadJustifyFieldSupport {
      /**
       * Bounds
       */
      public static class Bounds implements Serializable {
          /**
           * Immutable range of all valid lengths.
           */
          public static final Bounds ALL_VALID = new Bounds() {
              private static final long serialVersionUID = -2039931927562380883L;
  
              {
                  this.minimum = 0;
                  this.maximum = Integer.MAX_VALUE;
              }
  
              /**
               * {@inheritDoc}
               */
              public void setMinimum(int minimum) {
              }
  
              /**
               * {@inheritDoc}
               */
              public void setMaximum(int maximum) {
              }
          };
  
          /**
           * Default bounds.
           */
          public static final Bounds DEFAULT = ALL_VALID;
  
          private static final long serialVersionUID = 1L;
  
          /** Minimum */
          protected int minimum;
  
          /** Maximum */
          protected int maximum;
  
          /**
           * Create a new Bounds.
           * @param minimum size
           * @param maximum size
           */
          public Bounds(int minimum, int maximum) {
              setMinimum(minimum);
              setMaximum(maximum);
          }
  
          /**
           * Create a new Bounds instance.
           * @param example to copy
           */
          private Bounds(Bounds example) {
              this(example.getMinimum(), example.getMaximum());
          }
 
         /**
          * Create a new Bounds instance.
          */
         private Bounds() {
         }
 
         /**
          * Get the maximum.
          * @return int
          */
         public int getMaximum() {
             return maximum;
         }
 
         /**
          * Set the maximum.
          * @param maximum int
          */
         public void setMaximum(int maximum) {
             Validate.isTrue(maximum <= ALL_VALID.getMaximum(), "maximum value %d > %d", maximum,
                 ALL_VALID.getMaximum());
             this.maximum = maximum;
         }
 
         /**
          * Get the minimum.
          * @return int
          */
         public int getMinimum() {
             return minimum;
         }
 
         /**
          * Set the minimum.
          * @param minimum int
          */
         public void setMinimum(int minimum) {
             Validate.isTrue(minimum >= ALL_VALID.getMinimum(), "minimum value %s < %s", minimum,
                 ALL_VALID.getMinimum());
             this.minimum = minimum;
         }
 
         /**
          * {@inheritDoc}
          */
         public boolean equals(Object o) {
             if (o == this) {
                 return true;
             }
             if (!(o instanceof Bounds)) {
                 return false;
             }
             Bounds ob = (Bounds) o;
             return ob.getMaximum() == getMaximum() && ob.getMinimum() == getMinimum();
         }
 
         /**
          * {@inheritDoc}
          */
         public int hashCode() {
             return new HashCodeBuilder().append(minimum).append(maximum).toHashCode();
         }
 
         /**
          * Validate a field and value against these Bounds.
          * @param value to validate
          * @param df field to validate
          */
         public void validate(byte[] value, DynamicField df) {
             df.getUnderflow().check(value, getMinimum());
             df.getOverflow().check(value, getMaximum());
         }
     }
 
     /** Serialization version */
     private static final long serialVersionUID = -319053179741813727L;
 
     private Bounds bounds;
     private Overflow overflow;
     private Underflow underflow;
     private transient ByteArrayOutputStream buffer;
 
     /**
      * Create a new DynamicField.
      */
     public DynamicField() {
         this(new Bounds(Bounds.DEFAULT));
     }
 
     /**
      * Create a new DynamicField.
      * @param bounds bounds
      */
     public DynamicField(Bounds bounds) {
         setBounds(bounds);
     }
 
     /**
      * {@inheritDoc}
      */
     public synchronized byte[] getValue() {
         initialize(ArrayUtils.EMPTY_BYTE_ARRAY);
         return buffer.toByteArray();
     }
 
     /**
      * {@inheritDoc}
      */
     public int length() {
         initialize(ArrayUtils.EMPTY_BYTE_ARRAY);
         return buffer.size();
     }
 
     /**
      * Read up to <code>maximumLength</code> bytes from the specified InputStream or stop at EOF. This will rarely be
      * what you want. Instead, consider using InputFilteringDynamicField. In the case that &lt;
      * <code>minimumLength</code> bytes are available from <code>is</code> the <code>justify</code> and
      * <code>pad</code> options come into play.
      * @param is the InputStream from which to read data.
      * @throws IOException on problems with I/O, duh...
      */
     public synchronized void readFrom(InputStream is) throws IOException {
         initialize();
         buffer.reset();
         IOUtils.copy(new ThresholdingInputStream(is, getBounds().getMaximum()), buffer);
     }
 
     /**
      * {@inheritDoc}
      */
     public synchronized void setValue(byte[] b) {
         getBounds().validate(b, this);
         initialize();
         iSetValue(b);
     }
 
     /**
      * {@inheritDoc}
      */
     public synchronized void writeTo(OutputStream os) throws IOException {
         initialize(ArrayUtils.EMPTY_BYTE_ARRAY);
         buffer.writeTo(os);
     }
 
     /**
      * Get the overflow.
      * @return Overflow
      */
     public Overflow getOverflow() {
         return overflow == null ? Overflow.ERROR : overflow;
     }
 
     /**
      * Set the overflow.
      * @param overflow Overflow
      */
     public void setOverflow(Overflow overflow) {
         this.overflow = overflow;
     }
 
     /**
      * Get the underflow.
      * @return Underflow
      */
     public Underflow getUnderflow() {
         return underflow == null ? Underflow.ERROR : underflow;
     }
 
     /**
      * Set the underflow.
      * @param underflow Underflow
      */
     public void setUnderflow(Underflow underflow) {
         this.underflow = underflow;
     }
 
     /**
      * {@inheritDoc}
      */
     public int hashCode() {
         return new HashCodeBuilder().append(getBounds()).append(getValue()).toHashCode();
     }
 
     /**
      * {@inheritDoc}
      */
     public boolean equals(Object other) {
         if (other == this) {
             return true;
         }
         if (!(other instanceof DynamicField)) {
             return false;
         }
         DynamicField odf = (DynamicField) other;
         return ObjectUtils.equals(odf.getBounds(), getBounds())
                 && Arrays.equals(odf.getValue(), getValue());
     }
 
     /**
      * {@inheritDoc}
      */
     protected int getPadJustifyLength() {
         return getBounds().getMinimum();
     }
 
     /**
      * Protected inner setValue
      * @param value byte[]
      */
     protected synchronized void iSetValue(byte[] value) {
         super.setValue(value);
     }
 
     /**
      * {@inheritDoc}
      */
     public DynamicField clone() {
         DynamicField result = (DynamicField) super.clone();
         result.setBounds(new Bounds(getBounds()));
         result.buffer = null;
         result.setValue(getValue());
         return result;
     }
 
     /**
      * Get the bounds.
      * @return Bounds
      */
     public Bounds getBounds() {
         return bounds;
     }
 
     /**
      * Set the bounds.
      * @param bounds Bounds
      */
     public void setBounds(Bounds bounds) {
         this.bounds = Validate.notNull(bounds, "bounds cannot be null");
     }
 
     /**
      * Serialization
      * @param out to write to
      * @throws IOException on error
      */
     private synchronized void writeObject(ObjectOutputStream out) throws IOException {
         out.writeObject(getBounds());
         initialize(ArrayUtils.EMPTY_BYTE_ARRAY);
         out.write(buffer.size());
         buffer.writeTo(out);
     }
 
     /**
      * Serialization
      * @param in to read from
      * @throws IOException on error
      * @throws ClassNotFoundException if Object class not found
      */
     private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
         setBounds((Bounds) in.readObject());
         int n = in.read();
         initialize();
         if (n > 0) {
             IOUtils.copy(new ThresholdingInputStream(in, n), buffer);
         }
     }
 
     /**
      * Intitialize this {@link DynamicField}.
      */
     private void initialize() {
         initialize(null);
     }
 
     /**
      * Initialize this {@link DynamicField} from a given byte[].
      * @param value byte[]
      */
     private synchronized void initialize(byte[] value) {
         if (buffer == null) {
             buffer = new ByteArrayOutputStream();
             if (value != null) {
                 iSetValue(value);
             }
         }
     }
 
 }