#include "linkedlist.h"

template <class T>
LinkedList<T>::LinkedList(){
    this->head = new Node<T>();
    this->tail = new Node<T>();

    this->head->setNext(this->tail);
    this->head->setPrevious(NULL);

    this->tail->setNext(NULL);
    this->tail->setPrevious(this->head);

    this->quantity = 0;
}

template <class T>
LinkedList<T>::~LinkedList(){
    Node<T>* no = this->head;
    while(no != this->tail){
        Node<T>* toDestroy = no;
        no = no->getNext();
        delete toDestroy;
    }

    delete this->tail;
}

template <class T>
int LinkedList<T>::getQuantity(void) {
    return this->quantity;
}

template <class T>
bool LinkedList<T>::isEmpty(void) {
    return this->quantity == 0;
}

template <class T>
Node<T>* LinkedList<T>::getHead(void) {
    return this->head;
}

template <class T>
Node<T>* LinkedList<T>::getTail(void) {
    return this->tail;
}


template <class T>
T LinkedList<T>::get(int i) {
    int count = 1;
    T result;
    for(Node<T>* no = this->head->getNext(); no != this->tail; no = no->getNext()){
        if( i == count ){
            result = no->getValue();
            break;
        }
        count++;
    }
    return result;
}

template <class T>
int LinkedList<T>::search(T node_content) {
    int count = 1;

    for(Node<T>* no = this->head->getNext(); no != this->tail; no = no->getNext()) {
        T value = no->getValue();
        if( no == value )
        {
            return count;
        }
        count++;
    }
    return -1;
}

template <class T>
void LinkedList<T>::print(void) {
    for(Node<T>* no = this->head->getNext(); no != this->tail; no = no->getNext())
    {
        std::cout << no->getValue() << " ";
    }
    std::cout << std::endl;
}

template <class T>
bool LinkedList<T>::insertBegin(T node_content) {

    Node <T>* no = this->getHead();
    Node <T>* new_no = new Node<T>(node_content);

    new_no->setNext(no->getNext());
    new_no->setPrevious(no);
    new_no->getNext()->setPrevious(new_no);
    new_no->getPrevious()->setNext(new_no);
    quantity++;

    return true;
}

template <class T>
bool LinkedList<T>::insertEnd(T node_content)
{
    Node <T>* no = this->getTail();
    Node <T>* new_no = new Node<T>(node_content);

    new_no->setNext(no);
    new_no->setPrevious(no->getPrevious());
    new_no->getNext()->setPrevious(new_no);
    new_no->getPrevious()->setNext(new_no);
    quantity++;
    return true;
}

template <class T>
bool LinkedList<T>::insert(int i, T s)
{
    int y = 0;
    Node <T>* x = new Node<T>(s) ;
    Node<T>* n = this->getHead();
        while (y != i){
            if(n == this->getTail()){
                return false;
            }else{
                n = n->getNext();
                y++;
            }
        }
        if( i == y){
        x->setNext(n);
        x->setPrevious(n->getPrevious());
        n->setPrevious(x);
        n->getPrevious()->getPrevious()->setNext(x);

        quantity++;
        return true;
       }
      return false;
}



template <class T>
T LinkedList<T>::removeEnd(void) {
    T no_toremove;
    Node<T>* no ;
    no = this->getTail()->getPrevious();
    no_toremove = no->getValue();
    this->getTail()->setPrevious(this->getTail()->getPrevious()->getPrevious() );
    this->getTail()->getPrevious()->setNext(this->getTail());

    quantity--;
    delete no;
    return no_toremove;
}

template <class T>
T LinkedList<T>::removeBegin(void) {
    T no_toremove;
    Node<T>* no ;
    no = this->getHead()->getNext();
    no_toremove = no->getValue();
    this->getHead()->setNext(this->getHead()->getNext()->getNext() );
    this->getHead()->getNext()->setPrevious(this->getHead());
    quantity--;

    delete no;
    return no_toremove;

}

template <class T>
T LinkedList<T>::remove(int indice) {
    int count = 0;

    Node<T>* n = this->getHead();
        while (count != indice){
                n = n->getNext();
                count++;
        }
        if( indice == count){
        T valor = n->getValue();
        n->getNext()->setPrevious(n->getPrevious());
        n->getPrevious()->setNext(n->getNext());
        quantity--;
        delete n;
        return valor;
       }
       return "";
}