// CardLinkedList.java
// Kiri Wagstaff, wkiri@cs.cornell.edu
// August 1, 2001

public class CardLinkedList {
    private CardNode head;

		// Default constructor: creates an empty list
    public CardLinkedList() {
        head = null;
    }

		// length: returns the number of nodes in the list.
    public int length() {
        int count = 0;
        CardNode position = head;
        while (position != null) // the final node links to null
        {
            count++;
            position = position.link;  // go to the next node
        }
        return count;
    }

		// add: inserts the new Card to the head of the list
		//      by creating a new CardNode and linking it in front of head.
    public void add(Card newCard) {
        head = new CardNode(newCard, head); 
    }

		// remove: removes the first Card, and returns it.
		// It's okay to return the card itself here, because Cards
		// have no mutator methods, and at any rate, we're done with it.
    public Card remove() {
        if (head != null) {
        		Card c = head.data;
            head = head.link;
            return c;
        } else {
            System.out.println("Deleting from an empty list? Exiting!");
            System.exit(1);
        }
        return null;
    }

		// inList: returns true if the Card is in the list.
    public boolean inList(Card target)
    {
        return (Find(target) != null);
    }

		// Find: returns the first node containing the Card.
		//       If it's not there, returns null.
		//       This method is private so no one else can get access
		//       to the internal Cards of the list.
    private CardNode Find(Card target)
    {
        CardNode position;
        position = head;
        Card dataAtPosition;
        while (position != null) {
            dataAtPosition = position.data;
            if (dataAtPosition.equals(target)) return position;
            position = position.link;
        }
        return null;
    }

		// toString: return a nice String representation of the list.
    public String toString()
    {
        CardNode position = head;
        if (position == null) return "{}";
        String result = "{ " + position.data;
	      position = position.link;
        while (position != null) {
            result += ", " + position.data;
            position = position.link;
        }
        result += " }";
        return result;
    }

		// This class is private, because no one else should ever
		// need to use it.
    private class CardNode {
        private Card data;     // The stored Card
        private CardNode link; // The next CardNode in the list.

        public CardNode() {
            link = null;
            data = null;
        }

				// Create a CardNode with the specified Card inside it,
				// and link it to linkValue. Make a COPY of the Card.
        public CardNode(Card newData, CardNode linkValue) {
            data = new Card(newData.getValue(), newData.getSuit());
            link = linkValue;
        }
    }


		// Now let's add some other fun stuff to make this more like an array:
		// addAt: insert the Card at the specified index (starting index is 0)
		public void addAt(Card newCard, int index) {
			if (index < 0) {
				// Invalid index
				System.out.println("Index must be positive.");
				return;
			}
			// Handle adding at 0 specially
			if (index == 0) {
				// Just use the regular add method
				add(newCard);
				return;
			}
			CardNode position = head;
			int count = 0;
			// Find the right place to insert the new Card
			while (position != null) {
				// Position is at node number "count"
				if (count == index-1) {
					// Create the new card, and make it point to position's link.
					CardNode temp = new CardNode(newCard, position.link);
					// Now make position's node link up with the new node
					position.link = temp;
					// Done!
					return;
				} else {
					// Keep moving down the list
					position = position.link;
					count++;
				}
			}
			// Uh oh - if we made it here, then the index was too big.  Fail!
			System.out.println("Index " + index + " is too big for this list.");
			return;
		}
		
		// removeFrom: get the Card at the specified index and return it
		//             also, delete it from the list
		public Card removeFrom(int index) {
			if (index < 0) {
				// Invalid index
				System.out.println("Index must be positive.");
				return null;
			}
			// Handle removing from 0 specially
			if (index == 0) {
				// Just use the regular remove method
				return remove();
			}
			CardNode position = head;
			int count = 0;
			// Find the right Card
			while (position != null) {
				// Position is at node number "count"
				if (count == index-1) {
					// Make sure this isn't the last thing in the list.
					// If so, index is invalid.
					if (position.link == null) break;
					// Store the one we want
					Card temp = position.link.data;
					// Fix position's link to skip the one we're removing
					position.link = position.link.link;
					// Return this card
					return temp;
				} else {
					// Keep moving down the list
					position = position.link;
					count++;
				}
			}
			// Uh oh - if we made it here, then the index was too big.  Fail!
			System.out.println("Index " + index + " is too big for this list.");
			return null;
		}
		    
    public static void main(String[] args) {
    	// Test the constructor
    	CardLinkedList cll = new CardLinkedList();
    	System.out.println("New empty list: " + cll);
    	
    	// Test the add() method
    	Card c = new Card(3, "hearts");
    	cll.add(c);
    	System.out.println("Adding " + c + " gives " + cll);
    	cll.add(c);
    	System.out.println("Adding " + c + " gives " + cll);
    	Card c2 = new Card(Card.KING, "spades");
    	cll.add(c2);
    	System.out.println("Adding " + c2 + " gives " + cll);

			// Test the addAt() method
			Card c3 = new Card(Card.QUEEN, "clubs");
			cll.addAt(c3, 2);
    	System.out.println("Adding " + c3 + " at index 2 gives " + cll);
			cll.addAt(c3, 5); // should fail!
    	System.out.println("Adding " + c3 + " at index 5 gives " + cll);
			   
			// Test the inList() method
   		System.out.println(c2 + (cll.inList(c2)? " IS " : " ISN'T ")
   											+ "in the list.");
   											
   		// Test the remove() method
    	Card c4 = cll.remove();
    	System.out.println("Got the first element: " + c4 + ", now it's " + cll);
		
			// Test the removeFrom() method
			Card c5 = cll.removeFrom(2);
    	System.out.println("Removing element 2 gives " + c5 + " and " + cll);
			cll.removeFrom(5); // should fail!
    	System.out.println("Removing element 5 gives " + cll);
    }
}