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

void *pfunct(void *_tbuffer);
void *cfunct(void *_tbuffer);

pthread_mutex_t ptmutex;
pthread_cond_t ptcond;
pthread_attr_t tattr;

struct thrbuff{
        int buffer1[128];
        int buffer1index;
        int prodcomplete;
};
struct thrbuff tbuffer;


int main() {
        pthread_t producer,  consumer;

        pthread_attr_init(&tattr);
        pthread_attr_setschedpolicy(&tattr, SCHED_FIFO);
        pthread_mutex_init(&ptmutex, NULL);
        pthread_cond_init(&ptcond, NULL);

        tbuffer.buffer1index=1;
        tbuffer.prodcomplete=0;

        pthread_create(&producer, &tattr, pfunct, &tbuffer);
        pthread_create(&consumer, &tattr, cfunct, &tbuffer);

        pthread_join(producer, NULL);
        pthread_join(consumer, NULL);


        return 0;
}

void *pfunct(void *_tbuffer){
        int i=0;
        struct thrbuff *tbuffer=_tbuffer;


        while(i < 1024){
                pthread_mutex_lock(&ptmutex);
                if(tbuffer->buffer1index > 0 && tbuffer->buffer1index < 128){
                        tbuffer->buffer1[tbuffer->buffer1index] = i;
                        printf("producer - tbuffer->buffer1index is %d - i is %d - tbuffer->buffer1[tbuffer->buffer1index] is %d\n", tbuffer->buffer1index, i, tbuffer->buffer1[tbuffer->buffer1index]);
                        tbuffer->buffer1index++;
                        i++;
                        pthread_cond_signal(&ptcond);
                }
                else{
                        pthread_cond_signal(&ptcond);
                        pthread_cond_wait(&ptcond, &ptmutex);
                }
                pthread_mutex_unlock(&ptmutex);
        }

        tbuffer->prodcomplete=1;
        pthread_cond_signal(&ptcond);
        return 0;
}

void *cfunct(void *_tbuffer){
        struct thrbuff *tbuffer=_tbuffer;

        while(!pthread_mutex_lock(&ptmutex) && (tbuffer->prodcomplete == 0 || tbuffer->buffer1index)){
                if(tbuffer->buffer1index > 0){
                        tbuffer->buffer1index--;
                        printf("consumer - tbuffer->buffer1[tbuffer->buffer1index] is %d\n", tbuffer->buffer1[tbuffer->buffer1index]);
                        pthread_cond_signal(&ptcond);
                        pthread_mutex_unlock(&ptmutex);
                        sleep(1);
                }
                else{
                        //printf("consumer while tbuffer->prodcomplete=0, if tbuffer->buffer1index else\n");
                        pthread_cond_signal(&ptcond);
                        pthread_cond_wait(&ptcond, &ptmutex);
                        pthread_mutex_unlock(&ptmutex);
                }
        }
        printf("prodcomplete == 1\n");
        pthread_cond_signal(&ptcond);
        return 0;
}