package Simulator;

/**
  * Portions of an ordered list are implemented.
  * Duplicate items are allowed in the list.
  * A dynamic implementation is employed.
*/
public class OrderedList {
    // Fields
    protected int numElements;
    protected Node first;

    // Constructor
    public OrderedList() {
        first = null;
        numElements = 0;
    }

    // Commands
    public void insert (TimeCompare element) {
        if (numElements == 0) {
            Node newNode = new Node (element, null);
            first = newNode;
            numElements = 1;
        }
        else if (element.equalOrGreaterThan (backItem()))
        {//(element.isGreaterThan(backItem()))
            insertBack (element);
        }
        else {
            Node current = first;
            while (current != null && current.item.equalOrLessThan (element))
                current = current.next;
            insertBefore (current.item, element);
        }
    }

    public void removeFront () {
        first = first.next;
        numElements--;
    }

    // Other commands not included

    // Queries
    public TimeCompare frontItem () {
        if (numElements > 0)
            return first.item;
        else
            return null;
    }

    public int getNumElements() {
        return numElements;
    }

    // Other queries not included

    // For internal use
    protected TimeCompare backItem () {
        Node previous = first;
        while (previous.next != null)
            previous = previous.next;
        return previous.item;
    }

    protected Node backNode () {
        Node previous = first;
        while (previous.next != null)
            previous = previous.next;
        return previous;
    }

    protected Node nodeBefore (TimeCompare element) {
        Node previous = first;
        while (previous.next.item.isEqualTo (element) == false)
            previous = previous.next;
        return previous;
    }

    protected Node getNode (TimeCompare element) {
        Node node = first;
        while (node != null) {
            if (node.item.isEqualTo (element))
                return node;
            node = node.next;
        }
        return null;
    }

    protected void insertBack (TimeCompare element) {
        Node newNode, backNode;
        newNode = new Node (element, null);
        if (numElements > 0) {
            backNode = backNode();
            backNode.next = newNode;
        }
        if (numElements == 0)
            first = newNode;
        numElements++;
    }

    protected void insertBefore (TimeCompare before, TimeCompare element) {
        Node newNode, itemNode, beforeNode;
        itemNode = getNode (before);
        newNode = new Node (element, itemNode);
        if (first == itemNode)
            first = newNode;
        else {
            beforeNode = nodeBefore (itemNode.item);
            beforeNode.next = newNode;
        }
        numElements++;
    }

    /**
      * An inner class that is only available to OrderedList
    */
    private class Node {
        public TimeCompare item;
        public Node next;

        public Node (TimeCompare value, Node link) {
            item = value;
            next = link;
        }
    }
}