/*
 * 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
 *
 *      https://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.collections4.iterators;

import java.util.Iterator;
import java.util.NoSuchElementException;

import org.apache.commons.collections4.ResettableIterator;

/**
 * An {@link Iterator Iterator} over an array of objects.
 * <p>
 * This iterator does not support {@link #remove}, as the object array cannot be
 * structurally modified.
 * </p>
 * <p>
 * The iterator implements a {@link #reset} method, allowing the reset of the iterator
 * back to the start if required.
 * </p>
 *
 * @param <E> The type of elements returned by this iterator.
 * @since 3.0
 */
public class ObjectArrayIterator<E> implements ResettableIterator<E> {

    /** The array */
    final E[] array;

    /** The start index to loop from */
    final int startIndex;

    /** The end index to loop to */
    final int endIndex;

    /** The current iterator index */
    int index;

    /**
     * Constructs an ObjectArrayIterator that will iterate over the values in the
     * specified array.
     *
     * @param array The array to iterate over
     * @throws NullPointerException if {@code array} is {@code null}
     */
    public ObjectArrayIterator(final E... array) {
        this(array, 0, array.length);
    }

    /**
     * Constructs an ObjectArrayIterator that will iterate over the values in the
     * specified array from a specific start index.
     *
     * @param array  The array to iterate over
     * @param start  The index to start iterating at
     * @throws NullPointerException if {@code array} is {@code null}
     * @throws IndexOutOfBoundsException if the start index is out of bounds
     */
    public ObjectArrayIterator(final E[] array, final int start) {
        this(array, start, array.length);
    }

    /**
     * Constructs an ObjectArrayIterator that will iterate over a range of values
     * in the specified array.
     *
     * @param array  The array to iterate over
     * @param start  The index to start iterating at
     * @param end  The index (exclusive) to finish iterating at
     * @throws IndexOutOfBoundsException if the start or end index is out of bounds
     * @throws IllegalArgumentException if end index is before the start
     * @throws NullPointerException if {@code array} is {@code null}
     */
    public ObjectArrayIterator(final E[] array, final int start, final int end) {
        if (start < 0) {
            throw new ArrayIndexOutOfBoundsException("Start index must not be less than zero");
        }
        if (end > array.length) {
            throw new ArrayIndexOutOfBoundsException("End index must not be greater than the array length");
        }
        if (start > array.length) {
            throw new ArrayIndexOutOfBoundsException("Start index must not be greater than the array length");
        }
        if (end < start) {
            throw new IllegalArgumentException("End index must not be less than start index");
        }
        this.array = array;
        startIndex = start;
        endIndex = end;
        index = start;
    }

    /**
     * Gets the array that this iterator is iterating over.
     *
     * @return The array this iterator iterates over
     */
    public E[] getArray() {
        return array;
    }

    /**
     * Gets the end index to loop to.
     *
     * @return The end index
     */
    public int getEndIndex() {
        return endIndex;
    }

    /**
     * Gets the start index to loop from.
     *
     * @return The start index
     */
    public int getStartIndex() {
        return startIndex;
    }

    /**
     * Returns true if there are more elements to return from the array.
     *
     * @return true if there is a next element to return
     */
    @Override
    public boolean hasNext() {
        return index < endIndex;
    }

    /**
     * Returns the next element in the array.
     *
     * @return The next element in the array
     * @throws NoSuchElementException if all the elements in the array
     *    have already been returned
     */
    @Override
    public E next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        return array[index++];
    }

    /**
     * Always throws {@link UnsupportedOperationException}.
     *
     * @throws UnsupportedOperationException Always thrown.
     */
    @Override
    public void remove() {
        throw new UnsupportedOperationException("remove() method is not supported for an ObjectArrayIterator");
    }

    /**
     * Resets the iterator back to the start index.
     */
    @Override
    public void reset() {
        index = startIndex;
    }

}