#include "linkedlist.h"
#include "node.h"
#include <string>


/*
    brief construtor de LinkedList usando template
    @return   LinkedList<T>
*/
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;
}


/*
    brief Destrutor do Objeto LinkedList usando template
*/

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;
}

/*
    @brief get da variavel quantity usando template
    @return  quantidade de elementos na lista
*/
template <class T>
int LinkedList<T>::getQuantity(void) {
    return this->quantity;
}


/*
    @brief método que verifica se a lista está vazia
    @return  true se a lista estiver vazia e false se estiver com elementos nela
*/

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


/*
    @brief Get da variavel head usando template
    @return  ponteiro que aponta para o primeiro elemento da lista
*/
template <class T>
Node<T>* LinkedList<T>::getHead(void) {
    return this->head;
}


/*
    @brief Get da variavel tail usando template
    @return  ponteiro que aponta para o ultimo elemento da lista
*/
template <class T>
Node<T>* LinkedList<T>::getTail(void) {
    return this->tail;
}


/*
    @brief Função que retorna o elemento de acordo com o indice dado no parametro
    @param i - indice do valor do nó a ser buscado
    @return  valor do nó
*/
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;
}


/*
    @brief Função que busca um elemento na lista a partir de seu conteudo
    @param node_content - elemento a ser buscado na lista
    @return  indice do elemento que está sendo pesquisado
*/
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;
}


/*
    @brief Função que imprime os elementos da lista
*/
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;
}


/*
    @brief Função que insere um elemento no inicio da lista
    @param node_content - elemento a ser inserido na lista
    @return  true se foi inserido com sucesso e false se a inserção não acontecer
*/
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;
}

/*
    @brief Função que insere um elemento no fim da lista
    @param node_content - elemento a ser inserido na lista
    @return  true se foi inserido com sucesso e false se a inserção não acontecer
*/

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;
}


/*
    @brief Função que insere um elemento na lista de acordo com o indice colocado no parametro
    @param i - indice no qual o elemento será inserido na lista
            s - elemento a ser inserido na lista
    @return  true se foi inserido com sucesso e false se a inserção não acontecer
*/
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;
}



/*
    @brief Função que remove o ultimo elemento da lista
    @return  elemento que foi removido
*/
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;
}


/*
    @brief Função que remove o primeiro elemento da lista
    @return  elemento que foi removido
*/
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;

}


/*
    @brief Função que remove um elemento na lista de acordo com o indice colocado no parametro
    @param i - indice no qual o elemento será removido na lista
    @return  elemento que foi removido
*/
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 "";
}