// Exercise 4.3.36
package algs13;
import stdlib.*;
import java.util.Iterator;
public class MyRandomQueue<T> implements Iterable<T> {

	/** Create an empty random queue. */
	public MyRandomQueue () {}

	/** Is it empty? */
	public boolean isEmpty () {
		return true;
	}

	/** Return the number of elements. */
	public int size () {
		return 0;
	}

	/** Add an item. */
	public void enqueue (T item) {}

	/** Return (but do not remove) a random item. */
	public T sample () {
		return null;
	}

	/** Remove and return a random item. */
	public T dequeue () {
		return null;
	}

	/** Return an iterator over the items in random order. */
	public Iterator<T> iterator () {
		return new QueueIterator ();
	}

	// an iterator, doesn't implement remove() since it's optional
	private class QueueIterator implements Iterator<T> {
		public boolean hasNext () { return false; }
		public T next () { return null; }
		public void remove () {}
	}

	// Test code from https://blog.itu.dk/BADS-F2011/2011/02/10/programming-exercise-3-randomqueue/
	public static void main (String args[]) {
		int NUMROLLS = 10000;
		// Build a queue containing the Integers 1,2,...,6:
		MyRandomQueue<Integer> q1 = new MyRandomQueue<> ();
		for (int i = 1; i < 7; ++i)
			q1.enqueue (i); // autoboxing! cool!

		// Print 30 die rolls to standard output
		StdOut.print ("Some die rolls: ");
		for (int i = 1; i < 30; ++i)
			StdOut.print (q1.sample () + " ");
		StdOut.println ();

		// Let's be more serious: do they really behave like die rolls?
		int[] rolls = new int[NUMROLLS];
		for (int i = 0; i < NUMROLLS; ++i)
			rolls[i] = q1.sample (); // autounboxing! Also cool!
		StdOut.format ("Mean (should be around 3.5): %5.4f\n", StdStats.mean (rolls));
		StdOut.format ("Standard deviation (should be around 1.7): %5.4f\n", StdStats.stddev (rolls));

		// Let's look at the iterator. First, we make a queue of colours:
		MyRandomQueue<String> q2 = new MyRandomQueue<> ();
		q2.enqueue ("red");
		q2.enqueue ("blue");
		q2.enqueue ("green");
		q2.enqueue ("yellow"); //q2.print ();
		q2.dequeue (); //q2.print ();
		q2.dequeue (); //q2.print ();
		q2.enqueue ("purple"); //q2.print ();
		q2.enqueue ("orange"); //q2.print ();

		Iterator<String> it1 = q2.iterator ();
		Iterator<String> it2 = q2.iterator ();

		StdOut.print ("Two colours from first shuffle: ");
		StdOut.print (it1.next () + " ");
		StdOut.print (it1.next () + " ");

		StdOut.print ("\nEntire second shuffle: ");
		while (it2.hasNext ())
			StdOut.print (it2.next () + " ");

		StdOut.print ("\nRemaining two colours from first shuffle: ");
		StdOut.print (it1.next () + " ");
		StdOut.println (it1.next ());

		Stopwatch s = new Stopwatch ();
		int[][] irolls = new int[6][NUMROLLS];
		for (int i = 0; i < NUMROLLS; ++i) {
			Iterator<Integer> it3 = q1.iterator ();
			for (int j = 0; j < 6; j++)
				irolls[j][i] = it3.next ();
		}
		StdOut.format ("Elapsed time: %5.4f\n", s.elapsedTime ());
		for (int j = 0; j < 6; j++) {
			StdOut.format ("Mean (should be around 3.5): %5.4f\n", StdStats.mean (irolls[j]));
			StdOut.format ("Standard deviation (should be around 1.7): %5.4f\n", StdStats.stddev (irolls[j]));
		}
	}

}