/*! 
 *  \file       lista.c
 *  Todas as definições da lista estão neste módulo.
 *
 *  \brief      Módulo gerenciador da lista.
 *  \version    0.0.1
 *  \date       04/27/2012 10:51:51 AM
 *  \author     Alessandro Elias, ae11@inf.ufpr.br
 *  \author     Welton Pereira Martins, wpm11@inf.ufpr.br
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include "lista.h"
#include "mydebug.h"
#include "log.h"


/* __________________________________________________________________________________ */
/*!  \brief	Inicializa a lista.
 *   \param	pLista - ponteiro para a lista.
 *   \return	True caso a inicialização foi bem sucedida,
 *		False caso contrário.
 *   \remark	Iniclista deve ser a primeira função a ser chamada, caso
		ocorra uma chamada a qualquer uma das outras funções o resultado
 *		é imprevisível, pois a fila contém lixo de memória.
 *   \sa	VaziaLista, InsereLista, ImprimeLista, RemoveLista, TamanhoLista
 */
bool InicLista(struct TipoLista *pLista)
{
    int errnum;

    if( (pLista->pHeadNodo = (struct TipoElementoLista*) \
                malloc(sizeof(struct TipoElementoLista))) == NULL ) {
        errnum = errno;
        PERRLN("Erro 'InicLista'");
        LogMessage("Erro 'InicLista': %s\n", strerror(errnum));
        return FALSE;
    } 

    pLista->pHeadNodo->pProx = pLista->pHeadNodo;
    pLista->pHeadNodo->pAnt  = pLista->pHeadNodo;
    pLista->tamanho = 0;

    return TRUE;
}/* InicLista */

/*! \brief	Verifica se a lista possui elemento(s).
 *  \param	pLista - ponteiro para a lista.
 *  \return	TRUE caso a lista esteja vazia, 
 *		FALSE caso contrário.
 *  \sa         InicLista, InsereLista, ImprimeLista, RemoveLista, TamanhoLista  
 */
bool VaziaLista(struct TipoLista *pLista)
{ return( pLista->pHeadNodo->pProx == pLista->pHeadNodo ); }

/*!  \brief	Armazena um elemento na lista.
 *   \param	Item - item que será armazenado na lista.
 *   \param	pLista - ponteiro para a lista.
 *   \return    TRUE caso o elemento possa ser colocado na lista, 
		False caso contrário.
 *   \remark	Esta lista é circular duplamente encadeada.
 *   \sa        InicLista, VaziaLista, ImprimeLista, RemoveLista, TamanhoLista
 */
bool InsereLista(struct TipoItem *Item, struct TipoLista *pLista)
{
    struct TipoElementoLista *pnovo;
    int errnum;

    if( (pnovo = (struct TipoElementoLista*)malloc(sizeof(struct TipoElementoLista))) == NULL )
    {
        errnum = errno;
        PERRLN("Erro 'InsereLista'");
        LogMessage("Erro 'InsereLista': %s\n", strerror(errnum));
        return FALSE;
    }

    pLista->pHeadNodo->pAnt->pProx = pnovo;
    pLista->pHeadNodo->pAnt->pProx->pAnt = pLista->pHeadNodo->pAnt;
    pLista->pHeadNodo->pAnt = pLista->pHeadNodo->pAnt->pProx;
    pLista->pHeadNodo->pAnt->pProx = pLista->pHeadNodo;

   /* atribua valores ao novo elemento na lista */
    strncpy(pnovo->Elemento.nome, Item->nome, sizeof(pnovo->Elemento.nome)-1);
    if( *Item->brinde )
        strncpy(pnovo->Elemento.brinde, Item->brinde, sizeof(pnovo->Elemento.brinde)-1);
    else
        *pnovo->Elemento.brinde = '\0';      /* set para vazio */
    memcpy(pnovo->Elemento.disciplinas, Item->disciplinas, sizeof(Item->disciplinas));
    pLista->tamanho++;

    return TRUE;
}/* InsereLista */

/*!  \brief	Imprime na saída padrão os elementos da lista.
 *   \param	pLista - ponteiro para a lista.
 *   \sa        InicLista, VaziaLista, InsereLista, RemoveLista, TamanhoLista
 */
void ImprimeLista(struct TipoLista *pLista)
{
    char buff[65] = {'\0'};
    struct TipoElementoLista *aux;

    if( VaziaLista(pLista) ) {
        fprintf(stderr, "Erro: lista vazia.\n");
        LogMessage("Erro: lista vazia.\n");
    }else {
        system("clear");

        /* imprima cabecalho */
        fprintf(stderr, "%-64s %-12s %-12s %-12s %-12s %-12s  %-7s\n",
                "NOME:", "DISCIPLINA 1:", "DISCIPLINA 2:", "DISCIPLINA 3:", "DISCIPLINA 4:", "DISCIPLINA 5:", "BRINDE:");
        memset(buff, '=', 63);
        buff[64] = '\0';
        fprintf(stderr, "%-64.64s %-13.13s %-13.13s %13.13s %13.13s %13.13s  %.20s\n", buff, buff, buff, buff, buff, buff, buff);
        aux = pLista->pHeadNodo->pProx;
        do {
            fprintf(stderr, "%-64.64s %13.3d %13.3d %13.3d %13.3d %13.3d  %.31s\n",
                    aux->Elemento.nome,
                    aux->Elemento.disciplinas[0],
                    aux->Elemento.disciplinas[1],
                    aux->Elemento.disciplinas[2],
                    aux->Elemento.disciplinas[3],
                    aux->Elemento.disciplinas[4],
                    *aux->Elemento.brinde ? aux->Elemento.brinde : "s/ brinde" );
            aux = aux->pProx;
        }while( aux != pLista->pHeadNodo );
    }/* else */
}/* ImprimeLista */

/*!  \brief	Remove um elemento da lista.
 *   \param	pPos - ponteiro para a posição do elemento a ser removido.
 *   \param	pLista - ponteiro para a lista.
 *   \return	Elemento removido.
 *   \sa        InicLista, VaziaLista, InsereLista, ImprimeLista, TamanhoLista
 */
struct TipoItem RemoveLista(struct TipoElementoLista *pPos, struct TipoLista *pLista)
{
    struct TipoItem ret;

    memset(&ret, '\0', sizeof(struct TipoItem));
    if( VaziaLista(pLista) ) {
        fprintf(stderr, "Erro: lista vazia.\n");
        LogMessage("Erro: lista vazia.\n");
    }else if( pPos == pLista->pHeadNodo ) {
        fprintf(stderr, "Erro: elemento invalido.\n");
        LogMessage("Erro: elemento invalido.\n");   
    }else {
        /* salve elemento sendo removido */
        strcpy(ret.nome, pPos->Elemento.nome);
        memcpy(ret.disciplinas, pPos->Elemento.disciplinas, sizeof(pPos->Elemento.disciplinas));

        pPos->pProx->pAnt = pPos->pAnt;
        pPos->pAnt->pProx = pPos->pProx;
        free(pPos);
    }/* else */

    return ret;
}/* RemoveLista */

/*!  \brief	Informa o tamanho da lista.
 *   \param	pLista - ponteiro para a lista.
 *   \return	Tamanho da lista.
 */
UINT TamanhoLista(struct TipoLista *pLista)
{ return( pLista->tamanho ); }