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

#define WORKERS 2
#define ARRAY_ELEMENTS 100
#define MAX 1000


pthread_mutex_t mutex_bucket1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_signal = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_go = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_busy = PTHREAD_COND_INITIALIZER;

static int value = 0;
bool available = false;

void *worker_thread(void *pbucket)
{
    sleep(5);
    while(1)
    {
        unsigned int count = 0;
        int local_array[ARRAY_ELEMENTS];
        int *ptbucket = (int*)pbucket;
        setbuf(stdout, NULL);

        pthread_mutex_lock(&mutex_signal);
        printf(" --------------   n chainging state to available n --------- ");
        available = true;
        printf(" --------------   n from thread sending go signal n --------- ");
        pthread_cond_signal(&cond_go);
        pthread_mutex_unlock(&mutex_signal);


        pthread_mutex_lock(&mutex_bucket1);
        printf(" --------------   n data part locked in thread for copying n --------- ");
        while(count < ARRAY_ELEMENTS)
        {
            printf(" %d - n", ptbucket[count]);  /***incorrect values***/
            local_array[count] = ptbucket[count];
            count++;
        }
        pthread_mutex_unlock(&mutex_bucket1);

        /*Never able to acquire mutex_signal and change state to not available*/   **BUG**
        pthread_mutex_lock(&mutex_signal);
        printf(" --------------   n chainging state to not available n --------- ");
        available = false;
        pthread_mutex_unlock(&mutex_signal);

        count = 0;

        while(count < ARRAY_ELEMENTS)
        {
            printf(" %d - n", local_array[count]);
            count++;
        }

        printf(" --------------   n about to sleep for 5secs n --------- ");
        sleep(5);
    }
}

int main(void)
{
    pthread_t thread_id[WORKERS];

    unsigned int* pbucket1 = (int*) malloc(sizeof(int) * ARRAY_ELEMENTS);

    unsigned int* pbucket;

    for(int i = 0; i < WORKERS - 1; i++)
    {
        pthread_create(&thread_id[i], NULL, worker_thread, (void *) pbucket);
    }

    for(int i = 0; i < MAX; i++)
    {
        unsigned int count = 0;

        pbucket = pbucket1;

        // Make the payload ready
        pthread_mutex_lock(&mutex_bucket1);

        printf(" -------------- creating data payload --------- n");

        while(count < ARRAY_ELEMENTS)
        {
            pbucket1[count] = i;
            i++;
            count++;
        }

        printf(" --------------   n waiting for go signal n --------- ");

        while(!available)
        {
            pthread_cond_wait(&cond_go, &mutex_signal);
        }

        pthread_mutex_unlock(&mutex_bucket1);

        /*I believe after we unlock variable "available" can be mutexed
          again by other thread but seems thinking is flawed */

        printf(" --------------   n Main thread sleep for 3 seconds  n --------- ");
        sleep(3);
    }

    for(int i = 0; i < WORKERS; i++)
    {
        pthread_join(thread_id[i], NULL);
    }

    return 0;
}