package algs13;
import stdlib.*;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.NoSuchElementException;
/* ***********************************************************************
 *  Compilation:  javac ResizingArray.java
 *  Execution:    java ResizingArray < input.txt
 *************************************************************************/

public class ResizingArray<T> implements Iterable<T> {
  private T[] a;
  private int N;
  private long opcount;

  @SuppressWarnings("unchecked")
  public ResizingArray(int initialCapacity) {
    this.N = 0;
    this.a = (T[]) new Object[initialCapacity];
  }
  public ResizingArray()                       { this (4); }
  public ResizingArray(Iterable<T> collection) { this (); addAll (collection); }
  public ResizingArray(T[] array)              { this (); addAll (array); }

  public int size() { return N;  }

  @SuppressWarnings("unchecked")
  public void ensureCapacity(int minCapacity) {
    opcount++;
    if (minCapacity > a.length) {
      int newCapacity = Math.max (minCapacity, a.length*2);
      T[] temp = (T[]) new Object[newCapacity];
      for (int i = a.length - 1; i >= 0; i--) temp[i] = a[i];
      a = temp;
    }
  }

  public void set(int index, T item) {
    if (index >= N) throw new Error ();
    opcount++;
    a[index] = item;
  }
  public void add(T item) {
    ensureCapacity(N+1);
    a[N++] = item;
  }
  public void addAll(Iterable<T> collection) {
    for (T item : collection) {
      ensureCapacity(N+1);
      a[N] = item;
      N++;
    }
  }
  public void addAll(T[] array) {
    int newSize = N + array.length;
    ensureCapacity(newSize);
    for (int i = 0; i < array.length ; i++) {
      a[i+N] = array[i];
    }
    N = newSize;
  }



  public Iterator<T> iterator()  { return new ArrayIterator(); }
  private class ArrayIterator implements Iterator<T> {
    private int index = 0;
    private long oc = opcount;

    public boolean hasNext()  { return index < N; }
    public void remove()      { throw new UnsupportedOperationException();  }
    public T next() {
      if (opcount != oc) throw new ConcurrentModificationException ();
      if (!hasNext()) throw new NoSuchElementException();
      T item = a[index];
      index++;
      return item;
    }
  }

  public String toString () {
    if (N == 0) return "[]";
    StringBuilder sb = new StringBuilder ("[");
    sb.append (N + "/" + a.length + ":");
    sb.append (a[0]);
    for (int i = 1; i < N; i++) {
      sb.append (" ");
      sb.append (a[i]);
    }
    sb.append ("]");
    return sb.toString ();
  }

  public static void main(String[] args) {
    ResizingArray<Integer> a = new ResizingArray<>();
    for (int i=0; i<10; i++) {
      a.add (StdRandom.uniform(100));
      StdOut.println (a);
    }
    a.set (1, 5);
    StdOut.println (a);
    a.addAll (new Integer[] { 1, 2, 3, 4, 5 });
    StdOut.println (a);
    Queue<Integer> q = new Queue<>();
    for (int i = 1; i < 6; i++)
      q.enqueue (i);
    a.addAll (q);
    StdOut.println (a);
  }
}