//----------------------------------------------------------------------------------------------------------------
// Importo le librerie necessarie...
//----------------------------------------------------------------------------------------------------------------
#include <windows.h>
#include <time.h>
#include <stddef.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>



//----------------------------------------------------------------------------------------------------------------
// Dichiaro le costanti e le variabili globali...
//----------------------------------------------------------------------------------------------------------------
#define __Capienza 8                    //Definisco una costante per la capienza di ciascun forno
#define __Forni 1                        //Definisco una costante per il numeri di forni
#define __Pizzaioli 2                    //Definisco una costante per il numero di pizzaioli
#define __tp 1000                        //Definisco il tempo di preparazione per ogni singola pizza
#define __tc 3000                        //Definisco il tempo di cottura per ogni singola pizza
HANDLE H_Semaphore_Forni[__Forni];        //l'array di semafori dei forni
HANDLE H_Thread_Pizzaiolo[__Pizzaioli];    //l'array di thread dei pizzaioli
int fine=0;


//----------------------------------------------------------------------------------------------------------------
// Dichiaro le funzioni e le procedure...
//----------------------------------------------------------------------------------------------------------------
#define GetRandom( min, max ) ((rand() % (int)(((max) + 1) - (min))) + (min))
#define randomize srand((unsigned)time(NULL))
void Pizzaiolo(int *i);
HANDLE Finito(LPDWORD lpdwParam);



//----------------------------------------------------------------------------------------------------------------
// Main...
//----------------------------------------------------------------------------------------------------------------
void main()
{
    int i;

    //Creo il thread per gestire la fine...
    CreateThread(NULL,0,(LPTHREAD_START_ROUTINE) Finito,(LPVOID) &fine,0,NULL);

    //Creo un semaforo per ogni forno...
    for(i=0;i<__Forni;i++)
        H_Semaphore_Forni[i] = CreateSemaphore(NULL, __Capienza,__Capienza,NULL);
   
    //Creo i due thread,uno per ogni pizzaiolo
    for (i=0;i<__Pizzaioli;i++)
    {
        H_Thread_Pizzaiolo[i] = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE) Pizzaiolo ,(LPVOID) &i ,0, NULL);
        //Mando in sleep il processo,quanto basta per fare iniziare il thread creato con il corretto valore di i.
        Sleep(1000);
    }
   
    //Inizio attesa attiva
    while (fine == 0);
 
    //Chiudo le risorse...
    for (i=0;i<__Forni;i++)
        CloseHandle(H_Semaphore_Forni[i]);

    for (i=0;i<__Pizzaioli;i++)
        TerminateThread(H_Thread_Pizzaiolo[i],0);
}



//----------------------------------------------------------------------------------------------------------------
// Funzione che gestisce i pizzaioli...
//----------------------------------------------------------------------------------------------------------------
void Pizzaiolo(int *i)
{
    DWORD result,forno_libero[__Capienza];
    int numero_pizze,pizze_infornate,pizze_da_infornare;
    int whois;

    whois = *i + 1;
    while (fine==0)
    {
        //Il Pizzaiolo prende l'ordinazione delle pizze,al massimo 10
        randomize;
        numero_pizze=GetRandom(1,10);
        pizze_infornate=0;

        //le pizze vengono preparate
        printf("***** il Pizzaiolo%i sta preparando %i pizze... *****\n\n",whois,numero_pizze);
        Sleep(numero_pizze * __tp);

        do
        {   
            while ((pizze_infornate<__Capienza) && (pizze_infornate<numero_pizze))
            {
                result=WaitForMultipleObjects(__Forni,H_Semaphore_Forni,false, INFINITE);
                    forno_libero[pizze_infornate]=result-WAIT_OBJECT_0+1;       
                    printf("     il Pizzaiolo%i mette la pizza%i nel forno%d\n",whois,++pizze_infornate,forno_libero[pizze_infornate]);
            }
            printf("  \nil Pizzaiolo%i ha infornato attualmente %i pizze...\n",whois,pizze_infornate);
            Sleep(__tc);
            printf("     le %i pizze del Pizzaiolo%i sono cotte!! Buon Appetito...\n",pizze_infornate,whois);

            for (int i=0;i<pizze_infornate;i++)
                ReleaseSemaphore(H_Semaphore_Forni[forno_libero[i]-1],1,NULL);

            pizze_da_infornare = numero_pizze - pizze_infornate;
            printf("\n-----> ----->il Pizzaiolo%i deve ancora infornare %i pizze\n\n\n",whois,pizze_da_infornare);
            numero_pizze = numero_pizze - pizze_infornate;
            pizze_infornate=0;
        }
        while (pizze_da_infornare>0);
    }
}



//----------------------------------------------------------------------------------------------------------------
// Procedura che determina la fine del programma...
//----------------------------------------------------------------------------------------------------------------
HANDLE Finito(LPDWORD lpdwParam)
{
    int *fine;
    fine=(int*)lpdwParam;
    getch();
    *fine=1;

    return 0;
}