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

#define N 3

// Struttura di un nodo della coda thread-safe
typedef struct node {
    int value;
    struct node *next;
} node;

// Struttura della coda thread-safe (usa una linked list)
typedef struct queue_t {
    node *front;
    node *prev;
    //dispatch_semaphore_t mutex;
    //dispatch_semaphore_t popsem;
    sem_t mutex;
    sem_t popsem;
} Queue;

Queue *queue;

// crea una coda vuota
Queue* qcreate()
{
    // crea la coda
    Queue *queue = malloc(sizeof(Queue));

    // inizializza la coda
    queue->front = NULL;
    queue->prev  = NULL;
    sem_init(&queue->mutex, 0, 1);
    //dispatch_semaphore_t *mut = &queue->mutex;
    //*mut = dispatch_semaphore_create(1);
    sem_init(&queue->mutex, 0, 0);
    //dispatch_semaphore_t *sem = &queue->popsem;
    //*sem = dispatch_semaphore_create(0);
    return queue;
}

// Inserisce un elemento nella coda
void qpush(Queue* queue, int value, int npers)
{
    //dispatch_semaphore_wait(queue->mutex, DISPATCH_TIME_FOREVER);
    sem_wait(&queue->mutex);
    printf("Sono %d e ho il mutex\n", npers);

    // creazione di un nuovo nodo
    node *temp = malloc(sizeof(struct node));
    temp->value = value;
    temp->next  = NULL;

    // verifico se la coda è vuota
    if (queue->front == NULL) {
        //in questo caso front e prev coincidono
        queue->front = temp;
        queue->prev  = temp;
        printf("Inserisco nella coda il valore: %d, e faccio post su popsem\n", value);
        sem_post(&queue->popsem);
        //dispatch_semaphore_signal(queue->popsem);
    }
    else {
        //aggiunta di un elemento
        node *old_prev = queue->prev;
        old_prev->next = temp;
        queue->prev = temp;
        printf("Inserisco nella coda il valore: %d\n", value);
    }

    sem_post(&queue->mutex);
    printf("Sono %d e ho lasciato il mutex\n", npers);
    //dispatch_semaphore_signal(queue->mutex);
}

// Estrae un elemento dalla coda
void qpop(Queue* queue, int *value, int npers)
{
    sem_wait(&queue->mutex);
    printf("Sono %d e ho il mutex\n", npers);
    //dispatch_semaphore_wait(queue->mutex, DISPATCH_TIME_FOREVER);

    // verifico se la coda è vuota
    node *front = queue->front;

    if (front != NULL) {
        // lettura del valore ed cancellazione dell'elemento dalla coda
        *value = front->value;
        queue->front = front->next;
        free(front);
        printf("Estraggo dalla coda il valore: %d\n", *value);
        //sem_post(&queue->popsem);
        //dispatch_semaphore_signal(queue->popsem);
    } else {
        printf("la coda è vuota, mi blocco:\n");
    }
    sem_post(&queue->mutex);
    printf("Sono %d e ho lasciato mutex\n", npers);
    //dispatch_semaphore_signal(queue->mutex);
    sem_wait(&queue->popsem);
    //dispatch_semaphore_wait(queue->popsem, DISPATCH_TIME_FOREVER);
}

void qdestroy (Queue* queue){
    sem_destroy(&queue->mutex);
    sem_destroy(&queue->popsem);
    free(queue);
}
void *persona(void *arg){
    int numeropersona = *(int *)arg;
    int info;
    int infoo;
    for (int i = 0; i < N; i++)
    {
        int fval = rand()%10 + 1;
        int sval = rand()%10 + 1;
//        printf("Sono persona %d e voglio inserire %d\n", numeropersona, fval);
        qpush(queue, fval,numeropersona);
        qpop(queue, &info, numeropersona);
//        printf("Sono persona %d e ho estratto %d\n", numeropersona, info);
        qpop(queue, &infoo, numeropersona);
//        printf("Sono persona %d e ho estratto2 %d\n", numeropersona, infoo);
//        printf("Sono persona %d e voglio inserire %d\n", numeropersona, sval);
        qpush(queue, sval, numeropersona);
    }

    pthread_exit(0);
}


int main(){
    pthread_attr_t a;
    pthread_t persone[N];
    int numeropersona[N];

    queue = qcreate();
    printf("Coda creata\n");

    pthread_attr_init(&a);

    for(int i=0; i < N; i++){
        numeropersona[i] = i;
        printf("Sto per creare il thread %d-esimo persona\n", numeropersona[i]);
        pthread_create(&persone[i], &a, persona, &numeropersona[i]);
    }

    for(int i=0; i < N; i++){
        void *ret;
        pthread_join(persone[i], &ret);
    }
    qdestroy(queue);

    return 0;
}