/*
 * 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.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

/**
 * Entity collection with the following approach:  a size (number of children)
 * and a prototypical child are assigned.  The prototype child is cloned
 * <code>size</code> times, and these clones become the indexed child entities.
 */
public class EntityArray extends EntityCollectionSupport implements
        IndexedEntityCollection {
    private static final long serialVersionUID = 8716199462287161060L;

    private int size = -1;
    private int minimumSize = 0;
    private int maximumSize = Integer.MAX_VALUE;
    private boolean resizable = false;
    private List<Entity> children;
    private Entity prototype;

    /**
     * Create a new EntityArray.
     */
    public EntityArray() {
        // default constructor
    }

    /**
     * Create a new IndexedEntityCollection.
     * @param size number of occurrences of the prototypical Entity
     */
    public EntityArray(int size) {
        setSize(size);
    }

    /**
     * Create a new EntityArray with the specified prototype.
     * @param prototype Entity
     */
    public EntityArray(Entity prototype) {
        setPrototype(prototype);
    }

    /**
     * Create a new IndexedEntityCollection.
     * @param prototype Entity
     * @param size number of occurrences
     */
    public EntityArray(Entity prototype, int size) {
        this(prototype);
        setSize(size);
    }

    /**
     * {@inheritDoc}
     */
    public Entity getChild(int index) {
        initialize();
        return (Entity) children.get(index);
    }

    /**
     * {@inheritDoc}
     */
    public synchronized Collection<Entity> getChildren() {
        initialize();
        return Collections.unmodifiableCollection(children);
    }

    /**
     * Get the prototype.
     * @return Entity.
     */
    public synchronized Entity getPrototype() {
        return prototype;
    }

    /**
     * Set the prototype.
     * @param prototype The Entity prototype to set.
     */
    public synchronized void setPrototype(Entity prototype) {
        if (prototype == null) {
            throw new IllegalArgumentException("prototype Entity was null");
        }
        this.prototype = prototype;
    }

    /**
     * {@inheritDoc}
     * @throws IllegalArgumentException if <code>size</code> is not valid.
     */
    public synchronized void setSize(int size) {
        if (this.size >= 0 && !isResizable()) {
            if (size == this.size()) {
                return;
            }
            throw new IllegalStateException("size already set");
        }
        if (size < minimumSize || size > maximumSize) {
            throw new IllegalArgumentException("illegal collection size: "
                    + size + "; should be <= " + maximumSize + " and >= "
                    + minimumSize);
        }
        this.size = size;
    }

    /**
     * {@inheritDoc}
     */
    public synchronized int size() {
        return size;
    }

    /**
     * {@inheritDoc}
     */
    public synchronized boolean isSizable() {
        return size == -1 || isResizable();
    }

    /**
     * Clone this EntityArray.
     * @return new EntityArray
     */
    @Override
    public synchronized EntityArray clone() {
        EntityArray result = (EntityArray) super.clone();
        if (children != null) {
            result.children = new ArrayList<Entity>();
            for (Entity e : children) {
                result.children.add(e.clone());
            }
        }
        return result;
    }

    /**
     * Initialize this EntityArray.
     */
    private synchronized void initialize() {
        if (children != null) {
            return;
        }
        if (size < 0) {
            throw new IllegalStateException("EntityArray size not set");
        }
        if (size == 0) {
            children = Collections.<Entity>emptyList();
            return;
        }
        if (prototype == null) {
            throw new IllegalStateException("Prototype child entity not set");
        }
        children = new ArrayList<Entity>(size);
        adjustSize();
    }

    /**
     * Adjust the size of this EntityArray.
     */
    private synchronized void adjustSize() {
        if (children.size() > size) {
            children.subList(size, children.size()).clear();
            return;
        }
        for (int i = children.size(); i < size; i++) {
            children.add(prototype.clone());
        }
    }

    /**
     * Get the int maximumSize.
     * @return int
     */
    public synchronized int getMaximumSize() {
        return maximumSize;
    }

    /**
     * Set the int maximumSize.
     * @param maximumSize int
     */
    public synchronized void setMaximumSize(int maximumSize) {
        if (maximumSize > Integer.MAX_VALUE || maximumSize < getMinimumSize()) {
            throw new IllegalArgumentException(Integer.toString(maximumSize));
        }
        this.maximumSize = maximumSize;
    }

    /**
     * Get the int minimumSize.
     * @return int
     */
    public synchronized int getMinimumSize() {
        return minimumSize;
    }

    /**
     * Set the int minimumSize.
     * @param minimumSize int
     */
    public synchronized void setMinimumSize(int minimumSize) {
        if (minimumSize < 0 || minimumSize > getMaximumSize()) {
            throw new IllegalArgumentException(Integer.toString(minimumSize));
        }
        this.minimumSize = minimumSize;
    }

    /**
     * Get the boolean resizable.
     * @return boolean
     */
    public boolean isResizable() {
        return resizable;
    }

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

}