// READ: http://msdn.microsoft.com/en-us/library/6x16t2tx.aspx
        // list [i] = value; i is new list q is old list
        public string this[int i]
        {
            get { return this.ElementAt(i); }
            set {
                var placeHolderList = new SinglyLinkedList();

                for (var q = 0; q < this.Count(); q++)
                {
                   if (q==i)
                    {
                        placeHolderList.AddLast(value);
                    }
                    else
                    {
                        placeHolderList.AddLast(this.ElementAt(q));
                    }
                }

                first_node = new SinglyLinkedListNode(placeHolderList.First());
                for (var w = 1; w < placeHolderList.Count(); w++)
                {
                    this.AddLast(placeHolderList.ElementAt(w));
                }
            }
        }

        public void AddAfter(string existingValue, string value)
        {
            SinglyLinkedListNode CurrentNode = firstNode;
            SinglyLinkedListNode NodeToInsert = new SinglyLinkedListNode(value);
            if (ExistingValueExists(existingValue))
            {
                while (CurrentNode != null)
                {
                    if (CurrentNode.Value == existingValue)
                    {
                        NodeToInsert.Next = CurrentNode.Next;
                        CurrentNode.Next = NodeToInsert;
                        CurrentNode = NodeToInsert;
                    }
                    else
                    {
                        CurrentNode = CurrentNode.Next;
                    }

                }
            }
            else
            {
                throw new ArgumentException();
            }
        }

        // READ: http://msdn.microsoft.com/en-us/library/6x16t2tx.aspx
        public string this[int index]
        {
            get
            {
                return this.ElementAt(index);
            }
            set
            {
                var placeholder = new SinglyLinkedList();
                for(var j = 0; j < this.Count(); j++)
                {
                    if (j == index)
                    {
                        placeholder.AddLast(value);
                    } else
                    {
                        placeholder.AddLast(this.ElementAt(j));
                    }
                }
                first_node = new SinglyLinkedListNode(placeholder.First());

                for(var k = 1; k < placeholder.Count(); k++ )
                {
                    this.AddLast(placeholder.ElementAt(k));
                }
               }
        }

 public void NodeEqualityWithEqualValues()
 {
     SinglyLinkedListNode node1 = new SinglyLinkedListNode("foo");
     SinglyLinkedListNode node2 = new SinglyLinkedListNode("foo");
     Assert.AreEqual(node1, node2); // Equivalent to: Assert.IsTrue(node1.Equals(node2));
     // When you create your own types, you should override Equals. -- quote from the docs
 }

 public void AddAfter(string existingValue, string value)
 {
     /* if (last.Value == existingValue)
     {
         AddLast(value);
     } */
     SinglyLinkedListNode adding = new SinglyLinkedListNode(value);
     SinglyLinkedListNode test = first;
     while (true) {
         if (test == null)
         {
             throw new ArgumentException();
         }
         if (test != null)
         {
             if (test.Value == existingValue)
             {
                 adding.Next = test.Next;
                 test.Next = adding;
                 count++;
                 break;
             }
             test = test.Next;
         }
     }
 }

        // READ: http://msdn.microsoft.com/en-us/library/6x16t2tx.aspx
        public string this[int i]
        {
            get { return this.ElementAt(i); }
            set
            {
                var newList = new SinglyLinkedList();

                for (var x = 0; x < this.Count(); x++)
                {
                    if (x == i)
                    {
                        newList.AddLast(value);
                    }
                    else
                    {
                        newList.AddLast(this.ElementAt(x));
                    }
                }
                    first_node = new SinglyLinkedListNode(newList.First());
                    for (var w = 1; w < newList.Count(); w++)
                {
                    this.AddLast(newList.ElementAt(w));

                }
                }
        }

 public void AddLast(string value)
 {
     SinglyLinkedListNode newNode = new SinglyLinkedListNode(value);
     if (firstNode == null) firstNode = newNode;
     else LastNode().Next = newNode;
     count++;
 }

 public void AddFirst(string value)
 {
     SinglyLinkedListNode newNode = new SinglyLinkedListNode(value);
     newNode.Next = firstNode;
     firstNode = newNode;
     count++;
 }

 public void AddAfter(string existingValue, string value)
 {
     if (ElementAt(-1) == existingValue)
     {
         AddLast(value);
     }
     else
     {
         SinglyLinkedListNode current = firstNode;
         bool found = false;
         while (!current.IsLast())
         {
             if (current.Value == existingValue)
             {
                 SinglyLinkedListNode new_node = new SinglyLinkedListNode(value);
                 SinglyLinkedListNode old_next = current.Next;
                 new_node.Next = old_next;
                 current.Next = new_node;
                 found = true;
                 break;
             }
             current = current.Next;
         }
         if (!found)
         {
             throw new ArgumentException();
         }
     }
 }

        public void AddAfter(string existingValue, string value)
        {
            var node = this.first_node;
            var inputValue = IndexOf(existingValue);
            var value2Add = new SinglyLinkedListNode(value);

            if (IndexOf(existingValue) == -1)
            {
                throw new ArgumentException();
            }

            for (var i = 0; i < this.Count(); i++)
            {

                if (node.Value == existingValue)
                {
                    // gets the index of the found node
                    var foundPosition = node;

                    // set the pointer for the new node
                    value2Add.Next = foundPosition.Next;

                    // set the new value for after foundPosition
                    foundPosition.Next = value2Add;
                }
                else if (!node.IsLast())
                {
                    this.AddLast(value2Add.Value);
                }

                node = new SinglyLinkedListNode(value);
            }
        }

        // READ: http://msdn.microsoft.com/en-us/library/6x16t2tx.aspx
        public string this[int i]
        {
            //uses the ElementAt function to get value (saves you from duplicating your code)
            get { return this.ElementAt(i); }
            set
            {
                //using a placeholder list helps save the values in order without having to do voodoo with the pointers
                var placeholderList = new SinglyLinkedList();
                for (var q = 0; q < this.Count(); q++)
                {
                    //if this is the place where you need to exchange the value, insert it here
                    if (q == i)
                    {
                        placeholderList.AddLast(value);
                    }
                    //otherwise, insert the value that was preexisting in the list
                    else
                    {
                        placeholderList.AddLast(this.ElementAt(q));
                    }
                }

                //now swap out the values in the placeholder list into the real list.
                //first swap the first value to clear out the old list
                first_node = new SinglyLinkedListNode(placeholderList.First());
                //then loop through the placeholder list and add the values to the real list in order
                for (var w = 1; w < placeholderList.Count(); w++)
                {
                    this.AddLast(placeholderList.ElementAt(w));
                }
            }
        }

        // READ: http://msdn.microsoft.com/en-us/library/6x16t2tx.aspx
        public string this[int i]
        {
            get { return this.ElementAt(i); }
            set
            {
                var copy_of_list = new SinglyLinkedList();
                for (var j = 0; j < this.Count(); j++)
                {
                    if (j == i)
                    {
                        copy_of_list.AddLast(value);
                    }
                    else
                    {
                        copy_of_list.AddLast(this.ElementAt(j));
                    }
                }

                first_node = new SinglyLinkedListNode(copy_of_list.First());
                for (var o = 1; o < copy_of_list.Count(); o++)
                {
                    this.AddLast(copy_of_list.ElementAt(o));
                }
            }
        }

 public void NodeLastWhenLast()
 {
     SinglyLinkedListNode node1 = new SinglyLinkedListNode("foo");
     SinglyLinkedListNode node2 = new SinglyLinkedListNode("bar");
     node1.Next = node2;
     Assert.IsFalse(node1.IsLast());
 }

        public void AddAfter(string existingValue, string value)
        {
            if (ElementAt(-1) == existingValue)
            {
                AddLast(value);
            }
            else
            {
                SinglyLinkedListNode prevNode = firstNode;
                bool found = false;
                while (!prevNode.IsLast())
                {
                    if (prevNode.Value == existingValue)
                    {
                        SinglyLinkedListNode newNode = new SinglyLinkedListNode(value);
                        SinglyLinkedListNode oldNext = prevNode.Next;
                        newNode.Next = oldNext;
                        prevNode.Next = newNode;

                        found = true;
                        count++;
                        break;
                    }
                    prevNode = prevNode.Next;
                }

                if (!found)
                {
                    throw new ArgumentException();
                }
            }
        }

 public void NodeEqualityIgnoresNext()
 {
     SinglyLinkedListNode node1 = new SinglyLinkedListNode("foo");
     node1.Next = new SinglyLinkedListNode("bob");
     SinglyLinkedListNode node2 = new SinglyLinkedListNode("foo");
     node2.Next = new SinglyLinkedListNode("sally");
     Assert.AreEqual(node1, node2);
 }

        public SinglyLinkedListNode(string value)
        {
            this.value = value;
            this.next = null;

            // Used by the visualizer:
            allNodes.Add(this);
        }

 // READ: http://msdn.microsoft.com/en-us/library/aa691335(v=vs.71).aspx
 public SinglyLinkedList(params object[] values)
 {
     first = new SinglyLinkedListNode(values[0].ToString());
     int i = 1;
     while (i < values.Length)
     {
         AddLast(values[i].ToString());
         i += 1;
     }
 }

        private string value; // same as this.value

        #endregion Fields

        #region Constructors

        public SinglyLinkedListNode(string input)
        {
            this.value = input;

            // data members default to null, but...
            this.next = null;

            // Used by the visualizer:
            allNodes.Add(this);
        }

        private string value; //same as this.value

        #endregion Fields

        #region Constructors

        public SinglyLinkedListNode(string input)
        {
            this.value = input; //distinguishing between the two named items in this context
                                //don't have to use setter because in same class
            //Initialized data members default to null, but...
            this.next = null;

            // Used by the visualizer:
            allNodes.Add(this);
        }

 // READ: http://msdn.microsoft.com/en-us/library/aa691335(v=vs.71).aspx
 public SinglyLinkedList(params object[] values)
 {
     first = new SinglyLinkedListNode(null);
     if(values.Length != 0)
     {
         for (int i = 0; i < values.Length; i++)
         {
             AddLast(values[i] as string);
         }
     }
 }