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

#define EXIT_SUCCESS          0
#define EXIT_WRONGCOMMANDLINE 1
#define EXIT_MEMORY           2
#define EXIT_OPENFILE         3


typedef short boolean;

#define TRUE  1
#define FALSE 0


#define RIGA   80

typedef struct _libro
{
  char          TitoloAutore[RIGA];
  struct _libro *next, *prev;

} libro;

typedef libro listalibri;
typedef libro posizione;

listalibri *CreaListaLibri ();

void DistruggeListaLibri (listalibri **pL);

posizione *primolista (listalibri *L);

posizione *ultimolista (listalibri *L);

boolean finelista (posizione *p, listalibri *L);

boolean listavuota (listalibri *L);

posizione *succlista (posizione *p);

posizione *preclista (posizione *p);

void inslista (char *TitoloAutore, posizione *p, listalibri *L);

void canclista (posizione **p);

posizione *findelemento (char *TitoloAutore, listalibri *L);

void StampaListaLibri (listalibri *L);


void LeggeIstruzioni (int argc, char *argv[], char *BiblioFile, char *RecordFile);

void CaricaBiblioteca (char *BiblioFile, listalibri *Scaffale);

void EsegueMovimenti (char *RecordFile, listalibri *Scaffale, listalibri *Prestati, listalibri *Resi);

void RiponeLibriRestituiti (listalibri *Scaffale, listalibri *Resi);



int main(int argc, char *argv[])
{
  char BiblioFile[RIGA], RecordFile[RIGA];
  listalibri *Scaffale;
  listalibri *Prestati;
  listalibri *Resi;


  // 1) Interpretazione della linea di comando
  LeggeIstruzioni(argc,argv,BiblioFile,RecordFile);

  // 2) Allocazione delle strutture dati
  Scaffale = CreaListaLibri();
  Prestati = CreaListaLibri();
  Resi = CreaListaLibri();

  // 3) Caricamento dei dati
  CaricaBiblioteca(BiblioFile,Scaffale);

  // 4a) Algoritmo 1 e salvataggio dei risultati
  EsegueMovimenti(RecordFile,Scaffale,Prestati,Resi);

  // 5a) Salvataggio dei risultati 1
  StampaListaLibri(Scaffale);

  // 4b) Algoritmo 2
  RiponeLibriRestituiti(Scaffale,Resi);

  // 5b) Salvataggio dei risultati 2
  StampaListaLibri(Scaffale);

  // 6) Deallocazione delle strutture dati
  DistruggeListaLibri(&Scaffale);
  DistruggeListaLibri(&Prestati);
  DistruggeListaLibri(&Resi);

  return EXIT_SUCCESS;
}


void LeggeIstruzioni (int argc, char *argv[], char *BiblioFile, char *RecordFile)
{
  if (argc != 3)
  {
    printf("Command line format wrong!\n");
    exit(EXIT_WRONGCOMMANDLINE);
  }

  strcpy(BiblioFile,argv[1]);
  strcpy(RecordFile,argv[2]);
}


void CaricaBiblioteca (char *BiblioFile, listalibri *Scaffale)
{
  FILE *fBiblioFile;
  char Riga[RIGA];


  fBiblioFile = fopen(BiblioFile,"r");
  if (fBiblioFile == NULL)
  {
    printf("File %s does not exist!\n",BiblioFile);
    exit(EXIT_OPENFILE);
  }

  fgets(Riga,RIGA,fBiblioFile);
  while (strcmp(Riga,"FINE\n") != 0)
  {
    // Elimina l'a capo dalla stringa
    Riga[strlen(Riga)-1] = '\0';

    // Inserisce il nuovo libro in coda allo scaffale
    inslista(Riga,succlista(ultimolista(Scaffale)),Scaffale);

    fgets(Riga,RIGA,fBiblioFile);
  }

  fclose(fBiblioFile);
}


void EsegueMovimenti (char *RecordFile, listalibri *Scaffale, listalibri *Prestati, listalibri *Resi)
{
  FILE *fRecordFile;
  char Comando[RIGA], Riga[RIGA];
  posizione *p;


  fRecordFile = fopen(RecordFile,"r");
  if (fRecordFile == NULL)
  {
    printf("File %s does not exist!\n",RecordFile);
    exit(EXIT_OPENFILE);
  }

  fscanf(fRecordFile,"%s ",Comando);
  while (strcmp(Comando,"FINE") != 0)
  {
    fgets(Riga,RIGA,fRecordFile);
    Riga[strlen(Riga)-1] = '\0';

    if (strcmp(Comando,"PRESTITO") == 0)
    {
      // Cerca il libro sullo scaffale e lo cancella
      p = findelemento(Riga,Scaffale);
      if (p != NULL) canclista(&p);

      // Inserisce il nuovo libro in coda alla lista dei prestiti
      inslista(Riga,succlista(ultimolista(Prestati)),Prestati);
    }
    else if (strcmp(Comando,"RESTITUZIONE") == 0)
    {
      // Cerca il libro nella lista dei prestiti e lo cancella
      p = findelemento(Riga,Prestati);
      if (p != NULL) canclista(&p);

      // Inserisce il libro in cima alla lista dei resi
      inslista(Riga,primolista(Resi),Resi);
    }

    fscanf(fRecordFile,"%s ",Comando);
  }

  fclose(fRecordFile);
}


void RiponeLibriRestituiti (listalibri *Scaffale, listalibri *Resi)
{
}


listalibri *CreaListaLibri ()
{
  listalibri *L = (listalibri *) malloc(sizeof(listalibri));
  if (L == NULL)
  {
    printf("Memoria insufficiente per allocare la lista dei libri!\n");
    exit(EXIT_MEMORY);
  }
  L->next = L;
  L->prev = L;
  return L;
}


void DistruggeListaLibri (listalibri **pL)
{
  posizione *p;
  for (p = primolista(*pL); !listavuota(*pL); canclista(&p));
  free(*pL);
  *pL = NULL;
}


posizione *primolista (listalibri *L)
{
  posizione *p = L->next;
  return p;
}


posizione *ultimolista (listalibri *L)
{
  posizione *p = L->prev;
  return p;
}


boolean finelista (posizione *p, listalibri *L)
{
  boolean b = (p == L);
  return b;
}


boolean listavuota (listalibri *L)
{
  boolean b = (L->next == L) && (L->prev == L);
  return b;
}


posizione *succlista (posizione *p)
{
  posizione *q = p->next;
  return q;
}


posizione *preclista (posizione *p)
{
  posizione *q = p->prev;
  return q;
}


void inslista (char *TitoloAutore, posizione *p, listalibri *L)
{
  posizione *q = (posizione *) malloc(sizeof(libro));
  if (q == NULL)
  {
    printf("Memoria insufficiente per allocare il libro %s!\n",TitoloAutore);
    exit(EXIT_MEMORY);
  }
  strcpy(q->TitoloAutore,TitoloAutore);
  q->prev = p->prev;
  q->next = p;
  p->prev->next = q;
  p->prev = q;
}


void canclista (posizione **pp)
{
  posizione *q;
  q = *pp;
  q->prev->next = q->next;
  q->next->prev = q->prev;
  *pp = q->next;
  free(q);
}


posizione *findelemento (char *TitoloAutore, listalibri *L)
{
  posizione *p;

  for (p = primolista(L); !finelista(p,L); p = succlista(p))
    if (strcmp(p->TitoloAutore,TitoloAutore) == 0)
      return p;

  return NULL;
}


void StampaListaLibri (listalibri *L)
{
  posizione *p;

  printf("SCAFFALE\n");
  for (p = primolista(L); !finelista(p,L); p = succlista(p) )
    printf("%s\n",p->TitoloAutore);
  printf("FINE\n");
}