// CSE 143, Summer 2016
//
// Practice with Stacks and Queues

import java.util.*;

public class MondayPractice {
  public static void main(String[] args) {
    Stack<Integer> numbers = new Stack<Integer>();
    
    for (int i = 1; i <= 6; i++) {
      numbers.add(i * 3);
    }
    
    System.out.println("numbers: " + numbers);
    System.out.println("sum: " + sum(numbers));
    System.out.println("numbers: " + numbers);
  }
  
  // pre : numbers is not null
  // post: returns the sum of all numbers in the stack
  //
  // Methods in Stack
  //   push
  //   pop
  //   isEmpty
  //   size
  public static int sum(Stack<Integer> numbers) {
    // A stack would be an easier temp structure to use here.
    // We're going to take a harder route and use a queue.
    Queue<Integer> temp = new LinkedList<Integer>();
    int sum = 0;
    int size = numbers.size();
    for (int i = 0; i < size; i++) {
      int num = numbers.pop();
      sum += num;
      temp.add(num);
    }
    // now everything is in our temporary queue
    // I encourage you to play around with this!
    System.out.println("current queue: " + temp);
    System.out.println("current stack: " + numbers);
    queueToStack(temp, numbers);
    // if we stop here, our stack is reversed!
    System.out.println("current queue: " + temp);
    System.out.println("current stack: " + numbers);
    stackToQueue(numbers, temp);
    System.out.println("current queue: " + temp);
    System.out.println("current stack: " + numbers);
    queueToStack(temp, numbers);
    // now we're golden
    return sum;
  }
  
  // pre : numbers is not null
  // post: returns the sum of all numbers in the queue
  //
  // Methods in Queue
  //   add
  //   remove
  //   size
  //   isEmpty
  public static int sum(Queue<Integer> numbers) {
    // does not destroy the queue!
    int sum = 0;
    int size = numbers.size();
    for (int i = 0; i < size; i++) {
      int num = numbers.remove();
      sum += num;
      // here we can just add it to the back, no problem!
      numbers.add(num);
    }
    return sum;
  }

  // Moves everything in the stack to the queue.
  public static void stackToQueue(Stack<Integer> stack,
      Queue<Integer> queue) {
    while (!stack.isEmpty()) {
      queue.add(stack.pop());
    }
  }
  
  // Moves everything in the queue to the stack.
  public static void queueToStack(Queue<Integer> queue,
      Stack<Integer> stack) {
    while (!queue.isEmpty()) {
      stack.push(queue.remove());
    }
  }

}