Restaurant Fast Food

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

#define MIN(a, b) ((a) < (b) ? (a) : (b)) // functie care calculeaza minimul

typedef struct nod{
    int timp;
    char nume[30];
    struct nod *next;
}NOD;

NOD *creare_nod(){
    NOD *nod_nou = malloc(sizeof(NOD)); // alocam memorie
    scanf("%d%s", &nod_nou -> timp, nod_nou -> nume); // citim valorile
    nod_nou -> next = NULL;
    return nod_nou;
}

NOD *adauga_comanda(NOD *head){
    NOD *nod_nou = creare_nod();
    if(head == NULL) // verificam daca lista e goala
        return nod_nou;

    NOD *nod = head;
    while(nod->next)//parcurgem lista pana ajungem la ultimul element
        nod = nod->next;
    nod -> next = nod_nou; // adaugam elementul la finalul listei
    return head;
}

NOD *gatire_aragaz(NOD *aragaz, int t){ // functia simuleaza folosirea unui aragaz
    NOD *nod = aragaz;
    if(nod == NULL){
        return nod;
    }
    nod -> timp -= t;
    if(nod -> timp == 0){ // comanda e finalizata
        printf("%s\n", aragaz -> nume);
        aragaz = aragaz -> next; // eliberam aragazul
        free(nod);
    }
    return aragaz;
}

void urmatoarea_comanda(NOD **comenzi, NOD **aragaz){
    NOD *nod = NULL;
    // verificam daca aragazul este liber
    if(*aragaz == NULL && *comenzi){
        // daca e liber, alocam memorie si punem in pregatire primul element din lista de comenzi
        (*aragaz) = malloc(sizeof(NOD));
        strcpy((*aragaz) -> nume, (*comenzi)->nume);
        (*aragaz) -> timp = (*comenzi) -> timp;
        (*aragaz) -> next = NULL;

        nod = *comenzi;
        *comenzi = (*comenzi)->next; // actualizam lista de comenzi
        free(nod); // eliberam memoria pentru comanda in pregatire
    }
}

void urmatoarea_comanda_caz2(NOD **comenzi, NOD **aragaz, int cond) {
    // Verificăm dacă aragazul este liber și există comenzi
    if (*aragaz == NULL && *comenzi) {
        // Dacă prima comandă satisface condiția, o preluăm
        if ((cond && (*comenzi)->timp <= 15) || (!cond && (*comenzi)->timp > 15)) {
            *aragaz = *comenzi;
            *comenzi = (*comenzi)->next;
            (*aragaz)->next = NULL;  // Eliminăm conexiunea nodului cu lista
        } else {
            // Parcurgem lista pentru a găsi o comandă care satisface condiția
            NOD *prev = *comenzi;
            NOD *current = (*comenzi)->next;

            while (current) {
                if ((cond && current->timp <= 15) || (!cond && current->timp > 15)) {
                    *aragaz = current;        // Mutăm nodul pe aragaz
                    prev->next = current->next; // Sărim peste nodul selectat
                    (*aragaz)->next = NULL;  // Eliminăm conexiunea nodului cu lista
                    break;
                }
                prev = current;
                current = current->next;
            }
        }
    }
}


int verif(NOD *a1, NOD *a2, NOD *a3){
    if(a1 && a2 && a3) return 1;   // Toate ocupate
    if(a1 && a2 == NULL && a3 == NULL) return 5;   // Doar a1 ocupat
    if(a1 == NULL && a2 && a3 == NULL) return 6;   // Doar a2 ocupat
    if(a1 == NULL && a2 == NULL && a3) return 7;   // Doar a3 ocupat
    if(a1 && a2 == NULL && a3) return 3;   // A1 și A3 ocupate
    if(a1 && a2 == NULL && a3 == NULL) return 5;   // Doar A1 ocupat
    if(a1 == NULL && a2 && a3 == NULL) return 6;   // Doar A2 ocupat
    return 4;   // Toate goale sau o combinație
}

void gateste(NOD **comenzi, int timp, int tip, NOD **aragaz1, NOD **aragaz2, NOD **aragaz3){
    NOD *nod = NULL;
    switch(tip){
        // un singur aragaz
        case 0:{
            while(timp && (comenzi || aragaz1)){
                urmatoarea_comanda(comenzi, aragaz1);
                int t = MIN((*aragaz1)->timp, timp);
                timp -= t;
                *aragaz1 = gatire_aragaz(*aragaz1, t);
            }
            break;
        }
        // 3 aragazuri
        case 1:{
            while(timp > 0 && (*comenzi || *aragaz1 || *aragaz2 || *aragaz3)){
                urmatoarea_comanda(comenzi, aragaz1);
                urmatoarea_comanda(comenzi, aragaz2);
                urmatoarea_comanda(comenzi, aragaz3);

                int t = MIN((*aragaz1 ? (*aragaz1)->timp : 1000000),
                            MIN((*aragaz2 ? (*aragaz2)->timp : 1000000),
                                (*aragaz3 ? (*aragaz3)->timp : 10000000)));

                // Determină pentru ce timp actualizam procesul
                t = MIN(t, timp);

                if (*aragaz1) *aragaz1 = gatire_aragaz(*aragaz1, t);
                if (*aragaz2) *aragaz2 = gatire_aragaz(*aragaz2, t);
                if (*aragaz3) *aragaz3 = gatire_aragaz(*aragaz3, t);

                timp -= t;
            }
            break;
        }
        // 2 aragazuri + unul pentru comezni <= 15 minute
        case 2:{
            while(timp > 0 && (*comenzi || *aragaz1 || *aragaz2 || *aragaz3)){
                //aragazul 1 este pentru comenzi <= 15 minute
                urmatoarea_comanda_caz2(comenzi, aragaz1, 1);
                urmatoarea_comanda_caz2(comenzi, aragaz2, 0);
                urmatoarea_comanda_caz2(comenzi, aragaz3, 0);

                int t = MIN((*aragaz1 ? (*aragaz1)->timp : 1000000),
                            MIN((*aragaz2 ? (*aragaz2)->timp : 1000000),
                                (*aragaz3 ? (*aragaz3)->timp : 10000000)));

                // Determină pentru ce timp actualizam procesul
                t = MIN(t, timp);

                if (*aragaz1) *aragaz1 = gatire_aragaz(*aragaz1, t);
                if (*aragaz2) *aragaz2 = gatire_aragaz(*aragaz2, t);
                if (*aragaz3) *aragaz3 = gatire_aragaz(*aragaz3, t);

                timp -= t;
            }
            break;
        }
        default:
            break;
    }
}

void timp_comanda(NOD *head, NOD *a1, NOD *a2, NOD *a3){
    if(a1 || a2 || a3){
        if(a1 && a2 == NULL && a3 == NULL)
            printf("%d\n", a1->timp);
        else if(a1 == NULL && a2 && a3 == NULL)
            printf("%d\n", a2->timp);
        else if(a1 == NULL && a2 == NULL && a3)
            printf("%d\n", a3->timp);
        else if(a1 && a2 && a3 == NULL)
            printf("%d\n", MIN(a2->timp, a1->timp));
        else if(a1 && a2 == NULL && a3)
            printf("%d\n", MIN(a3->timp, a1->timp));
        else if(a1 == NULL && a2 && a3)
            printf("%d\n", MIN(a2->timp, a3->timp));
        else
            printf("%d\n", MIN(a2->timp, MIN(a1->timp, a3->timp)));
    }
    else if(head)
        printf("%d\n", head->timp);
    else
        printf("Nu avem comenzi in pregatire\n");
}

int main(){
    char comanda;
    int tip_restaurant;
    NOD *comenzi = NULL, *aragaz1 = NULL, *aragaz2 = NULL, *aragaz3 = NULL;

    scanf("%d", &tip_restaurant);
    getchar(); // citim '\n'

    while((comanda = getchar())!= EOF){
        if(comanda == '+'){
            comenzi = adauga_comanda(comenzi);

        }
        else if(comanda == '-'){
            int timp;
            scanf("%d", &timp);
            gateste(&comenzi, timp, tip_restaurant, &aragaz1, &aragaz2, &aragaz3);
        }
        else if(comanda == '?'){
            timp_comanda(comenzi, aragaz1, aragaz2, aragaz3);
        }
    }

    return 0;
}