#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <stdbool.h>


#define THREAD 15
#define MAX (THREAD/2)-2

pthread_cond_t impiegato1_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t impiegato1_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t impiegato2_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t impiegato2_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t fila1_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex_abitanti_in_fila1 = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t fila2_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex_abitanti_in_fila2 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t fila1_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t fila2_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t responsabile_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t responsabile_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t primo_posto_fila1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t primo_posto_fila2 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t rimanenti1_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t rimanenti2_mutex = PTHREAD_MUTEX_INITIALIZER;

void abitante (int id);
void responsabile();
void impiegato1();
void impiegato2();

const int S=THREAD;
int B1=MAX;
int B2=MAX;

int abitanti_in_fila1=0;
int abitanti_in_fila2=0;
int rimanenti1=THREAD;
int rimanenti2=THREAD;
int test=1;

bool svegliato_da_impiegato1=false;
bool svegliato_da_impiegato2=false;

void main()
{

    int id;
    pthread_t responsabile_t, *abitante_t, impiegato1_t, impiegato2_t;

    pthread_create( &responsabile_t, NULL, (void *) &responsabile, NULL);
    pthread_create( &impiegato1_t, NULL, (void *) &impiegato1, NULL);
    pthread_create( &impiegato2_t, NULL, (void *) &impiegato2, NULL);

    sleep(0.1);/*giusto per essere sicuri che gli abitanti siano creati DOPO impiegati e responsabile*/

    for(id=0;id<S;id++)
    {
        abitante_t = (pthread_t *) malloc(sizeof(pthread_t));
        pthread_create(abitante_t, NULL, (void *) &abitante, (void *) (id+1));
    }
    pthread_join(*abitante_t,NULL);

            return;
}

void responsabile()
{
    printf("Responsabile creato\n");
    pthread_cond_wait(&responsabile_cond, &responsabile_mutex);

    while(rimanenti1>0 || rimanenti2>0)
    {
        printf("Responsabile svegliato\n");

        if(svegliato_da_impiegato1 == true)
        {
            printf("Responsabile svegliato da impiegato 1\n");
            B1=MAX;
            printf("Responsabile rifornisce i b1\n");
            pthread_cond_signal (&impiegato1_cond);
            printf("Responsabile manda signal a impiegato1 e si rimette in wait\n");
            svegliato_da_impiegato1=false;
            pthread_cond_wait(&responsabile_cond, &responsabile_mutex);
        }
        if(svegliato_da_impiegato2 == true)
        {
            printf("Responsabile svegliato da impiegato 2\n");
            B2=MAX;
            printf("Responsabile rifornisce i b2\n");
            pthread_cond_signal (&impiegato2_cond);
            printf("Responsabile manda signal a impiegato2 e si rimette in wait\n");
            svegliato_da_impiegato2=false;
            pthread_cond_wait(&responsabile_cond, &responsabile_mutex);
        }
    }
}

void impiegato1()
{
    printf("Impiegato1 creato\n");
    pthread_cond_wait (&impiegato1_cond, &impiegato1_mutex);
    printf("Impiegato1 svegliato\n");


    while(rimanenti1>0 || rimanenti2>0)
    {
        pthread_mutex_lock(&primo_posto_fila1);
        printf("Impiegato 1 all'inizio del while\n");
        if(B1==0)
        {
            printf("Biglietti 1 finiti!!\n");
            printf("Impiegato 1 blocca mutex responsabile\n");
            pthread_mutex_lock(&responsabile_mutex);
            svegliato_da_impiegato1=true;
            printf("Impiegato 1 sveglia responsabile\n");
            pthread_cond_signal(&responsabile_cond);
            printf("Impiegato 1 si mette in attesa\n");
            pthread_cond_wait(&impiegato1_cond, &impiegato1_mutex);
            printf("Impiegato 1 svegliato da responsabile\n");
        }

        printf("Impiegato 1 consegna biglietto\n");
        B1--;
        printf("Ora ci sono %d biglietti 1 rimasti\n",B1);
        printf("Impiegato 1 manda signal a fila 1\n");
        pthread_cond_signal(&fila1_cond);
        pthread_mutex_unlock(&fila1_mutex);
        printf("Impiegato 1 si mette in wait in attesa del prossimo abitante\n");
        pthread_cond_wait(&impiegato1_cond, &primo_posto_fila1);
        printf("Impiegato 1 esce dal wait\n");
    }
    printf("Impiegato 1 distrutto\n");
    pthread_exit(NULL);
}

void impiegato2()
{
    printf("Impiegato2 creato\n");
    pthread_cond_wait (&impiegato2_cond, &impiegato2_mutex);
    printf("Impiegato2 svegliato\n");
    while(rimanenti1>0 || rimanenti2>0)
    {
        printf("Impiegato 2 all'inizio del while\n");
        if(B2==0)
        {
            printf("Biglietti 2 finiti!!\n");
            printf("Impiegato 2 blocca mutex responsabile\n");
            pthread_mutex_lock(&responsabile_mutex);
            svegliato_da_impiegato2=true;
            printf("Impiegato 2 sveglia responsabile\n");
            pthread_cond_signal(&responsabile_cond);
            printf("Impiegato 2 si mette in attesa\n");
            pthread_cond_wait(&impiegato2_cond, &impiegato2_mutex);
            printf("Impiegato 2 svegliato da responsabile\n");
        }

        printf("Impiegato 2 consegna biglietto\n");
        B2--;
        printf("Ora ci sono %d biglietti 2 rimasti\n",B2);
        printf("Impiegato 2 manda signal a fila 2\n");
        pthread_cond_signal(&fila2_cond);
        pthread_mutex_unlock(&fila2_mutex);
        printf("Impiegato 2 si mette in wait in attesa del prossimo abitante\n");
        pthread_cond_wait(&impiegato2_cond, &primo_posto_fila2);
        printf("Impiegato 2 esce dal wait\n");
    }
    printf("Impiegato 2 distrutto\n");
    pthread_exit(NULL);
}

void abitante(int id)
{
    printf("Abitante %d creato\n",id);
    int fila;
    bool possiedo_biglietto1 = false;
    bool possiedo_biglietto2 = false;

    /*Scelta della fila: l'abitante andrà nella fila con meno persone,
     * o, in caso di parità, nella fila1*/

    if(abitanti_in_fila1<abitanti_in_fila2)
    {
        fila=1;
        pthread_mutex_lock(&mutex_abitanti_in_fila1);
        abitanti_in_fila1++;
        pthread_mutex_unlock(&mutex_abitanti_in_fila1);
        printf("Abitante %d in fila 1\n",id);
    }
    else
    {
        fila=2;
        pthread_mutex_lock(&mutex_abitanti_in_fila2);
        abitanti_in_fila2++;
        pthread_mutex_unlock(&mutex_abitanti_in_fila2);
        printf("Abitante %d in fila 2\n",id);
    }

    while(possiedo_biglietto1==false || possiedo_biglietto2 == false)
    {
        if(fila==1)
        {
            printf("Abitante %d prova a bloccare mutex fila 1.\n",id);
            //pthread_mutex_lock(&primo_posto_fila1);
            printf("Abitante %d è riuscito a bloccare mutex fila 1\n",id);
            printf("Abitante %d manda signal a impiegato 1\n",id);
            pthread_cond_signal(&impiegato1_cond);
            printf("Abitante %d mette in wait se stesso e la fila 1\n",id);
            pthread_cond_wait(&fila1_cond,&fila1_mutex);
            printf("Abitante %d è stato svegliato e ha il biglietto 1\n",id);

            pthread_mutex_unlock(&impiegato1_mutex);
            possiedo_biglietto1=true;
            pthread_mutex_lock(&rimanenti1_mutex);
            rimanenti1--;
            pthread_mutex_unlock(&rimanenti1_mutex);

            if(possiedo_biglietto2==false)
            {
                printf("Abitante %d in fila 2\n",id);
                fila=2;
            }
        }

        if(fila==2)
        {
            printf("Abitante %d prova a bloccare mutex fila 2.\n",id);
            pthread_mutex_lock(&primo_posto_fila2);
            printf("Abitante %d è riuscito a bloccare mutex fila 2\n",id);
            printf("Abitante %d manda signal a impiegato 2\n",id);
            pthread_cond_signal(&impiegato2_cond);
            printf("Abitante %d mette in wait se stesso e la fila 2\n",id);
            pthread_cond_wait(&fila2_cond,&fila2_mutex);
            printf("Abitante %d è stato svegliato e ha il biglietto 2\n",id);
            pthread_mutex_unlock(&impiegato2_mutex);
            possiedo_biglietto2=true;
            pthread_mutex_lock(&rimanenti2_mutex);
            rimanenti2--;
            pthread_mutex_unlock(&rimanenti2_mutex);

            if(possiedo_biglietto1==false)
            {
                printf("Abitante %d in fila 1\n",id);
                fila=1;
            }

        }
    }
    printf("L'abitante %d ha tutti i biglietti!\n In tutto %d abitanti hanno tutti i biglietti\n",id,test);
    test++;
    printf("Abitante %d distrutto\n",id);
    pthread_exit(NULL);
}