package DataStructures.DynamicArray;

import java.util.*;
import java.util.function.Consumer;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

/**
 * This class implements a dynamic array
 *
 * @param <E> the type that each index of the array will hold
 */
public class DynamicArray<E> implements Iterable<E> {
	private static final int DEFAULT_CAPACITY = 16;

	private int capacity;
	private int size;
	private Object[] elements;

	/**
	 * constructor
	 *
	 * @param capacity the starting length of the desired array
	 */
	public DynamicArray(final int capacity) {
		this.size = 0;
		this.capacity = capacity;
		this.elements = new Object[this.capacity];
	}

	/**
	 * No-args constructor
	 */
	public DynamicArray() {
		this(DEFAULT_CAPACITY);
	}

	/**
	 * Adds an element to the array If full, creates a copy array twice the size of the current one
	 *
	 * @param element the element of type <E> to be added to the array
	 */
	public void add(final E element) {
		if (this.size == this.elements.length) {
			this.elements = Arrays.copyOf(this.elements, newCapacity(2 * this.capacity));
		}

		this.elements[this.size] = element;
		size++;
	}

	/**
	 * Places element of type <E> at the desired index
	 *
	 * @param index the index for the element to be placed
	 * @param element the element to be inserted
	 */
	public void put(final int index, E element) {
		this.elements[index] = element;
	}

	/**
	 * get method for element at a given index returns null if the index is empty
	 *
	 * @param index the desired index of the element
	 * @return <E> the element at the specified index
	 */
	public E get(final int index) {
		return getElement(index);
	}

	/**
	 * Removes an element from the array
	 *
	 * @param index the index of the element to be removed
	 * @return <E> the element removed
	 */
	public E remove(final int index) {
		final E oldElement = getElement(index);
		fastRemove(this.elements, index);

		if (this.capacity > DEFAULT_CAPACITY && size * 4 <= this.capacity)
			this.elements = Arrays.copyOf(this.elements, newCapacity(this.capacity / 2));
		return oldElement;
	}

	/**
	 * get method for size field
	 *
	 * @return int size
	 */
	public int getSize() {
		return this.size;
	}

	/**
	 * isEmpty helper method
	 *
	 * @return boolean true if the array contains no elements, false otherwise
	 */
	public boolean isEmpty() {
		return this.size == 0;
	}

	public Stream<E> stream() {
		return StreamSupport.stream(spliterator(), false);
	}

	private void fastRemove(final Object[] elements, final int index) {
		final int newSize = this.size - 1;

		if (newSize > index) {
			System.arraycopy(elements, index + 1, elements, index, newSize - index);
		}

		elements[this.size = newSize] = null;
	}

	private E getElement(final int index) {
		return (E) this.elements[index];
	}

	private int newCapacity(int capacity) {
		this.capacity = capacity;
		return this.capacity;
	}

	/**
	 * returns a String representation of this object
	 *
	 * @return String a String representing the array
	 */
	@Override
	public String toString() {
		return Arrays.toString(Arrays.stream(this.elements).filter(Objects::nonNull).toArray());
	}

	/**
	 * Creates and returns a new Dynamic Array Iterator
	 *
	 * @return Iterator a Dynamic Array Iterator
	 */
	@Override
	public Iterator iterator() {
		return new DynamicArrayIterator();
	}

	private class DynamicArrayIterator implements Iterator<E> {

		private int cursor;

		@Override
		public boolean hasNext() {
			return this.cursor != size;
		}

		@Override
		public E next() {
			if (this.cursor > DynamicArray.this.size) throw new NoSuchElementException();

			if (this.cursor > DynamicArray.this.elements.length)
				throw new ConcurrentModificationException();

			final E element = DynamicArray.this.getElement(this.cursor);
			this.cursor++;

			return element;
		}

		@Override
		public void remove() {
			if (this.cursor < 0) throw new IllegalStateException();

			DynamicArray.this.remove(this.cursor);
			this.cursor--;
		}

		@Override
		public void forEachRemaining(Consumer<? super E> action) {
			Objects.requireNonNull(action);

			for (int i = 0; i < DynamicArray.this.size; i++) {
				action.accept(DynamicArray.this.getElement(i));
			}
		}
	}

	/**
	 * This class is the driver for the DynamicArray<E> class it tests a variety of methods and prints
	 * the output
	 */
	public static void main(String[] args) {
		DynamicArray<String> names = new DynamicArray<>();
		names.add("Peubes");
		names.add("Marley");

		for (String name : names) {
			System.out.println(name);
		}

		names.stream().forEach(System.out::println);

		System.out.println(names);

		System.out.println(names.getSize());

		names.remove(0);

		for (String name : names) {
			System.out.println(name);
		}
	}
}