//----------------------------------------------------------------------------------------------------------------
// 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 __Wait_Object_Time 1000                             //Definisco un tempo di attesa limitato (100 secondi)
#define __Timerun 2500                                        //Definisco una costante per il tempo di percorrenza di ogni tragitto
#define __T1_Timewait 5000                                    //Definisco una costante per il tempo di attesa del treno T1
#define __T2_Timewait 2000                                    //Definisco una costante per il tempo di attesa del treno T2
#define __T3_Timewait 3000                                    //Definisco una costante per il tempo di attesa del treno T3
#define __Multi_Train 2                                        //Definisco il numero di treni che possono viaggiare sullo stesso binario,solo se vanno nella stessa direzione
#define __tragitti_andata 2                                 //Definisco una costante per il numeri di tragitti all'andata
#define __tragitti_ritorno 2                                //Definisco una costante per il numeri di tragitti al ritorno
HANDLE H_Semaphore_Tragitto_Andata[__tragitti_andata];        //l'array di semafori dei tragitti dell'andata
HANDLE H_Semaphore_Tragitto_Ritorno[__tragitti_ritorno];        //l'array di semafori dei tragitti del ritorno
//----------------------------------------------------------------------------------------------------------------
// Dichiaro le funzioni e le procedure...
//----------------------------------------------------------------------------------------------------------------
#define GetRandom( min, max ) ((rand() % (int)(((max) + 1) - (min))) + (min))
#define randomize srand((unsigned)time(NULL))
void T1(int *fine);
void T2(int *fine);
void T3(int *fine);
HANDLE Finito(LPDWORD lpdwParam);
//----------------------------------------------------------------------------------------------------------------
// Main...
//----------------------------------------------------------------------------------------------------------------
void main()
{
    int i,fine=0;
    //Creo il thread per gestire la fine...
    CreateThread(NULL,0,(LPTHREAD_START_ROUTINE) Finito,(LPVOID) &fine,0,NULL);
    //Creo un semaforo per ogni tragitto dell'andata...
    for(i=0;i<__tragitti_andata;i++)
        H_Semaphore_Tragitto_Andata[i] = CreateSemaphore(NULL, __Multi_Train,__Multi_Train,NULL);
    //Creo un semaforo per ogni tragitto del ritorno...
    for(i=0;i<__tragitti_ritorno;i++)
        H_Semaphore_Tragitto_Ritorno[i] = CreateSemaphore(NULL, __Multi_Train,__Multi_Train,NULL);
   
    //Creo i 3 thread,uno per ogni treno...
    CreateThread(NULL,0,(LPTHREAD_START_ROUTINE) T1 ,(LPVOID) &fine ,0, NULL);
    CreateThread(NULL,0,(LPTHREAD_START_ROUTINE) T2 ,(LPVOID) &fine ,0, NULL);
    CreateThread(NULL,0,(LPTHREAD_START_ROUTINE) T3 ,(LPVOID) &fine ,0, NULL);
   
    //Inizio attesa attiva
    while (fine == 0);
}
//----------------------------------------------------------------------------------------------------------------
// Funzione che gestisce il treno T1...
//----------------------------------------------------------------------------------------------------------------
void T1(int *fine)
{
    int pos=0;
    while (*fine == 0)
    {
        if ( (pos == 0) && ( WaitForMultipleObjects(__tragitti_ritorno,H_Semaphore_Tragitto_Ritorno,true,(__Wait_Object_Time * __T1_Timewait) ) != WAIT_TIMEOUT ) )
        {
            printf("*** T1 ***     si assicura che nessun treno gli vada contro...\n");
            if ( (pos == 0) && ( WaitForMultipleObjects(__tragitti_ritorno,H_Semaphore_Tragitto_Ritorno,true,(__Wait_Object_Time * __T1_Timewait) ) != WAIT_TIMEOUT ) )
            {
                printf("*** T1 ***     controllo superato,attende il permesso per partire...\n");
                if ( WaitForMultipleObjects(__tragitti_andata,H_Semaphore_Tragitto_Andata,true,(__Wait_Object_Time * __T1_Timewait) ) != WAIT_TIMEOUT )
                {
                    pos = 1;
                    printf("*** T1 ***     e' partito dalla stazione A\n");
                    ReleaseSemaphore(H_Semaphore_Tragitto_Ritorno[0],2,NULL);
                    ReleaseSemaphore(H_Semaphore_Tragitto_Ritorno[1],2,NULL);
                    Sleep(__Timerun );
                    ReleaseSemaphore(H_Semaphore_Tragitto_Andata[0],1,NULL);
                    printf("*** T1 ***     e' appena passato dalla stazione B\n");
                    Sleep(__Timerun );
                    ReleaseSemaphore(H_Semaphore_Tragitto_Andata[1],1,NULL);
                    printf("*** T1 ***     e' arrivato alla stazione C\n");
                }
            }
            else
            {
                ReleaseSemaphore(H_Semaphore_Tragitto_Ritorno[0],1,NULL);
                ReleaseSemaphore(H_Semaphore_Tragitto_Ritorno[1],1,NULL);
            }
        }
       
        printf("*** T1 ***     fa una sosta alla stazione C\n");
        Sleep(__T1_Timewait);
        if ( (pos == 1) && ( WaitForMultipleObjects(__tragitti_andata,H_Semaphore_Tragitto_Andata,true,(__Wait_Object_Time * __T1_Timewait) ) != WAIT_TIMEOUT ) )
        {
            printf("*** T1 ***     si assicura che nessun treno gli vada contro...\n");
            if ( (pos == 1) && ( WaitForMultipleObjects(__tragitti_andata,H_Semaphore_Tragitto_Andata,true,(__Wait_Object_Time * __T1_Timewait) ) != WAIT_TIMEOUT ) )
            {
                printf("*** T1 ***     controllo superato,attende il permesso per partire...\n");
                if ( WaitForMultipleObjects(__tragitti_ritorno,H_Semaphore_Tragitto_Ritorno,true,(__Wait_Object_Time * __T1_Timewait) ) != WAIT_TIMEOUT )
                {
                    pos = 0;
                    printf("*** T1 ***     e' partito dalla stazione C\n");
                    ReleaseSemaphore(H_Semaphore_Tragitto_Andata[0],2,NULL);
                    ReleaseSemaphore(H_Semaphore_Tragitto_Andata[1],2,NULL);
                    Sleep(__Timerun );
                    ReleaseSemaphore(H_Semaphore_Tragitto_Ritorno[1],1,NULL);
                    printf("*** T1 ***     e' appena passato dalla stazione B\n");
                    Sleep(__Timerun );
                    ReleaseSemaphore(H_Semaphore_Tragitto_Ritorno[0],1,NULL);
                    printf("*** T1 ***     e' arrivato alla stazione A\n");
                }
            }
            else
            {
                ReleaseSemaphore(H_Semaphore_Tragitto_Andata[0],1,NULL);
                ReleaseSemaphore(H_Semaphore_Tragitto_Andata[1],1,NULL);
            }
        }
       
        printf("*** T1 ***     fa una sosta alla stazione A\n");
        Sleep(__T1_Timewait);
    }
}
//----------------------------------------------------------------------------------------------------------------
// Funzione che gestisce il treno T2...
//----------------------------------------------------------------------------------------------------------------
void T2(int *fine)
{
    int pos=0;
    while (*fine == 0)
    {
        if ( (pos == 0) && ( WaitForSingleObject(H_Semaphore_Tragitto_Ritorno[0],(__Wait_Object_Time * __T2_Timewait) ) != WAIT_TIMEOUT ) )
        {
            printf("*** T2 ***     si assicura che nessun treno gli vada contro...\n");
            if ( (pos == 0) && ( WaitForSingleObject(H_Semaphore_Tragitto_Ritorno[0],(__Wait_Object_Time * __T2_Timewait) ) != WAIT_TIMEOUT ) )
            {
                printf("*** T2 ***     controllo superato,attende il permesso per partire...\n");
                if ( WaitForSingleObject(H_Semaphore_Tragitto_Andata[0],(__Wait_Object_Time * __T2_Timewait) ) != WAIT_TIMEOUT )
                {
                    pos = 1;
                    printf("*** T2 ***     e' partito dalla stazione A\n");
                    ReleaseSemaphore(H_Semaphore_Tragitto_Ritorno[0],2,NULL);
                    Sleep(__Timerun );
                    ReleaseSemaphore(H_Semaphore_Tragitto_Andata[0],1,NULL);
                    printf("*** T2 ***     e' arrivato alla stazione B\n");
                }
            }
            else
                ReleaseSemaphore(H_Semaphore_Tragitto_Ritorno[0],1,NULL);
        }
       
        printf("*** T2 ***     fa una sosta alla stazione B\n");
        Sleep(__T2_Timewait);
        if ( (pos == 1) && ( WaitForSingleObject(H_Semaphore_Tragitto_Andata[0],(__Wait_Object_Time * __T2_Timewait) ) != WAIT_TIMEOUT ) )
        {
            printf("*** T2 ***     si assicura che nessun treno gli vada contro...\n");
            if ( (pos == 1) && ( WaitForSingleObject(H_Semaphore_Tragitto_Andata[0],(__Wait_Object_Time * __T2_Timewait) ) != WAIT_TIMEOUT ) )
            {
                printf("*** T2 ***     controllo superato,attende il permesso per partire...\n");
                if ( WaitForSingleObject(H_Semaphore_Tragitto_Ritorno[0],(__Wait_Object_Time * __T2_Timewait) ) != WAIT_TIMEOUT )
                {
                    pos = 0;
                    printf("*** T2 ***     e' partito dalla stazione B\n");
                    ReleaseSemaphore(H_Semaphore_Tragitto_Andata[0],2,NULL);
                    Sleep(__Timerun );
                    ReleaseSemaphore(H_Semaphore_Tragitto_Ritorno[0],1,NULL);
                    printf("*** T2 ***     e' arrivato alla stazione A\n");
                }
            }
            else
                ReleaseSemaphore(H_Semaphore_Tragitto_Andata[0],1,NULL);
        }
       
        printf("*** T2 ***     fa una sosta alla stazione A\n");
        Sleep(__T2_Timewait);
    }
}
//----------------------------------------------------------------------------------------------------------------
// Funzione che gestisce il treno T3...
//----------------------------------------------------------------------------------------------------------------
void T3(int *fine)
{
    int pos=0;
    while (*fine == 0)
    {
        if ( (pos == 0) && ( WaitForSingleObject(H_Semaphore_Tragitto_Ritorno[1],(__Wait_Object_Time * __T3_Timewait) ) != WAIT_TIMEOUT ) )
        {
            printf("*** T3 ***     si assicura che nessun treno gli vada contro...\n");
            if ( (pos == 0) && ( WaitForSingleObject(H_Semaphore_Tragitto_Ritorno[1],(__Wait_Object_Time * __T3_Timewait) ) != WAIT_TIMEOUT ) )
            {
                printf("*** T3 ***     controllo superato,attende il permesso per partire...\n");
                if ( WaitForSingleObject(H_Semaphore_Tragitto_Andata[1],(__Wait_Object_Time * __T3_Timewait) ) != WAIT_TIMEOUT )
                {
                    pos = 1;
                    printf("*** T3 ***     e' partito dalla stazione B\n");
                    ReleaseSemaphore(H_Semaphore_Tragitto_Ritorno[1],2,NULL);
                    Sleep(__Timerun );
                    ReleaseSemaphore(H_Semaphore_Tragitto_Andata[1],1,NULL);
                    printf("*** T3 ***     e' arrivato alla stazione C\n");
                }
            }
            else
                ReleaseSemaphore(H_Semaphore_Tragitto_Ritorno[1],1,NULL);
        }
       
        printf("*** T3 ***     fa una sosta alla stazione C\n");
        Sleep(__T3_Timewait);
        if ( (pos == 1) && ( WaitForSingleObject(H_Semaphore_Tragitto_Andata[1],(__Wait_Object_Time * __T3_Timewait) ) != WAIT_TIMEOUT ) )
        {
            printf("*** T3 ***     si assicura che nessun treno gli vada contro...\n");
            if ( (pos == 1) && ( WaitForSingleObject(H_Semaphore_Tragitto_Andata[1],(__Wait_Object_Time * __T3_Timewait) ) != WAIT_TIMEOUT ) )
            {
                printf("*** T3 ***     controllo superato,attende il permesso per partire...\n");
                if ( WaitForSingleObject(H_Semaphore_Tragitto_Ritorno[1],(__Wait_Object_Time * __T3_Timewait) ) != WAIT_TIMEOUT )
                {
                    pos = 0;
                    printf("*** T3 ***     e' partito dalla stazione C\n");
                    ReleaseSemaphore(H_Semaphore_Tragitto_Andata[1],2,NULL);
                    Sleep(__Timerun );
                    ReleaseSemaphore(H_Semaphore_Tragitto_Ritorno[1],1,NULL);
                    printf("*** T3 ***     e' arrivato alla stazione B\n");
                }
            }
            else
                ReleaseSemaphore(H_Semaphore_Tragitto_Andata[1],1,NULL);
        }
       
        printf("*** T3 ***     fa una sosta alla stazione B\n");
        Sleep(__T3_Timewait);
    }
}
//----------------------------------------------------------------------------------------------------------------
// Procedura che determina la fine del programma...
//----------------------------------------------------------------------------------------------------------------
HANDLE Finito(LPDWORD lpdwParam)
{
    int *fine;
    fine=(int*)lpdwParam;
    getch();
    *fine=1;
    return 0;
}