package DataStructures.DynamicArray;

import java.util.Arrays;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.function.Consumer;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

public class DynamicArray<E> implements Iterable<E> {

 private int capacity = 10;

 private int size = 0;

 private Object[] elements;

 public DynamicArray(final int capacity) {
 this.capacity = capacity;
 this.elements = new Object[this.capacity];
 }

 public DynamicArray() {
 this.elements = new Object[this.capacity];
 }

 public int newCapacity() {
 this.capacity <<= 1;

 return this.capacity;
 }

 public void add(final E element) {
 if (this.size == this.elements.length)
 this.elements = Arrays.copyOf(this.elements, newCapacity());

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

 public void put(final int index, E element) {
// Objects.checkIndex(index, this.size);

 this.elements[index] = element;
 }

 public E get(final int index) {
 return getElement(index);
 }

 public E remove(final int index) {
 final E oldElement = getElement(index);
 fastRemove(this.elements, index);

 return oldElement;
 }

 public int size() {
 return this.size;
 }

 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) {
// Objects.checkIndex(index, this.size);
 return (E) this.elements[index];
 }

 @Override
 public String toString() {
 return Arrays.toString(Arrays.stream(this.elements).filter(Objects::nonNull).toArray());
 }

 @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));
 }
 }
 }

 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.size());

 names.remove(0);

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