package hw4;

import java.util.Iterator;
import java.util.Stack;

/**
 * <b>RatPolyStack</B> is a mutable finite sequence of RatPoly objects.
 * <p>
 * Each RatPolyStack can be described by [p1, p2, ... ], where [] is an empty
 * stack, [p1] is a one element stack containing the Poly 'p1', and so on.
 * RatPolyStacks can also be described constructively, with the append
 * operation, ':'. such that [p1]:S is the result of putting p1 at the front of
 * the RatPolyStack S.
 * <p>
 * A finite sequence has an associated size, corresponding to the number of
 * elements in the sequence. Thus the size of [] is 0, the size of [p1] is 1,
 * the size of [p1, p1] is 2, and so on.
 * <p>
 */
public final class RatPolyStack implements Iterable<RatPoly> {

  private final Stack<RatPoly> polys;

  // Abstraction Function:
  // Each element of a RatPolyStack, s, is mapped to the
  // corresponding element of polys.
  //
  // RepInvariant:
  // polys != null &&
  // forall i such that (0 <= i < polys.size(), polys.get(i) != null

  /**
   * @effects Constructs a new RatPolyStack, [].
   */
  public RatPolyStack() {
    polys = new Stack<RatPoly>();
    checkRep();
  }

  /**
   * Returns the number of RayPolys in this RatPolyStack.
   *
   * @return the size of this sequence.
   */
  public int size() {
    // TODO: Fill in this method, then remove the RuntimeException
    throw new RuntimeException("RatPolyStack->size() is not yet implemented");
  }

  /**
   * Pushes a RatPoly onto the top of this.
   *
   * @param p The RatPoly to push onto this stack.
   * @requires p != null
   * @modifies this
   * @effects this_post = [p]:this
   */
  public void push(RatPoly p) {
    // TODO: Fill in this method, then remove the RuntimeException
    throw new RuntimeException("RatPolyStack->push() is not yet implemented");
  }

  /**
   * Removes and returns the top RatPoly.
   *
   * @requires this.size() > 0
   * @modifies this
   * @effects If this = [p]:S then this_post = S
   * @return p where this = [p]:S
   */
  public RatPoly pop() {
    // TODO: Fill in this method, then remove the RuntimeException
    throw new RuntimeException("RatPolyStack->pop() is not yet implemented");
  }

  /**
   * Duplicates the top RatPoly on this.
   *
   * @requires this.size() > 0
   * @modifies this
   * @effects If this = [p]:S then this_post = [p, p]:S
   */
  public void dup() {
    // TODO: Fill in this method, then remove the RuntimeException
    throw new RuntimeException("RatPolyStack->dup() is not yet implemented");
  }

  /**
   * Swaps the top two elements of this.
   *
   * @requires this.size() >= 2
   * @modifies this
   * @effects If this = [p1, p2]:S then this_post = [p2, p1]:S
   */
  public void swap() {
    // TODO: Fill in this method, then remove the RuntimeException
    throw new RuntimeException("RatPolyStack->swap() is not yet implemented");
  }

  /**
   * Clears the stack.
   *
   * @modifies this
   * @effects this_post = []
   */
  public void clear() {
    // TODO: Fill in this method, then remove the RuntimeException
    throw new RuntimeException("RatPolyStack->clear() is not yet implemented");
  }

  /**
   * Returns the RatPoly that is 'index' elements from the top of the stack.
   *
   * @param index The index of the RatPoly to be retrieved.
   * @requires index >= 0 && index < this.size()
   * @return If this = S:[p]:T where S.size() = index, then returns p.
   */
  public RatPoly getNthFromTop(int index) {
    // TODO: Fill in this method, then remove the RuntimeException
    throw new RuntimeException(
        "RatPolyStack->getNthFromTop() unimplemented!\n");
  }

  /**
   * Pops two elements off of the stack, adds them, and places the result on
   * top of the stack.
   *
   * @requires this.size() >= 2
   * @modifies this
   * @effects If this = [p1, p2]:S then this_post = [p3]:S where p3 = p1 + p2
   */
  public void add() {
    // TODO: Fill in this method, then remove the RuntimeException
    throw new RuntimeException("RatPolyStack->add() is not yet implemented");
  }

  /**
   * Subtracts the top poly from the next from top poly, pops both off the
   * stack, and places the result on top of the stack.
   *
   * @requires this.size() >= 2
   * @modifies this
   * @effects If this = [p1, p2]:S then this_post = [p3]:S where p3 = p2 - p1
   */
  public void sub() {
    // TODO: Fill in this method, then remove the RuntimeException
    throw new RuntimeException("RatPolyStack->sub() is not yet implemented");
  }

  /**
   * Pops two elements off of the stack, multiplies them, and places the
   * result on top of the stack.
   *
   * @requires this.size() >= 2
   * @modifies this
   * @effects If this = [p1, p2]:S then this_post = [p3]:S where p3 = p1 * p2
   */
  public void mul() {
    // TODO: Fill in this method, then remove the RuntimeException
    throw new RuntimeException("RatPolyStack->mul() is not yet implemented");
  }

  /**
   * Divides the next from top poly by the top poly, pops both off the stack,
   * and places the result on top of the stack.
   *
   * @requires this.size() >= 2
   * @modifies this
   * @effects If this = [p1, p2]:S then this_post = [p3]:S where p3 = p2 / p1
   */
  public void div() {
    // TODO: Fill in this method, then remove the RuntimeException
    throw new RuntimeException("RatPolyStack->div() is not yet implemented");
  }

  /**
   * Pops the top element off of the stack, differentiates it, and places the
   * result on top of the stack.
   *
   * @requires this.size() >= 1
   * @modifies this
   * @effects If this = [p1]:S then this_post = [p2]:S where p2 = derivative
   *          of p1
   */
  public void differentiate() {
    // TODO: Fill in this method, then remove the RuntimeException
    throw new RuntimeException(
        "RatPolyStack->differentiate() unimplemented!\n");
  }

  /**
   * Pops the top element off of the stack, integrates it, and places the
   * result on top of the stack.
   *
   * @requires this.size() >= 1
   * @modifies this
   * @effects If this = [p1]:S then this_post = [p2]:S where p2 = indefinite
   *          integral of p1 with integration constant 0
   */
  public void integrate() {
    // TODO: Fill in this method, then remove the RuntimeException
    throw new RuntimeException("RatPolyStack->integrate() is not yet implemented");
  }

  /**
   * Returns an iterator of the elements contained in the stack.
   *
   * @return an iterator of the elements contained in the stack in order from
   *         the bottom of the stack to the top of the stack.
   */
  @Override
  public Iterator<RatPoly> iterator() {
    return polys.iterator();
  }

  /**
   * Checks that the representation invariant holds (if any).
   */
  // Throws a RuntimeException if the rep invariant is violated.
  private void checkRep() throws RuntimeException {
    /*assert polys != null: "polys should never be null.";
        for (RatPoly p : polys) {
                assert p != null: "polys should never contain a null element.";
        }*/


    if (polys == null) {
      throw new RuntimeException("polys should never be null.");
    }
    for (RatPoly p : polys) {
      if (p == null) {
        throw new RuntimeException(
            "polys should never contain a null element.");
      }
    }
  }
}