/*****************************************************************
    File:          producer_consumer.cc
    Description:   A program that simulates a producer-consumer 
                   model with pthreads. 
                                                         
    Author:        Dana Vrajitoru                          
    Organization:  IUSB                                    
    Date:          September, 2020

    Compilation command:
    g++ producer_consumer.cc main.cc -o prodc -lpthread

    Run with:
    prodc 
      or 
    ./prodc
******************************************************************/


#include <cstdlib>
#include <cstdio>
#include <iostream>
using namespace std;
#include <pthread.h>
#include "producer_consumer.h"

// global variables 
int data[MAX_ITEMS]; 
int counter = 0; 
pthread_mutex_t data_mutex, output_mutex;

// Initializes the mutexes we need.
void Init_mutexes() 
{
    pthread_mutex_init(&data_mutex, NULL);
    pthread_mutex_init(&output_mutex, NULL);
}

// Creates the threads calling the producer function, then those
// calling the consumer function, and to each of them it passes the
// pointer to the number of items as the argument.
void Create_threads(pthread_t *threads, int nr_producers, 
		    int nr_consumers, int &nr_items)
{
    void *ptr_nr_items = &nr_items;
    
    for (int i=0; i<nr_producers; i++)
        if (pthread_create(&threads[i], NULL, Producer, ptr_nr_items) != 0)
            cout << "Pthread_create fails for producers" << endl;
    
    for (int i=nr_producers; i<nr_producers+nr_consumers; i++)
        if (pthread_create(&threads[i], NULL, Consumer, ptr_nr_items) != 0)
            cout << "Pthread_create fails for consumers" << endl;
    
}

// Joins all of the threads so that the program doesn;t end before
// they have finished the work.
void Synchronise(pthread_t *threads, int no_threads)
{
    for (int i=0; i<no_threads; i++)
        if (pthread_join(threads[i], NULL) != 0)
            cout << "Pthread_join fails" << endl;
}

// Inputs the number of producers and the nummber of items to be
// produced by each of them. Sets the number of consumers to be equal
// to the number of producers.
void Input_data(int &nr_producers, int &nr_consumers, int &nr_items)
{
    cout << "Enter the number of producers" << endl;
    cin >> nr_producers;
    cout << "Enter the number of items for each producer" << endl;
    cin >> nr_items;
    nr_consumers = nr_producers;
}

// The classical producer function.
void *Producer(void *arg) 
{ 
    int nr_items = *(int *)arg, item;
    for (int i=0; i<nr_items; i++) { 
        item = Produce_item(); 
        while (!Deposit(item)) ; 
    }
    return NULL;
} 

// The classical consumer function.
void *Consumer(void *arg) 
{ 
    int nr_items = *(int *)arg, item;
    for (int i=0; i<nr_items; i++) {  
        while (!Fetch(item)); 
        Consume(item); 
    } 
    return NULL;
} 

// Attempts to deposit an item in the array of data. It returns 0 in
// case of failure, otherwise 1.
bool Deposit(int item) 
{ 
    pthread_mutex_lock(&data_mutex);
    if (Data_is_full()) {
        pthread_mutex_unlock(&data_mutex);
        return false; 
    }
    else { 
        data[counter++] = item;
        pthread_mutex_unlock(&data_mutex); 
        return true; 
    } 
} 

// Attempts to fetch an item from the array of data. It returns 0 in
// case of failure, otherwise 1.
bool Fetch(int &item) 
{ 
    pthread_mutex_lock(&data_mutex);
    if (Data_is_empty()) {
        pthread_mutex_unlock(&data_mutex);
        return false; 
    }
    else { 
        item = data[--counter]; 
        pthread_mutex_unlock(&data_mutex);
        return true; 
    } 
} 

// Tells us if there array of data is full.
bool Data_is_full() 
{ 
    return (counter == MAX_ITEMS); 
} 

// Tells us if there array of data is empty.
bool Data_is_empty() 
{ 
    return (counter == 0); 
} 

// Produces a random integer between 1 and 10.
int Produce_item() 
{
    return (1+ (rand() % 10));
}

// Writes a number of * characters equal to the value of the item.
void Consume(int item)
{
    pthread_mutex_lock(&output_mutex);
    cout << "Consuming item " << item << ' ';
    for (int i=0; i<item; i++)
        cout << "*";
    cout << endl;
    pthread_mutex_unlock(&output_mutex);
}