#include <pthread.h>
#include <iostream>

// #include "semaphore.hh"
#include "semaphore_cond.hh"


// constants
const int k = 20;
const int m = 3;
const int n = 6;


// shared variables
Semaphore empty;
Semaphore full;

int buf[k];

Semaphore mutexP;
int front = 0;

Semaphore mutexC;
int rear = 0;


void* producer (void* number)
{
  while (true)
  {
    // produce t
    int t = rand() % 1000;
    
    P(empty);

    P(mutexP);
    buf[front] = t;
    front = (front + 1) % k;
    V(mutexP);

    V(full);

    std::cout << "producer[" << *((int*) number) << "] produced: "
	      << t << std::endl << std::flush;
  }
  pthread_exit(NULL);
}


void* consumer (void* number)
{
  while (true)
  {
    P(full);

    P(mutexC);
    int t = buf[rear];
    rear = (rear + 1) % k;
    V(mutexC);

    V(empty);

    // consume t
    std::cout << "consumer[" << *((int*) number) << "] consumed: "
	      << t << std::endl << std::flush;
  }
  pthread_exit(NULL);
}


int main(int argc, char* argv[])
{
  // initialize semaphores
  init(empty, k);
  init(full, 0);

  // initialize mutex semaphores
  init(mutexP, 1);
  init(mutexC, 1);

  // create producer threads
  pthread_t producer_thread[n];
  int producer_number[n];
  for (int i = 0; i < n; i++)
  {
    producer_number[i] = i;
    pthread_create(&producer_thread[i], NULL, producer, (void*) &producer_number[i]);
  }

  // create consumer threads
  pthread_t consumer_thread[m];
  int consumer_number[m];
  for (int i = 0; i < m; i++)
  {
    consumer_number[i] = i;
    pthread_create(&consumer_thread[i], NULL, consumer, (void*) &consumer_number[i]);
  }

  // wait for threads to terminate
  for (int i = 0; i < n; i++)
    pthread_join(producer_thread[i], NULL);
  for (int i = 0; i < m; i++)
    pthread_join(consumer_thread[i], NULL);

  // cleanup mutex semaphores
  destroy(mutexP);
  destroy(mutexC);

  // cleanup semaphores
  destroy(empty);
  destroy(full);
        
  return 0;
}