#include <iostream>
#include <string>
#include <cstdlib>
#include <unistd.h>
#include <ctime>
#include "dining.h"
using namespace std;

int main (int argc, char **argv) {

 srand (time (nullptr));
 cout << "How many philosophers?  ";
 string numstr;
 getline (cin,numstr);
 num = atoi(numstr.c_str());
 locks = new pthread_mutex_t [num];
 th = new pthread_t[num];
 id = new int[num];
 for (int i=0; i < num; i++)
  id[i] = i;
 for (int i=0; i < num; i++)
  pthread_create (&th[i],nullptr,phil,&id[i]);
 for (int i=0; i < num; i++)
  pthread_join (th[i],nullptr);
 delete[] th;
 delete[] id;
 delete[] locks;
 return 0;
}

void * phil (void *a) {

 while (true) {
  int idnum = *(int*)a;
  int pause = 1+rand()%10;
  cout << to_string(idnum)+":  Thinking\n";cout.flush();
//  sleep (pause);
  pause = 1+rand()%10;

/*
If my id is idnum, the fork to my left is idnum and the fork to my right is idnum+1 (after wrapping back to zero if necessary)
*/
  cout <<to_string(idnum) +" trying to lock "+ to_string((idnum+1)%num)+"\n";
  cout.flush();
//  pthread_mutex_lock (&locks[(idnum+1)%num]);
  pthread_mutex_lock (&locks[idnum?(idnum+1)%num:idnum]);
      //%num wraps back to 0 if it needs to
//  sleep (5); //pause between picking up right fork and left fork
  cout <<to_string(idnum) +" trying to lock " + to_string(idnum) +"\n";
  cout.flush();
// pthread_mutex_lock (&locks[idnum]);
  pthread_mutex_lock (&locks[!idnum?(idnum+1)%num:idnum]);
  cout << to_string(idnum) + ":  Eating\n";cout.flush();
//  sleep (pause);
  cout << to_string(idnum) +" unlocking " + to_string((idnum+1)%num) +
        "\n";
  cout.flush();
  pthread_mutex_unlock (&locks[(idnum+1)%num]);
  cout << to_string(idnum) + " unlocking "+ to_string(idnum) +"\n";
  cout.flush();
  pthread_mutex_unlock (&locks[idnum]);
 }
 return nullptr;
}

/*

In C-like languages, you have unary operators  like -x, you have binary operators like x*y, you have one ternary operator.  Since there is only the one, people just call it "the ternary operator" or just "tern."  I always called it "hook" but that's just me.



expr1 ? expr2 : expr3

if expr1 evaluates to anything other than 0, expr2 is computed and returned.
if expr1 evaluates to 0, expr3 is computed and returned.

Much like short-circuit boolean, the unused expression is not even computed and evaluated, so if it might have caused an error, it won't because it's not evaluated.


Short-circuit boolean:

if (expr1 && expr2)

if expr1 is false, the whole && thing has to be false, so there's no point in computing expr2, so C-like languages do not bother.

if (x < sz && A[x]==10)

if (expr1 || expr2)

if expr1 is true (non-zero) the whole || thing is true, so expr2 is not evaluated.

*/