/**
 *    Como o C++ só suporta templates se a implementação estiver no mesmo 
 * arquivo que a descrição (não pode ter .cpp e .h, só .h), a implementação
 * é feita nos arquivos lista_simples_lib.h e lista_simples_lib.cpp, e esta classe
 * atual somente herda aquela, fazendo os castings.
 */

#ifndef LISTA_SIMPLES_H
#define LISTA_SIMPLES_H

#include <lista_simples_lib.h>

template <class t_class> class Lista_Simples : public Lista_Simples_Lib{
  // Métodos Públicos: Podem ser acessados externamente
public:
  /**
   * Construtores: chamado quando se da o new
   *@param elemento apontador para elemento de qualquer tipo
   */
  Lista_Simples(t_class elemento) {
    Muda_Valor(elemento);
    Aterra_Ponteiro();
  }
  Lista_Simples() : Lista_Simples_Lib() { };
  /**
   * Destrutor: Chamado quando se da o delete
   */
  ~Lista_Simples() {
    if (Lista_Simples_Lib::Valor() != NULL) {
      delete (t_class *)Lista_Simples_Lib::Valor();
      Lista_Simples_Lib::Muda_Valor(NULL);
    }
    if (Proximo() != NULL) {
      delete Proximo();
      Muda_Proximo(NULL);
    }
  };


  /**
   * Procura: procura pelo elemento na lista
   *@param elemento a ser procurado
   *@return nó da lista
   */
  Lista_Simples<t_class> *Procura(t_class elemento) {
    Lista_Simples<t_class> *aux = this;
    while ((aux != NULL) && (aux->Valor() != elemento))
      aux = aux->Proximo();
    return aux;
  };



  /**
   * Add_Depois: adiciona 'elemento' na lista numa posição posterior à atual
   *@param elemento apontador para elemento de qualquer tipo
   */
  void Add_Depois(t_class elemento) {
    t_class *elem = new t_class;
    *elem = elemento;
    Lista_Simples_Lib::Add_Depois(elem);
  };

  /**
   * Remove: o elemento atual é retirado da lista a qual pertencia e é colocado em uma lista que só o contém.
   *@return apontador para a lista sem o elemento atual.
   */
  Lista_Simples<t_class> *Remove() { return (Lista_Simples<t_class>*)Lista_Simples_Lib::Remove(); };

  /**
   * Valor: retorna o elemento atual. Você deverá usar um 'cast' para o tipo original do elemento.
   *@return apontador para o elemento da posição atual da lista
   */
  t_class Valor() { return *(t_class*) Lista_Simples_Lib::Valor(); };

  /**
   * Muda_Valor: muda o elemento atual da lista
   *@param elemento elemento que irá ser colocado na posição atual da lista
   */
  void Muda_Valor(t_class elemento) { 
    t_class *elem = new t_class;
    *elem = elemento;
    if (Lista_Simples_Lib::Valor() != NULL) {
      delete (t_class*)Lista_Simples_Lib::Valor();
      Lista_Simples_Lib::Muda_Valor(NULL);
    }
    Lista_Simples_Lib::Muda_Valor(elem);
  };

  
  /**
   * Acha_Ultimo: retorna o último elemento da lista
   *@return apontador para o último elemento da lista atual
   */
  Lista_Simples<t_class> *Acha_Ultimo() { return (Lista_Simples<t_class> *)  Lista_Simples_Lib::Acha_Ultimo(); };

  /**
   * Proximo: retorna apontador para o próximo elemento da lista
   *@return apontador para próximo elemento da lista
   */
  Lista_Simples<t_class> *Proximo() { return (Lista_Simples<t_class> *) Lista_Simples_Lib::Proximo(); };

  /**
   * Muda_Proximo: altera o apontador de próximo elemento para noh
   *@param noh apontador para outra lista ou nó de lista
   */
  void Muda_Proximo(Lista_Simples<t_class> *noh) { Lista_Simples_Lib::Muda_Proximo(noh); };

  /**
   * Limpa: limpa(apaga) toda a lista, ficando só o nó atual
   */
  void Limpa() {
    Lista_Simples_Lib *aux = (Lista_Simples_Lib *)Proximo();
    while (aux != NULL) {
      if (aux->Valor() != NULL) {
	delete (t_class *)aux->Valor();
	aux->Muda_Valor(NULL);
      }
      aux = aux->Proximo();
    }
    Lista_Simples_Lib::Limpa();
    aux = this;
    while (aux != NULL) {
      aux = aux->Proximo();
    }
  };

  /**
   * Junta_Depois: coloca uma COPIA de 'lista'  logo após este nó e após da cópia de 'lista' coloca-se a restante da lista existente anteriormente.
   *@param lista será copiada e inserida entre 'this' e 'this->Proximo()'. Não é alterada.
   */
  void Junta_Depois(Lista_Simples<t_class> &lista) {
    Lista_Simples<t_class> *proximo = Proximo();
    Lista_Simples<t_class> *nova = lista.Copia();
    Muda_Proximo(nova);
    nova->Acha_Ultimo()->Muda_Proximo(proximo);
  }
  

  /**
   * Junta_Ultimo: coloca uma COPIA de 'lista'  logo após o último elemento desta lista
   *@param lista será copiada e inserida após this->Acha_Ultimo()
   */
    void Junta_Ultimo(Lista_Simples<t_class> &lista) {
      Acha_Ultimo()->Junta_Depois(lista);
    }

    /**
     * Copia: retorna cópia(alocada dinamicamente, não se esqueça de liberar após o uso) da lista atual
     *@return a cópia da lista atual. (Memória dinâmica, liberar após o uso!)
     */
    Lista_Simples<t_class> *Copia() {
      Lista_Simples<t_class> *lista = new Lista_Simples<t_class>(this->Valor());
      Lista_Simples<t_class> *aux, *aux2;
      
      aux = Proximo();
      aux2= lista;
      while (aux != NULL) {
	aux2->Add_Depois(aux->Valor());
	aux2=aux2->Proximo();
	aux =aux->Proximo();
      }
      
      return lista;
    }
    
    /**
     * Contador: retorna o número de elementos na lista
     *@return númerode elementos na lista
     */
    int Contador() { return Lista_Simples_Lib::Contador(); }
    
    
 protected:
    /**
     * Aterra_Ponteiro: altera os apontadores de próximo para NULL
     */
    void Aterra_Ponteiro() { Lista_Simples_Lib::Aterra_Ponteiro(); };
    
};

#endif