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

}