#ifndef LINKEDLIST_CPP
#define LINKEDLIST_CPP

#include "node.cpp"
#include <cstdlib>
#include <cassert>

template <typename T>
class LinkedList{
public:
  LinkedList(){
    head = NULL;
  }


  ~LinkedList(){
    clear();
  }

  LinkedList(const LinkedList<T>& rhs){
    *this = rhs; // why reinvent the wheel... just use the = operator :) 
  }

  const LinkedList<T>& operator=(const LinkedList<T>& rhs){
    if( this != &rhs ){
      clear();  // release the memory of the current linked list
    
      if( rhs.head == NULL ){
	head = NULL;
      }else{
	head = new Node<T>(rhs.head->value());

	Node<T>* finger = rhs.head->next();
	Node<T>* current = head;

	while( finger != NULL ){
	  current->setNext(new Node<T>(finger->value()));
	  current = current->next();
	  finger = finger->next();
	}
      }
    }

    return *this;
  }
  
  T& operator[](unsigned int index){
    Node<T>* finger = head;

    for( int i = 0; i < index && head != NULL; i++ ){
      finger = finger->next();
    }

    assert(finger != NULL);

    return finger->modValue();
  }

void addFirst(T value){
  head = new Node<T>(value, head);
}

  T removeFirst(){
    assert(head != NULL);

    T returnMe = head->value();
    Node<T>* oldHead = head;
    head = head->next();
    delete oldHead;
    return returnMe;
  }


  T getFirst() const{
    return head->value();
  }
 

  bool contains(T value) const{
    Node<T>* finger = head;

    while( finger != NULL && finger->value() != value ){
      finger = finger->next();
    }
    
    return finger != NULL;
  }


  void set(int index, T value){
    Node<T>* finger = head;

    for( int i = 0; i < index && head != NULL; i++ ){
      finger = finger->next();
    }
    
    if( finger != NULL ){
      finger->setValue(value);
    }
  }

  void clear(){
    while( !isEmpty() ){
      removeFirst();
    }
  }

  bool isEmpty(){
    return head == NULL;
  }

private:
  Node<T>* head;
};
#endif