#include <stdio.h>
#include <stdlib.h>

typedef int TipoL;

typedef struct ListaNo
{
  TipoL info;
  struct ListaNo *prox;
} * pListaNo;

typedef struct TLista
{
  pListaNo primeiro, ultimo, iterador;
  int longitude;
} * Lista;

Lista inicLista()
{

  Lista lst;
  lst = (Lista)malloc(sizeof(struct TLista)); // alocando a struct TLista
  lst->longitude = 0;                         // zero elmentos
  lst->iterador = NULL;
  lst->primeiro = NULL;
  lst->ultimo = NULL;
  return lst; // retorna o endereco onde a struct Lista foi alocada
}

void primLista(Lista lst)
{
  //por o iterador sobre o primeiro No da lista
  lst->iterador = lst->primeiro;
}

void ultLista(Lista lst)
{
  //por o iterador sobre o ultimo No da lista
  lst->iterador = lst->ultimo;
}

void posLista(Lista lst, int pos)
{

  if (lst->longitude > 0 && pos >= 1 && pos <= lst->longitude)
  {

    int i;
    for (i = 1, lst->iterador = lst->primeiro; i < pos; i++, lst->iterador = lst->iterador->prox)
    {
    }
  }
  else
  {
    lst->iterador = NULL; // iterador indefinido
  }
}

int fimLista(Lista lst)
{

  return (lst->iterador == NULL);
}

void segLista(Lista lst)
{

  if (lst->iterador == NULL)
  {
    printf("\n erro: iterador indefindio \n");
  }
  else
  {
    lst->iterador = lst->iterador->prox;
  }
}

TipoL infoLista(Lista lst)
{
  if (lst->iterador == NULL)
  {
    printf("\n erro: iterador indefinido \n");
    return NULL;
  }
  else
    return lst->iterador->info;
}

int longLista(Lista lst)
{
  return lst->longitude;
}

//3 casos: Lista vazia, iterador sobre o ultimo elemento, iterador sobre um elemento intermediario
void anxLista(Lista lst, TipoL elem)
{

  //tratamento de erro
  if (lst->iterador == NULL && lst->longitude > 0)
  {
    printf("\n erro: iterador indefinido e lista cheia \n");
  }
  else
  {

    //alocar memória para o novoNo a ser adicionado
    pListaNo novoNo = (pListaNo)malloc(sizeof(struct ListaNo));
    novoNo->info = elem; // atribuir o elemento a ser armazenado
    novoNo->prox = NULL; // atribuir NULL para deixar o novoNo preparado

    if (lst->longitude == 0) // lista vazia
    {
      //apontar para o novoNo
      lst->primeiro = novoNo;
      lst->ultimo = novoNo;
      lst->iterador = novoNo;
      lst->longitude++;
    }
    else if (lst->iterador == lst->ultimo) // iterador sobre o ultimo elemento
    {
      //por no campo prox do ultimo no o endereco do novoNo
      lst->iterador->prox = novoNo;
      //lst->ultimo->prox = novoNo;
      //atualizar o campo ultimo com o endereco do novoNo
      lst->ultimo = novoNo;
      //atualizar o campo iterador com o endereco do novoNo
      lst->iterador = novoNo;
      //incrementar a quantidade de nos
      lst->longitude++;
    }
    else //iterador sobre um noh intermediario
    {
      // o prox do novoNo aponta para o proximo Noh depois do iterador
      // fazer o prox do iterador apontar para o novoNo
      novoNo->prox = lst->iterador->prox;
      lst->iterador->prox = novoNo;
      lst->iterador = novoNo;
      lst->longitude++;
    }
  }
}

//3 casos: Lista vazia, iterador sobre o primeiro elemento, iterador sobre qualquer outro elemento
void insLista(Lista lst, TipoL elem)
{

  if (lst->iterador == NULL && lst->longitude > 0)
  {
    printf("\n erro: iterador indefinido e lista cheia \n");
  }
  else
  {

    //alocar memória para o novoNo a ser adicionado
    pListaNo novoNo = (pListaNo)malloc(sizeof(struct ListaNo));
    novoNo->info = elem; // atribuir o elemento a ser armazenado
    novoNo->prox = NULL; // atribuir NULL para deixar o novoNo preparado

    if (lst->longitude == 0) // lista vazia
    {
      //apontar para o novoNo
      lst->primeiro = novoNo;
      lst->ultimo = novoNo;
      lst->iterador = novoNo;
      lst->longitude++;
    }
    else if (lst->iterador == lst->primeiro) // iterador sobre o primeiro elemento
    {
      //novoNo->prox = lst->iterador;
      novoNo->prox = lst->primeiro;
      lst->primeiro = novoNo;
      lst->iterador = novoNo;
      lst->longitude++;
    }
    else //iterador sobre qualquer outro noh
    {
      //usar um segundo iterador para percorrer a lista e parar uma posicao antes do iterador
      pListaNo p;
      for (p = lst->primeiro; p->prox != lst->iterador; p = p->prox)
      {
      }
      //ao sair do for, p esta um noh antes do iterador
      //acertar os ponteiros
      novoNo->prox = lst->iterador;
      p->prox = novoNo;
      lst->iterador = novoNo;
      lst->longitude++;
    }
  }
}