Untitled

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

#define BUFFER_SIZE 4999
#define SIZE_TABELLA_INIZIALE 1024

struct lotto
{
    char *nome_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
    struct ordine *next;
};

struct ricetta **ricetta_in_tabella = NULL;
int size_ricettario;
struct ingrediente **ingredienti_in_tabella = NULL;
int size_magazzino;

int numero_elementi_magazzino;
int numero_elementi_ricettario;

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

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

void resize_tabella_ricette()
{

    int new_size = size_ricettario * 2;

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

    for (int i = 0; i < size_ricettario; i++)
    {
        struct ricetta *nodo = 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(ricetta_in_tabella);
    ricetta_in_tabella = copia_ricette;
    size_ricettario = new_size;
}

void resize_tabella_ingredienti()
{
    int new_size = size_magazzino * 2;

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

    for (int i = 0; i < size_magazzino; i++)
    {
        struct ingrediente *nodo = 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(ingredienti_in_tabella);
    ingredienti_in_tabella = copia_ingredienti;
    size_magazzino = new_size;
}

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(char * nome_lotto, int quantita_lotto, int scadenza_lotto)
{
    struct lotto *nuovo_lotto = malloc(sizeof(struct lotto));
    nuovo_lotto->nome_lotto = strdup(nome_lotto);
    nuovo_lotto->quantita = quantita_lotto;
    nuovo_lotto->scadenza = scadenza_lotto;

    nuovo_lotto->next = NULL;

    return nuovo_lotto;
}

struct ingrediente *crea_ingrediente(char *nome)
{
    struct ingrediente *nuovo_ingrediente = malloc(sizeof(struct ingrediente));
    nuovo_ingrediente->nome_ingrediente = strdup(nome);
    nuovo_ingrediente->quantita_totale_lotti = 0;
    nuovo_ingrediente->next = NULL;
    nuovo_ingrediente->lotto_ingrediente = NULL;
    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;
    // ingr_ricetta->nome_ingrediente = strdup(ingrediente_ricetta->nome_ingrediente);
    return ingr_ricetta;
}

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;
    return nuovo_ordine;
}

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

    int index_hash = funzione_hash(nome_ricetta, size_ricettario);
    struct ricetta *ricetta_in_lista = 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 = ricetta_in_tabella[index_hash];
        ricetta_in_tabella[index_hash] = ricetta_nuova;
        numero_elementi_ricettario++;
        if (numero_elementi_ricettario >= size_ricettario * 2)
        {
            resize_tabella_ricette();
        }
        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 ricetta *ricetta_associata)
{
    /*
        calcolo il hash con il nome dell'ingrediente
        trovo l'ingrediente nel magazzino
        se non è presente lo aggiungo
    */

    int index_hash = funzione_hash(nome_ingrediente, size_magazzino);
    struct ingrediente *ingrediente_in_lista = 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)
    {
        // printf("aggiungo nuovo ingrediente da aggiungi_ingrediente ");

        struct ingrediente *nuovo_ingrediente = crea_ingrediente(nome_ingrediente);

        nuovo_ingrediente->next = ingredienti_in_tabella[index_hash];
        ingredienti_in_tabella[index_hash] = nuovo_ingrediente;
        numero_elementi_magazzino++;
        if (numero_elementi_magazzino >= size_magazzino * 2)  //
        {
            resize_tabella_ingredienti();
        }
        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)
{

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

    unsigned long hash = funzione_hash(nome_ricetta, size_ricettario);

    struct ricetta *t = ricetta_in_tabella[hash];
    struct ricetta *prec = NULL;

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

            return;
        }
        prec = t;
        t = t->next;
    }

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

bool cerca_ingrediente_magazzino(char * nome_lotto){
    bool ingrediente_trovato = 0;
    int index_hash = funzione_hash(nome_lotto, size_magazzino);
    struct ingrediente *i = ingredienti_in_tabella[index_hash];
    while (i != NULL)
    {
        if (strcmp(i->nome_ingrediente, nome_lotto) == 0)
        {
            ingrediente_trovato = 1;
            break;
        }
        i = i->next;
    }
    return ingrediente_trovato;

}

void aggiungi_lotto(char *nome_lotto, int quantita_lotto, int scadenza_lotto)
{
    struct lotto *nuovo_lotto = crea_lotto(nome_lotto,quantita_lotto, scadenza_lotto);
    int index_hash = funzione_hash(nome_lotto, size_magazzino);
    if (cerca_ingrediente_magazzino(nome_lotto) == 1)
    {       
        struct ingrediente *ingrediente_associato = ingredienti_in_tabella[index_hash];        
        struct lotto *lotto_temp = ingrediente_associato->lotto_ingrediente;
        struct lotto *prec = NULL;
        while (lotto_temp != NULL) 
        {
            if (lotto_temp->scadenza > scadenza_lotto)
            {
                break;
            } else{
                prec = lotto_temp;
                lotto_temp = lotto_temp->next;
            }               
        }

        if (prec == NULL)
        {
            nuovo_lotto->next = lotto_temp;
            ingrediente_associato->lotto_ingrediente = nuovo_lotto;
        }
        else
        {
            nuovo_lotto->next = lotto_temp;
            prec->next = nuovo_lotto;
        }
        ingrediente_associato->quantita_totale_lotti += quantita_lotto;
    } else{
        // 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 = ingredienti_in_tabella[index_hash];
        ingredienti_in_tabella[index_hash] = nuovo_ingrediente_da_rifornimento;
        numero_elementi_magazzino++;
        if (numero_elementi_magazzino >= size_magazzino * 2)
        {
            resize_tabella_ingredienti();
        }

    }
}
    
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->nome_lotto);
            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 gestione_ordine(char *nome_ordine, int quantita_ordine, int tempo)
{
    int index_hash = funzione_hash(nome_ordine, size_ricettario);
    int ingrediente_trovato = 0;
    struct ricetta *r = 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);

            struct ingrediente_in_ricetta *ingrediente_r = r->ingredienti_ricetta;

            while (ingrediente_r != NULL)
            {
                /* 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;
                
                while (lotto_ingrediente != NULL)
                {
                    if (lotto_ingrediente->scadenza <= 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;
                        // agiorno la quantità totale dei lotti di quel ingrediente
                        ingrediente_r->ingrediente_associato->quantita_totale_lotti -= lotto_ingrediente->quantita;

                        // elimino il lotto scaduto
                        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)
                        break;
                    }
                }

                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 
                    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;
                        }
                    }

                    break;
                }
                else
                {
                    ingrediente_r = ingrediente_r->next;
                    // controllo se è l'ultimo ingrediente, in quel caso lo metto in pronti
                    if (ingrediente_r == NULL)
                    {
                        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 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;

        while (ingrediente_r != NULL)
        {
            /* 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;
            
            while (lotto_ingrediente != NULL)
            {
                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)
                    break;
                }
            }
            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
                prec = a;
                a = a->next;
                break;
            }
            else
            {
                // se i lotti per quel inigrediente sono sufficienti controllo i successivi
                ingrediente_r = ingrediente_r->next;

                if (ingrediente_r == NULL)
                {
                    elimina_lotti_utilizzati(a, a->quantita);
                    struct ordine * ordine_da_aggiungere = crea_ordine(a->nome_ordine, a->quantita, a->istante_di_tempo, a->ricetta_ordine);
                    if (prec == NULL)
                    {
                        ordini_attesa = a->next;
                        scambio_ordini(ordine_da_aggiungere);
                        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;
                        scambio_ordini(ordine_da_aggiungere);
                        a = a->next;
                    }
                }
                
            }
        }
    }
}

int calcola_peso_ordine(struct ordine * ordine){
    int peso_ordine = 0;
    struct ingrediente_in_ricetta * testa_ingredienti = ordine->ricetta_ordine->ingredienti_ricetta;
    while (testa_ingredienti != NULL)
    {
        peso_ordine += testa_ingredienti->quantita * ordine->quantita;
    }
    return peso_ordine;
}

void stampa_camioncino(); 

void gestione_corriere(int capienza)
{

    struct ordine *p = ordini_pronti;
    int quantita_parziale = 0;
    /*
        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 * o = ordini_pronti;
    while (o!=NULL)
    {
        printf("%s", o->nome_ordine); printf(" ");
        o = o->next;
    } */

    while (p != NULL)
    {
        quantita_parziale += (p->ricetta_ordine->peso_ricetta) * p->quantita;
        if (quantita_parziale > capienza)
        {
            break;
        }
        else {
            // aggiungo ordine nel camioncino. L' eliminazione poi degli ordini del camioncino vengo fatti dopo aver stampato
            if (camioncino == NULL)
            {
                ordini_pronti = p->next;
                p->next = NULL;
                camioncino = p;
                p = ordini_pronti;
            }
            else {
                // inserisco in ordine di peso, quindi trovo la posizione in lista
                struct ordine *ord_camioncino = camioncino;
                struct ordine *precedente = NULL;
                int peso_da_aggiungere = ord_camioncino->ricetta_ordine->peso_ricetta * ord_camioncino->quantita ;
                int peso_p = p->ricetta_ordine->peso_ricetta * p->quantita;


                while (ord_camioncino != NULL && peso_da_aggiungere >= peso_p) // metto >= perchè se sono uguali inserisco in ordine di inserimento dell'ordine
                {
                    precedente = ord_camioncino;
                    ord_camioncino = ord_camioncino->next;
                    if (ord_camioncino != NULL)
                    {
                        peso_da_aggiungere = ord_camioncino->ricetta_ordine->peso_ricetta * ord_camioncino->quantita;
                    }
                               
                }

                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;
            }
        }
    }

    stampa_camioncino();

}

void stampa_camioncino(){

    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);
        }
    }
}

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

    numero_elementi_ricettario = 0;
    ricetta_in_tabella = calloc(SIZE_TABELLA_INIZIALE, sizeof(struct ricetta *));
    size_ricettario = SIZE_TABELLA_INIZIALE;

    numero_elementi_magazzino = 0;
    ingredienti_in_tabella = calloc(SIZE_TABELLA_INIZIALE, sizeof(struct tabella_ingredienti *));
    size_magazzino = SIZE_TABELLA_INIZIALE;
    

    // printf("INIZIO \n");

    if (fgets(BUFFER, BUFFER_SIZE, f)) // lettura periodo e capienza
    {
        periodo = atoi(strtok(BUFFER, " \n"));
        capienza = atoi(strtok(NULL, " \n"));
        // printf("%d", periodo);   printf("%d", capienza);
    }

    while (fgets(BUFFER, BUFFER_SIZE, f)) // 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);
            // 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, ricetta_letta);
                    nome_ingrediente = strtok(NULL, " \n");
                }
            }
        } else 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);
                nomeLotto = strtok(NULL, " \n");
            }
            controlla_ordini_attesa(tempo);
            printf("rifornito\n");
        } else if (strcmp(richiesta, "ordine") == 0){
            char *nomeOrdine = strtok(NULL, " \n");
            int a = atoi(strtok(NULL, " "));
            gestione_ordine(nomeOrdine, a, tempo);
        } else if (strcmp(richiesta, "rimuovi_ricetta") == 0){
            char *nome_ricetta = strtok(NULL, " \n");
            elimina_ricetta(nome_ricetta);
        }
        tempo += 1;
        if (((tempo % periodo) == 0))
        {
            gestione_corriere(capienza);
        }
    }

    return 0;
}