/*
 * 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.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Iterator;

import org.apache.commons.lang3.ArrayUtils;

/**
 * Implementation of common operations for an EntityCollection.
 * @version $Revision: 1301248 $ $Date: 2012-03-15 17:20:49 -0500 (Thu, 15 Mar 2012) $
 */
public abstract class EntityCollectionSupport extends EntitySupport implements EntityCollection {
    /** Serialization version */
    private static final long serialVersionUID = 5902476686737324304L;

    private static final byte[] DEFAULT_DELIMITER = ArrayUtils.EMPTY_BYTE_ARRAY;

    private byte[] delim = DEFAULT_DELIMITER;
    private boolean delimAfter = true;
    private boolean suppressEmptyChildren = true;

    /**
     * {@inheritDoc}
     */
    public final synchronized int length() {
        int result = 0;
        for (Iterator<Entity> it = getChildren().iterator(); it.hasNext();) {
            Entity e = it.next();
            if (shouldSuppress(e)) {
                continue;
            }
            result += e.length();
            if (it.hasNext() || isDelimAfter()) {
                result += getDelim().length;
            }
        }
        return result;
    }

    /**
     * {@inheritDoc}
     */
    public final synchronized void readFrom(InputStream is) throws IOException {
        for (Iterator<Entity> it = getChildren().iterator(); it.hasNext();) {
            Entity e = it.next();
            if (shouldSuppress(e)) {
                continue;
            }
            e.readFrom(is);
            if (it.hasNext() || isDelimAfter()) {
                is.skip(getDelim().length);
            }
        }
    }

    /**
     * {@inheritDoc}
     */
    public final synchronized void writeTo(OutputStream os) throws IOException {
        for (Iterator<Entity> it = getChildren().iterator(); it.hasNext();) {
            Entity e = it.next();
            if (shouldSuppress(e)) {
                continue;
            }
            e.writeTo(os);
            if (it.hasNext() || isDelimAfter()) {
                os.write(getDelim());
            }
        }
    }

    /**
     * {@inheritDoc}
     */
    public final synchronized byte[] getValue() {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try {
            writeTo(baos);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return baos.toByteArray();
    }

    /**
     * {@inheritDoc}
     */
    public final synchronized void setValue(byte[] b) {
        try {
            readFrom(new ByteArrayInputStream(b));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * {@inheritDoc}
     */
    public final void setValue(byte[] b, int offset, int length) {
        try {
            readFrom(new ByteArrayInputStream(b, offset, length));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * Learn whether a trailing delimiter will be added when a delimiter is being used.
     * @return boolean.
     */
    public boolean isDelimAfter() {
        return delimAfter;
    }

    /**
     * Set whether to add a trailing delimiter when a delimiter is being used.
     * Default is <code>true</code>.
     * @param delimAfter The boolean delimAfter to set.
     */
    public void setDelimAfter(boolean delimAfter) {
        this.delimAfter = delimAfter;
    }

    /**
     * Get the delimiter to use between children.
     * @return byte[].
     */
    public byte[] getDelim() {
        return delim;
    }

    /**
     * Set the delimiter to use between children.
     * @param delim The byte[] delimiter to set.
     */
    public synchronized void setDelim(byte[] delim) {
        this.delim = delim == null ? DEFAULT_DELIMITER : delim;
    }

    /**
     * Get the boolean suppressEmptyChildren.
     * @return boolean
     */
    public boolean isSuppressEmptyChildren() {
        return suppressEmptyChildren;
    }

    /**
     * Set the boolean suppressEmptyChildren.
     * @param suppressEmptyChildren boolean
     */
    public void setSuppressEmptyChildren(boolean suppressEmptyChildren) {
        this.suppressEmptyChildren = suppressEmptyChildren;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public EntityCollectionSupport clone() {
        return (EntityCollectionSupport) super.clone();
    }

    /**
     * Learn whether the specified child should be suppressed.
     * @param child to check
     * @return boolean
     */
    protected boolean shouldSuppress(Entity child) {
        return isSuppressEmptyChildren() && child.length() == 0;
    }

}