// To compile:  gcc -g3 -pthread THIS_FILE
#define  _DEFAULT_SOURCE /* for drand48 */

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

#define NUM_LOOP 3

pthread_mutex_t mutex;
pthread_cond_t cond;

int num_readers = 0;
int num_writers = 0;
int num_readers_waiting = 0;
int num_writers_waiting = 0;

int PRINT = 0;

// NOTE:  Condition: This means readers always wait for any active writer
//        If readers wait for _ANY_ writer (cond: num_writers == 0),
//          then this condition would be an example of WRITER_PREFFERRED.
//        QUESTION:  How would you modify this to stop all future reades
//                   if at some point there are 5 readers or more, but
//                   then allow arbitrary reads after all writers write?
int read_condition() {
  return (num_writers - num_writers_waiting) == 0;
}

// NOTE: Condition: This thread is one of the writers, and no threads are active.
//       If writers wait for _ANY_ reader (cond: num_readers == 0),
//         then this condition would be an example of READER_PREFERRED..
//       But the current condition is WEAK_READER_PREFERRED, writer waits
//         as long as there are any active readers, but if a reader is waiting,
//         then the writer will still aquire the resource.
//       Don't implement both WRITER_PREFERRED and READER_PREFERRED,
//         or else you'll see deadlock !
int write_condition() {
  return (num_readers - num_readers_waiting) == 0 &&
         (num_writers - num_writers_waiting) == 1;
}

void *reader(void *thread_num) {
  int thread_num_int = *(int *)thread_num;
  for(int i=0; i< NUM_LOOP; i++) {
    int len = (int) ((drand48() * 5) + 1);
    sleep(len);

    // Acquire a resource for reading
    pthread_mutex_lock(&mutex);
    num_readers++;
    while (! read_condition()) {
      num_readers_waiting++;
      // This unlocks the mutex if we have to wait.
      pthread_cond_wait(&cond, &mutex);
      // After waiting, pthread_cond_wait locks the mutex again.
      num_readers_waiting--;
     }
    pthread_mutex_unlock(&mutex);

    len = (int) ((drand48() * 5) + 1);
    sleep(len);
    if (PRINT) printf("reader %d is reading\n", thread_num_int);

    // Release the resource for reading
    pthread_mutex_lock(&mutex);
    num_readers--;
    pthread_cond_broadcast(&cond);
    pthread_mutex_unlock(&mutex);
  }
  return NULL;
}

void *writer(void *thread_num) {
  int thread_num_int = *(int *)thread_num;
  for( int i=0; i<NUM_LOOP; i++){
    int len = (int) ((drand48() * 5) + 1);
    sleep(len);

    // Acquire a resource for reading
    pthread_mutex_lock(&mutex);
    num_writers++;
    while (! write_condition()) {
      num_writers_waiting++;
      // This unlocks the mutex if we have to wait.
      pthread_cond_wait(&cond, &mutex);
      // After waiting, pthread_cond_wait locks the mutex again.
      num_writers_waiting--;
    }
    pthread_mutex_unlock(&mutex);

    len = (int) ((drand48() * 5) + 1);
    sleep(len);
    if (PRINT) printf("writer %d is writing\n", thread_num_int);

    // Release the resource for reading
    pthread_mutex_lock(&mutex);
    num_writers--;
    pthread_cond_broadcast(&cond);
    pthread_mutex_unlock(&mutex);
  }
  return NULL;
}

int main(int argc, char* argv[]) {
  if(argc != 4){
    printf("Usage: %s NUM_READERS NUM_WRITERS PRINT\n", argv[0]);
    return 1;
  }

  int NUM_READERS = atoi(argv[1]);
  int NUM_WRITERS = atoi(argv[2]);
  PRINT = atoi(argv[3]);

  pthread_t read_thread[NUM_READERS];
  pthread_t write_thread[NUM_WRITERS];
  int reader_num_array[NUM_READERS];
  int writer_num_array[NUM_WRITERS];
  pthread_mutex_init(&mutex, NULL);
  pthread_cond_init(&cond, NULL);

  for (int i = 0; i < NUM_READERS; i++) {
    // We pass thread_num as an argument.
    reader_num_array[i] = i;
    pthread_create(&read_thread[i], NULL, reader, &reader_num_array[i]);
  }
  for (int i = 0; i < NUM_WRITERS; i++) {
    writer_num_array[i] = i;
    pthread_create(&write_thread[i], NULL, writer, &writer_num_array[i]);
  }

  for (int i = 0; i < NUM_READERS; i++) {
    pthread_join(read_thread[i], NULL);
  }
  for (int i = 0; i < NUM_WRITERS; i++) {
    pthread_join(write_thread[i], NULL);
  }
  return 0;
}