/************************************************************
  File:          solution2.cc
  Description:   A program that simulates the problem of the 
                 five philosophers.
                                                         
  Author:        Dana Vrajitoru                          
  Organization:  IUSB                                    
  Date:          August 22, 2018
**************************************************************/

#include <cstdlib>
#include <iostream>
using namespace std;
#include <cmath>
#include "solution2.h"

int forks[PHIL_NR] = {1, 1, 1, 1, 1}, id=0, iterations=0;
pthread_mutex_t forks_sem[PHIL_NR], id_sem, cout_sem;
int meditated[PHIL_NR] = {0, 0, 0, 0, 0}, 
    eaten[PHIL_NR] = {0, 0, 0, 0, 0};

// Initializes all the semaphores we need.
void Init_semaphores()
{
    pthread_mutex_init(&id_sem, NULL);
    //pthread_mutex_unlock(&id_sem);
    for (int i=0; i<PHIL_NR; i++) {
        pthread_mutex_init(&(forks_sem[i]), NULL);
        //pthread_mutex_unlock(&(forks_sem[i]));
    }
    pthread_mutex_init(&cout_sem, NULL);
}

// Inputs the number of iterations for each philosopher.
void Input_iters()
{
    cout << "Enter the number of iterations" << endl;
    cin >> iterations;
}

// Waits for a random amount of time between two limits.
void Wait()
{
    static const int LOW = 10000, HIGH=20000;
    int cycles = LOW + rand()%(HIGH - LOW);
    double j;
    for (int i=0; i<cycles; i++)
        j = cos(i);
}

// Increases the meditation count and waits.
void Meditate(int id)
{
    //cerr << id << " meditating" << endl;
    meditated[id]++;
    Wait();
}

// Increases the eating count and waits.
void Eat(int id)
{
    //cerr << id << " eating" << endl;
    eaten[id]++;
    Wait();
}

// Tries to reserve a fork. If it can, it reserves it and returns 1,
// otherwise returns 0.
int Try_to_reserve(int fork_nr)
{
    int result = 0;
    pthread_mutex_lock(&(forks_sem[fork_nr]));
    //cerr << "reserving fork nr " << fork_nr 
    //     << " which is " << forks[fork_nr] << endl;
    if (forks[fork_nr]) {
        forks[fork_nr] = 0;
        result = 1;
    }
    pthread_mutex_unlock(&(forks_sem[fork_nr]));
    return result;
}

// Releases a fork.
void Release(int fork_nr)
{
    pthread_mutex_lock(&(forks_sem[fork_nr]));
    forks[fork_nr] = 1;
    pthread_mutex_unlock(&(forks_sem[fork_nr]));
}

// The second solution in the heandouts for the philosophers problem.
void Philosopher(int id)
{
    int right = id, left = (PHIL_NR + id-1) % PHIL_NR;
    //cerr << "left:" << left << " right: " << right << endl;
    //cerr << "philosopher running" << endl;
    for (int i=0; i<iterations; i++) { 
        if (Try_to_reserve(right)) { 
            if (Try_to_reserve(left)) { 
                Eat(id); 
                Release(right); 
                Release(left); 
                Meditate(id); 
            } 
            else { 
                Release(right); 
                Meditate(id); 
            } 
        } 
        else 
            Meditate(id); 
    }
}

// The main thread function. Each of the threads gets an id between 0
// and the number of philosophers and then calls the Philosopher
// function with this id.
void *Get_id_and_run(void *ignored)
{
    int my_id = 0;
    //cout << "getting id" << endl;
    pthread_mutex_lock(&id_sem);
    my_id = id;
    id++;
    pthread_mutex_unlock(&id_sem);
    //cerr << "My id is " << my_id << endl;
    Philosopher(my_id);
    return NULL;
}

// The function that creates all of the threads.
void Create_threads(pthread_t *threads)
{
    for (int i=0; i<PHIL_NR; i++)
        if (pthread_create(&(threads[i]), NULL, Get_id_and_run, NULL) != 0)
            cerr << "Pthread_create fails" << endl;
        else;
    //cerr << "thread created" << endl;
}

// A function that synchronizes all of the threads.
void Synchronise(pthread_t *threads)
{
    //cerr << "synchronizing" << endl;
    for (int i=0; i<PHIL_NR; i++)
        if (pthread_join(threads[i], NULL) != 0)
            cerr << "Pthread_join fails";
}

// Output the statistics for each philosopher.
void Write_stats()
{
    for (int i=0; i<PHIL_NR; i++)
        cout << "Philosopher nr " << i 
             << " has eaten " << eaten[i] << " times and meditated "
             << meditated[i] << " times." << endl;
}