/*!
 * \file        ceui.h
 * \brief       Define TAD da interface com usuario.
 *
 * \date        02-05-2012 16:36:45
 * \version     0.0.1
 * \author      Alessandro Elias, ae11@inf.ufpr.br
 * \author      Welton Pereira Martins wpm11@inf.ufpr.br
 */

#ifndef __CEUI_H__
#define __CEUI_H__      1

#include <poll.h>               /* Chamada a funcao do sistema para verificar se STDIN tem dados no buffer. */
#include "fila.h"
#include "lista.h"
#include "pilha.h"
#include "mycommdef.h"

/****
 * LISTA DE ERROS
 **********************************/
/*! erro ao inicializar a fila. */
#define ERR_INIC_FILA       1
/*! Erro ao inicializar a lista. */
#define ERR_INIC_LISTA      2
/*! Erro ao inicializar a pilha. */ 
#define ERR_INIC_PILHA      3 

/*! Minimo codigo das diciplinas. */
#define MIN_DISCIPLINA       1
/*! Maximo codigo das disciplinas. */
#define MAX_DISCIPLINA      200
/*! Define número padrão de colunas. Em caso de erro este será o tamanho adotado. */
#define DEFAULT_COLS        80
/*! Define número de linhas padrão. Em caso de erro este será o tamanho adotado. */
#define DEFAULT_LINES       25

/*!
 * Opcoes do menu.
 * \remarks     A pilha de brindes e entregue na ordem de matriculas
 *              introduzida no sistema, primeira matricula recebe o brinde
 *              que esta no topo, o segundo recebe penultimo brinde da pilha
 *              e assim por diante.
 */
enum eOptMenu {
    oCreateQueue = 1,           /*!< Cria uma fila de estudades. */
    oInsertStudent,             /*!< Cadastro de estudantes. */
    oPrint,                     /*!< Imprime todas as listas. */
    oPrintQueue = 31,           /*!< Imprime fila. */
    oPrintList,                 /*!< Imprime lista de estudantes. */
    oPrintStack,                /*!< Imprime a pilha de brindes. */
    oGift = 4,                  /*!< Gera uma pilha de brindes a alunos inscritos. */
    oRemove,                    /*!< Remove um estudante da lista. */
    oExit,                      /*!< Sair do programa. */
    oUnknown,                   /*!< Opcao invalida. */
    oNone                       /*!< Nao faca nada */
};
 
void PrintMenu(void);
void Greeting(void);
enum eOptMenu ParseOption(
        const char*,
        enum eOptMenu,
        struct TipoFila*,
        struct TipoLista*,
        struct TipoPilha*);
bool MoreInput(void);
int  GetDisciplina(char**);
enum eOptMenu InsertStudent(struct TipoFila*, struct TipoLista*, struct TipoPilha*);
enum eOptMenu InsertNextStudent(struct TipoItem*, struct TipoLista*, struct TipoPilha*);
enum eOptMenu InsertPilha(struct TipoPilha*);
enum eOptMenu GetCommand(char*, char*);
enum eOptMenu CriaFila(struct TipoFila*);
enum eOptMenu RemoveStudent(struct TipoLista*);
enum eOptMenu WhichCmd(char*, const char*, ...);

#endif /*__CEUI_H__*/

/*! \mainpage  TRABALHO 1 ALGORITMOS E ESTRUTURA DE DADOS II (Cadastro de Estudantes Documentação)
\section intro_sec Introdução
<div align=justify>A primeira decisão da dupla foi pelo nome do programa, o qual escolhemos
ce (iniciais de Cadastro de Estudantes).</div>

\section sec1 DA IDÉIA
 <div align=justify>O cadastro não pode ser preenchido sem ter alunos na fila, portanto para cadastrar
é necessário antes criar uma fila de estudantes.
A idéia da fila é: são números inteiros que representam uma senha para cada estudante na fila,
em ordem crescente de 1 à 30 (este é máximo elementos na fila), 30 porque geralmente uma turma tem em torno 40 alunos,
e a probabilidade dos 40 estar presentes para fazer a matrícula é pequena, então 30 deverá ser o suficiente ao
término deverão ser redistribuidas.
O cadastro para, quando não ouver mais estudantes na fila, porém o usuário tem a opção
de entrar um nome em branco, depois retornar e continuar da senha onde parou.
Brinde é a pilha, a cada estudante matrículado ganha um brinde do topo da pilha, a pilha é nome do brinde.
Pode ser entrado na primeira entrada de cada opção do menu para invocar um comando de impressão, veja em das especificações.</div>

\section sec2 DAS ESPECIFICAÇÕES
<div align=justify>Todas as especificações foram atendidas:
Fila em vetor, pilha, lista dinâmica, lista duplamente encadeada circular.
Impressão a qualquer ponto da execução do programa.
Os comandos podem ser passados na primeira entrada de cada opção, os comandos são:
<ul>
<li>-pf imprime a fila.</li>
<li>-pl imprime lista.</li>
<li>-pp imptime pilha.</li>
ATENÇÃO: qualuer dado depois do comando será ignorado.
</ul>
</div>

\section sec3 DA MODULARIAÇÃO
<div align=justify>
O progrma foi dividido em módulos:
<ul>
<li>ceui.h - protótipos e esqueletos de estruturas cadastro de estudantes user interface.</li>
<li>ceui.c - módulo com as definições das funções que interagem com o usuário.</li>
<li>fila.h - protótipos e esqueletos de estruturas, parte stática da fila.</li>
<li>fila.c - módulo com as definições das funções da fila.</li>
<li>lista.h - protótipos e esqueletos de estruturas, parte stática da lista.</li>
<li>lista.c - módulo com as definições da lista.</li>
<li>pilha.h - protótipos e esqueletos de estruturas, parte stática da pilha.</li>
<li>pilha.c - módulo com as definições da pilha.</li>
<li>log.h - protótipos e esqueletos de estruturas, parte stática do log.</li>
<li>log.c - módulo com as definições das funções que gera o log.</li>
<li>mycommdef.h - declarações comuns a todos os módulos.</li>
<li>mydebug.h - macros que facilitam processo de depuraçõa do código.</li>
<li>Makefile - arquivo que compila cada módulo e depois linka-os.</li>
</ul>
(O programa deve ser linkado com libncurses).
<br/>
Desta maneira o programa seque modularização e facilitará a reutilização do
código e manutenção, pois alguns dos módulos operam de forma independente.
</div>

\section sec4 DE UM PROGRAMA MAIS ROBUSTO
<div align=justify>
Decidimos em usar read() (uma chamada de baixo nível) para
ler dados da entrada padrão, isto posibilita verificar se há mais
dados no STDIN depois de uma leitura, com poll por exemplo. Em caso tivessemos optado por
funções de mais alto nível, não poderiamos controlar se há mais dados,
(ao menos com estas funções não temos conhecimento de como fazer) pois
tais funções como: fgets() getchar() e família trbalham com um buffer
interno. Assim quando o usuário entra mais dados que o tamaho do buffer
podemos operar facilmente filtrando estes dados e ignorando dados excedentes,
mas sempre informando o usuário do que ocorreu, também garantimos que nunca ocorrerá
buffer over-run. Desta forma nosso programa se torna mais robusto.
</div>

\section sec5 DA COMUNICAÇÃO COM USUÁRIO
<div align=justify>
A comunicação com o usuário foi divida em stdout: toda interação com o usuário, menus, chamada de atenção.
Stderr mandamos todas as mensagens de erro e também impressão de relatórios assim damos a oportunidade ao usuário de
redirecionar para outro arquivo os relatórios sem as interações com o sistema.
Observamos que tinhamos a opção de escrever direto no terminal (em /dev/tty) assim ultrapassaríamos
o stdout e poderiamos der deixado somente relatórios em stdout, erros stderr, porém devido
o aumento da complexidade optamos pela primeira.
</div>

\section sec6 DO LOG
<div align=justofy>
Para não obter log's muito longo optamos por gerar um log a cada interação com o programa. O programa gera no
máximo 999 logs, depois disso usuário deve remover alguns logs para que possa ser gerado mais logs, cada log
é gerado com o nome logxxx.txt onde xxx é iqual ao número da execução, no formato 001 para primeira
002 e assim sucessivamente. Observe que se este limite for atingido o usuário será informado.
</div>

\section sec7 DA UTILIZAÇÃO
<div align=justify>
O programa pode trabalhar com redirecionamento, tanto da entrada padrão quanto do erro padrão (stderr).
A utilização mais simples é executar o programa e sequir as opções na tela, porém se for utilizado redirecionamento
o arquivo de entrada deve seguir as sequintes regras:
<ul>
<li>Opção do menu: xxx\\n (3 char's + enter)</li>
<li>Entrada da fila: xxxxx\\n (5 char's + enter)</li>
<li>Nome: _ _...62_\\n (62 char's + enter)</li>
<li>Disciplinas: xxx xxx xxx xxx xxx\\n (20 char's + enter)</li>
<li>Pilha: _ _...30_\\n (30 char's + enter)</li>
</ul>
Toda e qualquer entrada deve preencher todo o buffer.<br/>
OBS.: _ é espaço, x é 0 padded.<br/><br/>
Ex.: o nome do aluno pode conter no máximo 64 caracteres incluindo ('\\0') final da string
como cada entrada deve ser sinalizada por LF ('\\n') esta entrada deve conter 62 caracteres
preenchidos mais LF, a entrada pode ser preenchida com espaços, números devem ser preenchidos com 0.
Isto vale para todos os campos.
Para que ele execute um determinado comando do menu, este também deve estar dentro do arquivo
de entrada na forma: 02\\n, ou seja ele deve conter 3 chars.<br/>
Ex.:<br/>
01<br/>
00001<br/>
02<br/>
nome do aluno_ _ _62*_ (_=espaço)<br/>
06<br/>
</div>
<a href="../fila.h">fila</a>
*/