Untitled

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

#define BUFFER_SIZE 10000
#define SIZE_TABELLA_INIZIALE 1024

struct lotto
{
    int quantita;
    int scadenza;      
    struct lotto *next;
};

struct ingrediente
{
    char *nome_ingrediente;      
    struct lotto *lotto_ingrediente;
    int quantita_totale_lotti;         // quantita in grammi dei lotti di quel determinato ingrediente
    struct ingrediente * next;
};

struct ingrediente_in_ricetta
{
    char * nome_ingrediente;
    struct ingrediente *ingrediente_associato;
    int quantita;
    struct ingrediente_in_ricetta *next;
};

struct ricetta
{
    char *nome_ricetta; 
    struct ingrediente_in_ricetta * ingredienti_ricetta;
    int peso_ricetta;          // peso_ricetta = quantita di ogni ingrediente in grammi, lo calcolo quando aggiungo una ricetta
    struct ricetta *next;

};

struct ordine
{
    char * nome_ordine;
    int quantita;
    int istante_di_tempo;
    struct ricetta *ricetta_ordine;   // ogni ordine ha un puntatore alla sua ricetta
    int peso_ordine; 
    struct ordine *next;
} order;

struct tabella_ricette
{
    struct ricetta ** ricetta_in_tabella;
    int numero_elementi;
    int size;
};

struct tabella_ingredienti
{
    struct ingrediente **ingredienti_in_tabella;
    int numero_elementi;
    int size;
};

struct ordine * ordini_pronti = NULL;
struct ordine * coda_pronti = NULL;
struct ordine * ordini_attesa = NULL;
struct ordine * coda_attesa = NULL;
struct ordine * camioncino = NULL; 

struct tabella_ricette * crea_ricettario(){
    struct tabella_ricette * ricettario =  malloc(sizeof(struct tabella_ricette));
    ricettario->numero_elementi = 0; 
    ricettario->ricetta_in_tabella = (struct ricetta **)calloc(SIZE_TABELLA_INIZIALE, sizeof(struct ricetta *));
    ricettario->size = SIZE_TABELLA_INIZIALE;
    return ricettario;
};

struct tabella_ingredienti * crea_magazzino(){
    struct tabella_ingredienti * magazzino =  malloc(sizeof(struct tabella_ingredienti));
    magazzino->numero_elementi = 0; 
    magazzino->ingredienti_in_tabella = calloc(SIZE_TABELLA_INIZIALE, sizeof(struct tabella_ingredienti *));
    magazzino->size = SIZE_TABELLA_INIZIALE;
    return magazzino;
};

unsigned long funzione_hash(const char *chiave, int size)      // funzione hash sdbm
{
    unsigned long hash = 0;
    int c;
    while ((c = *chiave++))
    {
        hash = ((hash << 5) + hash) + c;
    }
    return hash % size;
}

void resize_tabella_ricette(struct tabella_ricette * ricettario)
{
    
    int new_size =  ricettario->size * 2;

    struct ricetta **copia_ricette = calloc(new_size, sizeof(struct ricetta *));

    for (int i = 0; i < ricettario->size; i++)
    {
        struct ricetta * nodo = ricettario->ricetta_in_tabella[i];
        while (nodo != NULL)
        {
            struct ricetta * nodo_successivo = nodo->next;
            unsigned long hash = funzione_hash(nodo->nome_ricetta, new_size);

            nodo->next = copia_ricette[hash]; 
            copia_ricette[hash] = nodo;       

            nodo = nodo_successivo;
        }
    }

    free(ricettario->ricetta_in_tabella);
    ricettario->ricetta_in_tabella = copia_ricette;
    ricettario->size  = new_size;
}

void resize_tabella_ingredienti(struct tabella_ingredienti * magazzino)
{
    int new_size =  magazzino->size * 2;

    struct ingrediente **copia_ingredienti = calloc(new_size, sizeof(struct ingrdiente *));

    for (int i = 0; i < magazzino->size; i++)
    {
        struct ingrediente * nodo = magazzino->ingredienti_in_tabella[i];
        while (nodo != NULL)
        {
            struct ingrediente * nodo_successivo = nodo->next;
            unsigned long hash = funzione_hash(nodo->nome_ingrediente, new_size);

            nodo->next = copia_ingredienti[hash]; 
            copia_ingredienti[hash] = nodo;       

            nodo = nodo_successivo;
        }
    }

    free(magazzino->ingredienti_in_tabella);
    magazzino->ingredienti_in_tabella = copia_ingredienti;
    magazzino->size  = new_size;
}

struct ingrediente *crea_ingrediente(char *nome)
{
    struct ingrediente *nuovo_ingrediente = malloc(sizeof(struct ingrediente));
    nuovo_ingrediente->nome_ingrediente = strdup(nome);
    nuovo_ingrediente->lotto_ingrediente = NULL;
    nuovo_ingrediente->next = NULL;
    nuovo_ingrediente->quantita_totale_lotti = 0;   
    return nuovo_ingrediente;
}

struct ingrediente_in_ricetta *crea_ingrediente_in_ricetta(struct ingrediente * ingrediente_ricetta, int quantita_ingrediente)
{
    struct ingrediente_in_ricetta * ingr_ricetta = malloc(sizeof(struct ingrediente_in_ricetta));
    ingr_ricetta->ingrediente_associato = ingrediente_ricetta;
    ingr_ricetta->quantita = quantita_ingrediente;
    return ingr_ricetta;
}

struct ricetta * crea_ricetta(const char *name)
{
    struct ricetta * nuova_ricetta = malloc(sizeof(struct ricetta));

    nuova_ricetta->nome_ricetta = strdup(name);
    nuova_ricetta->ingredienti_ricetta = NULL;
    nuova_ricetta->peso_ricetta = 0;
    nuova_ricetta->next = NULL;
    return nuova_ricetta;
}

struct lotto * crea_lotto(int quantita_lotto, int scadenza_lotto)
{
    struct lotto * nuovo_lotto = malloc(sizeof(struct lotto));
    nuovo_lotto->quantita = quantita_lotto;
    nuovo_lotto->scadenza = scadenza_lotto;
    
    nuovo_lotto->next = NULL;

    return nuovo_lotto;
}

struct ordine * crea_ordine(char * nome_ordine, int quantita_ordine, int tempo, struct ricetta * ricetta_ordine){
    struct ordine * nuovo_ordine = malloc(sizeof(struct ordine)); 
    nuovo_ordine->nome_ordine = strdup(nome_ordine);
    nuovo_ordine->quantita = quantita_ordine;
    nuovo_ordine->istante_di_tempo = tempo;
    nuovo_ordine->next = NULL; 
    nuovo_ordine->ricetta_ordine = ricetta_ordine; 
    nuovo_ordine->peso_ordine = ricetta_ordine->peso_ricetta * quantita_ordine;
    return nuovo_ordine;
}

struct ricetta * inserisci_ricetta(char *nome_ricetta, struct tabella_ricette *ricettario)
{
    /*
        controllo se la ricetta è presente in tabella, in quel caso stampo ignorato e ritorno NULL
        altrimenti aggiungo la ricetta in testa alla lista
    */

    if (ricettario->numero_elementi >= ricettario->size * 2 )
    {
        resize_tabella_ricette(ricettario);
    }

    int index_hash = funzione_hash(nome_ricetta, ricettario->size);
    struct ricetta * ricetta_in_lista = ricettario->ricetta_in_tabella[index_hash];
    int ricetta_presente = 0;

    while (ricetta_in_lista != NULL)
    {
        if (strcmp(ricetta_in_lista->nome_ricetta, nome_ricetta) == 0)
        {
            ricetta_presente = 1;
        }
        ricetta_in_lista = ricetta_in_lista->next;
    }

    if (ricetta_presente == 0)   
    {
        // Se la ricetta non è presente la aggiungo
        struct ricetta * ricetta_nuova = crea_ricetta(nome_ricetta);
        ricetta_nuova->next = ricettario->ricetta_in_tabella[index_hash]; 
        ricettario->ricetta_in_tabella[index_hash] = ricetta_nuova;
        ricettario->numero_elementi++;       
        printf("aggiunta\n");
        return ricetta_nuova;
    } else{
        // se non è presente ritorno NULL
        printf("ignorato\n");
        return NULL;
    }
       
}

void aggiungi_ingrediente(char *nome_ingrediente,int quantita_ingrediente, struct tabella_ingredienti * magazzino, struct ricetta * ricetta_associata)
{
    /*
        calcolo il hash con il nome dell'ingrediente
        trovo l'ingrediente nel magazzino
        se non è presente lo aggiungo
    */

    if (magazzino->numero_elementi >= magazzino->size * 2)
    {
        resize_tabella_ingredienti(magazzino);
    }

    int index_hash = funzione_hash(nome_ingrediente, magazzino->size);
    struct ingrediente * ingrediente_in_lista = magazzino->ingredienti_in_tabella[index_hash];
    int uscita = 0;
    while (ingrediente_in_lista != NULL && uscita == 0)
    {
        if (strcmp(ingrediente_in_lista->nome_ingrediente, nome_ingrediente) == 0)
        {
            struct ingrediente_in_ricetta * ingrediente_in_ricetta = crea_ingrediente_in_ricetta(ingrediente_in_lista, quantita_ingrediente);
            ingrediente_in_ricetta->next = ricetta_associata->ingredienti_ricetta;
            ricetta_associata->ingredienti_ricetta = ingrediente_in_ricetta;
            ricetta_associata->peso_ricetta += quantita_ingrediente;
            uscita = 1;
            
        } else{
            ingrediente_in_lista = ingrediente_in_lista->next;
        }
    }

    if (uscita == 0)
    {
        struct ingrediente * nuovo_ingrediente = crea_ingrediente(nome_ingrediente);

        nuovo_ingrediente->next = magazzino->ingredienti_in_tabella[index_hash];
        magazzino->ingredienti_in_tabella[index_hash] = nuovo_ingrediente;
        magazzino->numero_elementi++;

        struct ingrediente_in_ricetta * i = crea_ingrediente_in_ricetta(nuovo_ingrediente, quantita_ingrediente);
        i->next = ricetta_associata->ingredienti_ricetta;
        ricetta_associata->ingredienti_ricetta = i;
        ricetta_associata->peso_ricetta += quantita_ingrediente;
    }

}

int controlla_ordini(char * nome){
    struct ordine * l = ordini_pronti;
    while (l != NULL)
    {
        if (strcmp(l->nome_ordine, nome) == 0)
        {
            return 1;
        }
        l = l->next;        
    }
    struct ordine * a = ordini_attesa;
    while (a != NULL)
    {
        if (strcmp(a->nome_ordine, nome) == 0)
        {
            return 1;
        }  

        a = a->next;      
    }
    return 0;   
}

void elimina_ricetta(char *nome_ricetta, struct tabella_ricette *ricettario)
{

    if (controlla_ordini(nome_ricetta) == 1)
    {
        printf("ordini in sospeso\n");
        return;
    }

    unsigned long hash = funzione_hash(nome_ricetta, ricettario->size);
    
    struct ricetta * t = ricettario->ricetta_in_tabella[hash];
    struct ricetta * prec = NULL;

    while (t != NULL)
    {
        if (strcmp(t->nome_ricetta, nome_ricetta) == 0)
        {
            if (prec == NULL)
            {
                ricettario->ricetta_in_tabella[hash] = t->next;
            }
            else
            {
                prec->next = t->next;
            }
            printf("rimossa\n");
            ricettario->numero_elementi--;
            free(t->nome_ricetta);
            free(t);
            
            return;
        }
        prec = t;
        t = t->next;
    }

    printf("non presente\n");
    return;
}

void elimina_lotti_utilizzati(struct ordine * ordine_ingrediente, int quantita_ordine)
{

    /*
        controllo ogni ingrediente della ricetta associata all'ordine
        elimino i lotti utilizzati di ogni ingrediente
        aggiorno la quantita totale del lotto
    */
    int quantita_parziale = 0; 
    int quantita_utilizzata = 0;
    struct ingrediente_in_ricetta * i = ordine_ingrediente->ricetta_ordine->ingredienti_ricetta;

    while (i != NULL)
    {
        struct lotto * lotto_ingrediente = i->ingrediente_associato->lotto_ingrediente;
        quantita_parziale = lotto_ingrediente->quantita; 
        quantita_utilizzata = i->quantita * quantita_ordine; 

        while (quantita_parziale < quantita_utilizzata) 
        {

            struct lotto * lotto_del = lotto_ingrediente;
            // aggiorno la lista di lotti
            i->ingrediente_associato->lotto_ingrediente = lotto_ingrediente->next;
            free(lotto_del);

            // la lista di lotti punta al successivo
            lotto_ingrediente = i->ingrediente_associato->lotto_ingrediente;
            
            quantita_parziale += lotto_ingrediente->quantita;
        }

        // l'ultimo lotto usato non l'ho elimino perchè può essere usato solo parzialmente
        lotto_ingrediente->quantita = quantita_parziale - quantita_utilizzata;
        // aggiorno quantita totale dei lotti sottraendo quelli utilizzati
        i->ingrediente_associato->quantita_totale_lotti -= quantita_utilizzata;
        // vado all'INGREDIENTE successivo
        i = i->next;
    }
}

/* void controlla_scadenze(struct ingrediente_in_ricetta ** ingrediente_r, int tempo){
    struct lotto * l = (*ingrediente_r)->ingrediente_associato->lotto_ingrediente; 
    while (l != NULL && l->scadenza <= tempo)
    {
        struct lotto * lotto_del = l;
        (*ingrediente_r)->ingrediente_associato->quantita_totale_lotti -= l->quantita;
        (*ingrediente_r)->ingrediente_associato->lotto_ingrediente = l->next;       
        free(lotto_del);
        l = (*ingrediente_r)->ingrediente_associato->lotto_ingrediente;       
    }
} */

void scambio_ordini(struct ordine * ordine_da_scambiare){
    /*
        aggiungo l'ordine proveniente dall'attesa nella lista dei pronti
        aggiungo in ordine di tempo d'inserimento
    */ 

    struct ordine * p = ordini_pronti;
    struct ordine * precedente = NULL;

    if (ordini_pronti == NULL)
    {
        ordini_pronti = ordine_da_scambiare;
        coda_pronti = ordine_da_scambiare;
    } else{

        while (p != NULL && p->istante_di_tempo < ordine_da_scambiare->istante_di_tempo)
        {
            precedente = p; 
            p = p->next;
        }

        if (precedente == NULL)
        {
            ordine_da_scambiare->next = ordini_pronti; 
            ordini_pronti = ordine_da_scambiare;
        } else{
            // nel caso in cui l'ordine viene aggiunto alla coda aggiorno la coda della lista
            if (precedente->next == NULL)
            {
                coda_pronti = ordine_da_scambiare;
            }

            ordine_da_scambiare->next = precedente->next; 
            precedente->next = ordine_da_scambiare;       
    }

    }
}

void controlla_ordini_attesa(int istante_tempo)
{
    struct ordine * a = ordini_attesa;
    struct ordine * prec = NULL;
    while (a != NULL)
    {
        struct ingrediente_in_ricetta * ingrediente_r = a->ricetta_ordine->ingredienti_ricetta;
        int scambio = 1;

        while (ingrediente_r != NULL && scambio == 1)
        {
            /* struct ingrediente_in_ricetta ** ingrediente_chek = malloc(sizeof(struct ingrediente_in_ricetta *));
            *ingrediente_chek = ingrediente_r;
             struct lotto * l = ingrediente_r->ingrediente_associato->lotto_ingrediente;
            controlla_scadenze(ingrediente_chek, istante_tempo); */

                struct lotto * lotto_ingrediente = ingrediente_r->ingrediente_associato->lotto_ingrediente;
                int ferma_scansione = 0;
                while (lotto_ingrediente != NULL && ferma_scansione == 0)
                {
                    if (lotto_ingrediente->scadenza <= istante_tempo)
                    {
                        struct lotto * lotto_da_eliminare = lotto_ingrediente;
                        // la lista dei lotti punta all'elemento successivo
                        ingrediente_r->ingrediente_associato->lotto_ingrediente = lotto_ingrediente->next;

                        // aggiorno la quantita totale dei lotti salvata nell'ingrediente in tabella
                        ingrediente_r->ingrediente_associato->quantita_totale_lotti -= lotto_ingrediente->quantita;
                        
                        free(lotto_da_eliminare);

                        //il lotto punta di nuovo a inizio della lista lotti associata all'ingrediente
                        lotto_ingrediente = ingrediente_r->ingrediente_associato->lotto_ingrediente;
                    }
                    else{
                        // mi fermo appena trovo un lotto non scaduto (la lista dei lotti è in ordine di scadenza)
                        ferma_scansione = 1;
                    }
               
                }
            int quantita_necessarria = ingrediente_r->quantita * a->quantita;
            int quantita_totale_lotti = ingrediente_r->ingrediente_associato->quantita_totale_lotti;
            /*            
                printf("%d", quantita_totale_lotti); 
                printf(" necessaria :  ")
                printf("%d", quantita_necessarria); 
                printf("\n");
            */
            // se la quantita totale dei lotti è maggiore della quantità necessaria aggiorno 

            if ( quantita_totale_lotti < quantita_necessarria)
            {
                // se non posso fare lo scambio mi fermo, mancano i lotti per un ingrediente
                scambio = 0;
            }
            else
            {
                // se i lotti per quel inigrediente sono sufficienti controllo i successivi
                ingrediente_r = ingrediente_r->next;
            }
        }

        if (scambio == 1)
        {
            elimina_lotti_utilizzati(a, a->quantita);
            if (prec == NULL)
            {
                ordini_attesa = a->next;
                a->next = NULL;
                scambio_ordini(a);               
                a = ordini_attesa;
            }
            else
            {   
                if (a->next == NULL)   // se a è l'ultimo oggetto aggiorno la coda dell'attesa
                {
                    coda_attesa = prec;
                }

                prec->next = a->next;
                struct ordine *successivo = a->next;  // mi serve salvare l'elemento successivo per continuare lo scan
                a->next = NULL;
                scambio_ordini(a);
                a = successivo;
            }
        }
        else
        {
            // in questo caso vado avanti normalmente
            prec = a;
            a = a->next;
        }
    }
}

void aggiungi_lotto(char * nome_lotto, int quantita_lotto, int scadenza_lotto, struct tabella_ingredienti * magazzino)
{
    if (magazzino->numero_elementi >= magazzino->size * 2)
    {
        resize_tabella_ingredienti(magazzino);
    }

    struct lotto * nuovo_lotto = crea_lotto(quantita_lotto, scadenza_lotto);   
    int index_hash = funzione_hash(nome_lotto, magazzino->size);
    struct ingrediente *i = magazzino->ingredienti_in_tabella[index_hash];

    while (i != NULL)
    {
        if (strcmp(i->nome_ingrediente, nome_lotto) == 0)
        {
            struct lotto * lotto_temp = i->lotto_ingrediente;
            struct lotto *prec = NULL;

            while (lotto_temp != NULL && lotto_temp->scadenza < scadenza_lotto)     // possibile modifica
            {
                prec = lotto_temp;
                lotto_temp = lotto_temp->next;
            }
            if (prec == NULL)
            {
                nuovo_lotto->next = lotto_temp;
                i->lotto_ingrediente = nuovo_lotto;
            }
            else
            {
                nuovo_lotto->next = lotto_temp;
                prec->next = nuovo_lotto;
            }
            i->quantita_totale_lotti += quantita_lotto;
            return;
        }
        i = i->next;
    }

    // se viene effettuato un rifornimento di un ingrediente non ancora preseente in nessuna ricetta
    // lo aggiungo in testa alla lista 
    struct ingrediente * nuovo_ingrediente_da_rifornimento = crea_ingrediente(nome_lotto);
    nuovo_ingrediente_da_rifornimento->lotto_ingrediente = nuovo_lotto;
    nuovo_ingrediente_da_rifornimento->next = magazzino->ingredienti_in_tabella[index_hash];
    magazzino->ingredienti_in_tabella[index_hash] = nuovo_ingrediente_da_rifornimento;
    magazzino->numero_elementi++;
    
}

void gestione_ordine(char *nome_ordine, int quantita_ordine, int tempo, struct tabella_ricette * ricettario)
{
    int index_hash = funzione_hash(nome_ordine, ricettario->size);
    int ingrediente_trovato = 0;
    struct ricetta * r = ricettario->ricetta_in_tabella[index_hash];

    while (r != NULL && ingrediente_trovato == 0)
    {
        if (strcmp(r->nome_ricetta, nome_ordine) == 0)
        {
            ingrediente_trovato = 1;
            struct ordine * nuovo_ordine = crea_ordine(nome_ordine, quantita_ordine, tempo, r);
            int ordine_in_attesa = 0;

            struct ingrediente_in_ricetta * ingrediente_r = r->ingredienti_ricetta;

            while (ingrediente_r != NULL && ordine_in_attesa == 0)
            {
               /* struct ingrediente_in_ricetta ** ingrediente_chek = malloc(sizeof(struct ingrediente_in_ricetta *));
                *ingrediente_chek = ingrediente_r;
                controlla_scadenze(ingrediente_chek, tempo); */

                struct lotto * lotto_ingrediente = ingrediente_r->ingrediente_associato->lotto_ingrediente;
                int ferma_scansione = 0;
                while (lotto_ingrediente != NULL && ferma_scansione == 0)
                {
                    if (lotto_ingrediente->scadenza <= tempo)
                    {
                        // la lista dei lotti punta all'elemento successivo
                        ingrediente_r->ingrediente_associato->lotto_ingrediente = lotto_ingrediente->next;
                        // agiorno la quantità totale dei lotti di quel ingrediente                       
                        ingrediente_r->ingrediente_associato->quantita_totale_lotti -= lotto_ingrediente->quantita;

                        // elimino il lotto scaduto
                        struct lotto * lotto_da_eliminare = lotto_ingrediente;                       
                        free(lotto_da_eliminare);
                        lotto_ingrediente = ingrediente_r->ingrediente_associato->lotto_ingrediente;
                    }
                    else{
                        // mi fermo appena trovo un lotto non scaduto (la lista dei lotti è in ordine di scadenza)
                        ferma_scansione = 1;
                    }
               
                }
                
                int quantita_necessarria = ingrediente_r->quantita * quantita_ordine;
                int quantita_totale_lotti = ingrediente_r->ingrediente_associato->quantita_totale_lotti;
                           
                   /* printf("%d", quantita_totale_lotti); 
                    printf(" necessaria :  ")
                    printf("%d", quantita_necessarria); 
                    printf("\n"); */

                if (quantita_totale_lotti < quantita_necessarria)
                {
                    // se devo mettere l'ordine in attesa mi fermo con la scansione
                    ordine_in_attesa = 1;
                }
                else
                {
                    ingrediente_r = ingrediente_r->next;
                }
            }

            if (ordine_in_attesa == 1)
            {
                // aggingo l'ordine in attesa

                if (ordini_attesa == NULL)
                {
                    ordini_attesa = nuovo_ordine; 
                    coda_attesa = nuovo_ordine;
                } else{
                    if (coda_attesa != NULL)
                    {
                        coda_attesa->next = nuovo_ordine; 
                        coda_attesa = nuovo_ordine;
                    }                    
                }
            }
            else
            {
                // aggiungo l'ordine in pronti 

                if (ordini_pronti == NULL)
                {
                    ordini_pronti = nuovo_ordine; 
                    coda_pronti = nuovo_ordine;
                } else{
                    if (coda_pronti != NULL)
                    {
                        coda_pronti->next = nuovo_ordine; 
                        coda_pronti = nuovo_ordine;
                    }                    
                }

                elimina_lotti_utilizzati(nuovo_ordine, quantita_ordine);
            }

            printf("accettato\n");
        } else{
            r = r->next;
        }
        
    }
    if (ingrediente_trovato == 0)
    {
        printf("rifiutato\n");
    }
    
    
}

void gestione_corriere(int capienza)
{
    /* printf("prova visione ordini pronti in lista :  ")
    struct ordine * o = ordini_pronti;
    while (o!=NULL)
    {
        printf("%s", o->nome_ordine); printf(" ");
        o = o->next;
    } */
 
    /*
        controllo gli ordini in attesa e la capienza del camioncino
        aggiungo nella lista del camioncino in ordine di peso
        se supero la capienza esco dal while 
    */

    struct ordine * p = ordini_pronti; 
    int quantita_parziale = p->peso_ordine; 

    while (p!=NULL && quantita_parziale <= capienza)
    {
        if (camioncino == NULL)
        {
            ordini_pronti = p->next;    // aggiorno la lista dei pronti
            p->next = NULL; 
            camioncino = p;            // inserisco in camioncino
            p = ordini_pronti;
        }
        else
        {
            // inserisco in ordine di peso, quindi trovo la posizione in lista

            struct ordine * ord_camioncino = camioncino; 
            struct ordine * precedente = NULL; 
            
            while (ord_camioncino != NULL && ord_camioncino->peso_ordine >= p->peso_ordine)  // metto >= perchè se sono uguali inserisco in ordine di inserimento dell'ordine
            {
                precedente = ord_camioncino; 
                ord_camioncino = ord_camioncino->next;
            }

            if (precedente == NULL)
            {
                ordini_pronti = p->next;   
                p->next = camioncino;
                camioncino = p;
            } else{                   
                ordini_pronti = p->next;
                p->next = precedente->next;
                precedente->next = p;
            }
            p = ordini_pronti;                                           
        }

        if (p!=NULL)
        {
            quantita_parziale += p->peso_ordine;
        }                  
    }

    if (camioncino == NULL)
    {
        printf("camioncino vuoto\n");
    } else{
         
        while (camioncino != NULL)
        {
            printf("%d", camioncino->istante_di_tempo); printf(" ");
            printf("%s", camioncino->ricetta_ordine->nome_ricetta); printf(" ");
            printf("%d", camioncino->quantita);           
            printf("\n");

            // svuoto il camioncino
            struct ordine * corrente = camioncino;
            camioncino = camioncino->next;
            free(corrente);
        }

        if (camioncino != NULL)
        {
            camioncino = NULL;
        }
               
    }
}

int main(int argc, char const *argv[])
{    
    char *BUFFER = malloc(BUFFER_SIZE * sizeof(char));   // questa è una riga 
    char *richiesta = NULL;
    int periodo = 0, capienza = 0;
    int tempo = 0;
    

    struct tabella_ricette *ricettario = crea_ricettario();
    struct tabella_ingredienti *magazzino = crea_magazzino();

    // printf("INIZIO \n");

    if (fgets(BUFFER, BUFFER_SIZE, stdin))    // lettura periodo e capienza
    {
        periodo = atoi(strtok(BUFFER, " \n"));
        capienza = atoi(strtok(NULL, " \n"));
    }
    
    while (fgets(BUFFER, BUFFER_SIZE, stdin)) // fgets(comando, 800, fp)
    {
        richiesta = strtok(BUFFER, " \n");

        if (strcmp(richiesta, "aggiungi_ricetta") == 0)
        {
            char *nome_ricetta = strtok(NULL, " \n");
            struct ricetta * ricetta_letta = inserisci_ricetta(nome_ricetta, ricettario);
            // se la ricetta è null stampo ignorato e non aggiungo ingredienti
            if (ricetta_letta != NULL)
            {
                char *nome_ingrediente = strtok(NULL, " \n");
                while (nome_ingrediente != NULL)
                {
                    int quantita_ingrediente = atoi(strtok(NULL, " \n"));
                    aggiungi_ingrediente(nome_ingrediente, quantita_ingrediente, magazzino, ricetta_letta);
                    nome_ingrediente = strtok(NULL, " \n");
                }
            }
        } 
        if (strcmp(richiesta, "rifornimento") == 0)
        {
            char *nomeLotto = strtok(NULL, " \n");
            while (nomeLotto != NULL)
            {
                int quantita_lotto = atoi(strtok(NULL, " \n"));
                int scadenza = atoi(strtok(NULL, " \n"));
                aggiungi_lotto(nomeLotto, quantita_lotto, scadenza, magazzino);
                nomeLotto = strtok(NULL, " \n");
            }
            controlla_ordini_attesa(tempo);
            printf("rifornito\n");
        }

        if (strcmp(richiesta, "ordine") == 0)
        {
            char *nomeOrdine = strtok(NULL, " \n");
            int a = atoi(strtok(NULL, " "));
            gestione_ordine(nomeOrdine, a, tempo, ricettario);
        } 

        if (strcmp(richiesta, "rimuovi_ricetta") == 0)
        {
            char *nome_ricetta = strtok(NULL, " \n");
            elimina_ricetta(nome_ricetta, ricettario);
        }
        tempo += 1;
        if (((tempo%periodo) == 0))
        {
            gestione_corriere(capienza);
        }
    }

    return 0;
}