#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <stdarg.h>

#include <pthread.h>
#include <semaphore.h>

#define SIZE 5

sem_t forks[SIZE];
pthread_t thread[SIZE];

/* volatile tells the compiler NOT to optimize anything
   where this variable is used. So everytime a thread
   needs this variable it fetches it without caching it
   somewhere. */
volatile int running = 1; // Not in use!

/* Because printf is buffered, I wrote
   this function to prevent anything
   get buffered. */
void printflush(const char* format, ...)
{
    va_list args;
    va_start(args, format);
    vfprintf(stdout, format, args);
    fflush(stdout);
    va_end(args);
}

void* thread_callback(void* arg)
{
    int index = *((int*)arg);
    int lfork;
    int rfork;

    /* calc index of left fork */
    if(index == 0) lfork = SIZE-1;
    else lfork = index - 1;

    /* calc index of left fork */
    if(index == SIZE-1) rfork = 0;
    else rfork = index + 1;

    /* check this every time (useless because I don't change it..) */
    while(running)
    {
        printflush("(%d) Try get left fork ... \n", index);
        sem_wait(&forks[lfork]);

        /* Try to aquire the semaphore, if not unlock left fork, wait and
           try again. */
        printflush("(%d) Got left fork!\n", index);
        if(sem_trywait(&forks[rfork]) != 0)
        {
            /* someone is using semaphore */
            printflush("(%d) Someone is using semaphore ... "
                    "trying later ...\n", index);

            sem_post(&forks[lfork]);
            sleep(1);
            continue;
        }

        printflush("(%d) Got right fork!\nEating ...\n", index);
        sleep(3);

        sem_post(&forks[rfork]);
        printflush("(%d) Released right fork!\n", index);
        sleep(1);

        sem_post(&forks[lfork]);
        printflush("(%d) Released left fork!\n", index);
        sleep(1);
    }

    printflush("(%d) Quit ...\n", index);

    free(arg);
    return NULL;
}

int main(void)
{
    for(int i = 0; i < SIZE; i++)
        sem_init(&forks[i], 0, 1);

    for(int i = 0; i < SIZE; i++)
    {
        int* num = malloc(sizeof(int));
        *num = i;
        pthread_create(&thread[i], NULL, thread_callback, num);
    }

    for(int i = 0; i < SIZE; i++)
        pthread_join(thread[i], NULL);

    return 0;
}