//program ristorante

#include <stdio.h>
#include <windows.h>
#include <conio.h>

//funzione per la generazione di numeri random
#define GetRandom(min,max)((rand()%(int)(((max)+1)-(min)))+(min))

#define TAV 5

#define POSTI 6

#define T 1000

#define T1 3000

#define T2 2500

//prototipo di funzione per il thread finito
DWORD finito (LPDWORD lpdwParam);

//prototipo di funzione per il thread clienti
DWORD clienti(LPDWORD lpdwParam);

//vettore di semafori per i tavoli
HANDLE tavoli[TAV];

//variabile globale per la terminazione del programma
int fine=1;

//variabile globale che conta il numero di clienti che hanno pranzato al ristorante
int count=0;

//vettore dei posti che sono disponibili per ogni tavolo
int pfree[TAV]={POSTI,POSTI,POSTI,POSTI,POSTI};

//sezione critica per accedere al vettore dei posti disponibili
CRITICAL_SECTION cs;


/************************************************************************/
/*                 MAIN        PROGRAMM                                    */
/************************************************************************/

void main()
{
    int i;

    //id del gruppo di clienti che arrivano al ristorante
    int id=0;

    //handle per i thread finito e clienti
    HANDLE hfinito, hclienti;

    InitializeCriticalSection(&cs);

    //inzio con la creazione dei semafori
    for (i=0; i<TAV; i++)
        if((tavoli[i]=CreateMutex(NULL,FALSE,NULL))==NULL)
            fprintf(stderr,"Errore creazione mutex %d\n\n",i);

    //creo prima il thread finito e poi i vari thread clienti
    if ((hfinito=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)finito,(LPVOID)&fine,0,NULL))==NULL)
    {
        fprintf(stderr,"Errore creazione thread finito\n\n");
    }
    else
    {
        while (fine)
        {
            if ((hclienti=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)clienti,(LPVOID)id,0,NULL))==NULL)
            {
                fprintf(stderr,"Errore creazione thread clienti\n\n");
            }
            else
            {
                ++id;
            }
            Sleep(T*(GetRandom(1,4)));
        }
        //termino correttamente i thread che sono ancora in esecuzione
        TerminateThread(hclienti,0);

    }
    //stampo le statistiche
    printf("Oggi hanno pranzato %d clienti\n\n\n",count);
}



/************************************************************************/
/*                        THREAD        FINITO                              */
/************************************************************************/

DWORD finito(LPDWORD lpdwParam)
{
    int *finish;
    finish=(int*)lpdwParam;
    getch();
    *finish= 0;
    return 0;
}



/************************************************************************/
/*                     THREAD        CLIENTI                             */
/************************************************************************/
/*
Nota:
Suppongo che in ogni tavolo possano essere sistemati più gruppi (fino a 6 se ho gruppi da 1 cliente)
e che ogni gruppo aspetti un tavolo che abbia posti sufficienti per sedersi.
*/




DWORD clienti(LPDWORD lpdwParam)
{
    //id del gruppo di clienti
    int id;
    id=(int)lpdwParam;

    //booleano per vedere quando un gruppo trova posto
    bool seduto=true;

    DWORD table;

    //numero di clienti nel gruppo
    int nclienti=GetRandom(1,6);

    printf("Gruppo %d: siamo in %d, aspettiamo un tavolo...\n\n",id,nclienti);

    while (seduto)
    {
        //controlla un tavolo per vedere se ci sono abbastanza posti disponibili
        table=WaitForMultipleObjects(TAV,tavoli,FALSE,INFINITE);

        //Se ci sono abbastanza posti il gruppo si accomoda.
        if (pfree[table]>=nclienti) 
        {
            EnterCriticalSection(&cs);
            pfree[table]-=nclienti;
            printf("Gruppo %d: abbiamo trovato posto al tavolo %d\n\n",id,table+1);
            seduto=FALSE;
            ReleaseMutex(tavoli[table]);
            LeaveCriticalSection(&cs);
        }
        //se non ci sono abbastanza posti allora il gruppo cerca un altro tavolo
        else
        {
            ReleaseMutex(tavoli[table]);
        }       
    }

    printf("Gruppo %d: ordiniamo...\n\n",id);
    Sleep(nclienti*T);
    printf("Gruppo %d: abbiamo ordinato, aspettiamo l'ordine...\n\n",id);
    Sleep(T1);
    printf("Gruppo %d: stiamo mangiando...\n\n",id);
    Sleep(T2*(GetRandom(1,4)));

    EnterCriticalSection(&cs);
    printf("Gruppo %d: abbiamo terminato di pranzare. Grazie e arrivederci\n\n",id);
    pfree[table]+=nclienti;
    LeaveCriticalSection(&cs);

    count+=nclienti;

    return 0;
}