/* Aqui temos as duas bibliotecas que precisamos para o nosso header
*/
#include <string.h> /* mem* */
#include <stdlib.h> /* malloc e free */

/*
Aqui definimos a nossa estrutura básica "nodo_basic". Ela conterá um ponteiro void, o tamanho do apontado pelo ponteiro void e um apontador para o próximo nodo.

Pode parecer estranho gravar o tamanho do que se aponta, mas é essencial. Já que não temos como saber qual tipo ele terá.
*/
typedef struct nodo_basic {
   void *nodo;
   size_t tam_nodo;
   struct nodo_basic *next;
} nodo_basic;

/*
Nosso tipo "fila". Conterá um ponteiro pro inicio(remover nodos) e um ponteiro pro fim(inserir nodos). Elements é um contador para não termos que "correr" para sabermos quantos elementos temos na fila.
*/
typedef struct {
     nodo_basic *start;
     nodo_basic *end;
     long int elements;
} fila;

// Se utilizar um compilador C++ podem remover as duas linhas abaixo
#define true 0
#define false 1

/*
Sempre antes de qualquer coisa chamamos esta função para limpar nosso tipo fila.

Ele já prepara nossa inserção alocando espaço para o primeiro nodo e fazendo as manipulações necessárias.
*/
void filaini( fila *aux)
{
   aux->end = (nodo_basic *) malloc( sizeof(nodo_basic) ); /*cria 1° nodo*/
      
   aux->end->nodo = NULL; /* Limpa o conteúdo do nodo */
   aux->end->next = NULL;
   aux->end->tam_nodo = 0;
  
   aux->start = aux->end; /* Atribui o primeiro nodo ao inicio */
   aux->elements = 0; /* Numero de elementos atuais */
  
}

/*
Aqui nos inserimos no tipo fila. Basicamente, alocamos espaço que precisamos e depois copiamos o que queremos para dentro do nosso nodo final e incrementamos elements.
*/
int add( fila *aux, void *x, size_t tam_x )
{
   // Cria novo nodo
   aux->end->next = (nodo_basic *) malloc( sizeof(nodo_basic) );
  
   if (aux->end->next == NULL) /* testa se falta memória */
      return false;
  
   aux->end->nodo = (void *) malloc(tam_x); /* aloca memória para o nodo */
   if (aux->end->nodo == NULL)
      return false;
   memmove(aux->end->nodo, x, tam_x); /* aux->end->nodo = X; */
   aux->end->tam_nodo = tam_x;
      
   aux->end = aux->end->next; /* coloca o novo nodo como próximo */
   aux->elements++;
  
   return true;
}

/*
Essa função elimina o nodo inicial da fila. Aqui ocorre a liberação de memória e decremento do elements para a sua eliminação. Além do inicio receber o segundo elemento da fila.
*/
int retira( fila *aux )
{
   void *aux2 = aux->start;

   if (aux->elements == 0)
      return false;
      
   aux->start = aux->start->next;
   free( aux2 );
  
   aux->elements--;
   return true;
}

/*
Praticamente inútil já que não temos como barrar a manipulação da variável do tipo fila... O que ela faz é reinserir o nodo inicial e elimina-lo do inicio. Isso faz com que o inicio receba o segundo elemento e o antigo elemento seja posto no fim. Uma das formas de se percorrer a fila encadeada.
*/
int posindex( fila *aux, int X )
{
   while ( X ) {
     if (add( aux, aux->start->nodo, aux->start->tam_nodo ) == false)
        return false;
     retira( aux );
     X--;
   }
  
   return true;
}