#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
struct data{
    int*pole;
   volatile  int velkost;
   volatile  int obsadene;
   volatile  int hornyInterval;
   volatile  int dolnyInterval;
    pthread_cond_t *polePlne;
    pthread_cond_t *poleNiejePlne;
    pthread_mutex_t* mutex;
};
void* thread2_main(void* pdata){
     struct data* data = (struct data*) pdata;
         while(1){
         int fibonacci = 0;
         int first = 0;
         int second = 1;
         int next;
          pthread_mutex_lock(data->mutex);
          // overi ci nieje pole prazdne
         if(data->obsadene < 0){
          pthread_cond_wait(data->polePlne,data->mutex);
         }
         //generuje fibonacciho postupnost
         for(int i = 0; i < data->hornyInterval;i++){
             if(i <= 1){
                 fibonacci = i;
             }else{
                 fibonacci = first + second;
                 first = second;
                 second = fibonacci;
                 // porovnanie ci fibbonaciho cislo nieje vacsie ako cislo v pol
                 if(fibonacci > data->pole[data->obsadene]) {
                   printf("neni Fibonacciho\n");
                   data->obsadene--;
                   printf("%d \n",data->obsadene);
                   pthread_mutex_unlock(data->mutex);
                   pthread_cond_signal(data->poleNiejePlne);
                   // iba pre spomalenie aby som to mohol odkontrolovat
                   //sleep(1);
                   break;
                 }
                 //porovnava aktualne fibonacciho cislo s cislom v poli ak su ro
                 if(fibonacci == data->pole[data->obsadene]){
                  printf("fibonacciho cislo %d \n", data->pole[data->obsadene]);
                  data->obsadene--;
                  printf("%d \n",data->obsadene);
                  pthread_mutex_unlock(data->mutex);
                  pthread_cond_signal(data->poleNiejePlne);
                  // iba pre spomalenie aby som to mohol odkontrolovat

                  //sleep(1);
                 }
             }
         }
         }

}
void* thread1_main(void* pdata){
    struct data* data = (struct  data*) pdata;

    while(1){
      // nasada na rand aby generoval furt ine cisla
        srand(time(NULL));
        pthread_mutex_lock(data->mutex);
        //ak je plne  pole tak caka pokial sa miesto v poli neuvolni ak ano pokr
        if(data->obsadene == (data->velkost -1 )){
            pthread_cond_wait(data->poleNiejePlne,data->mutex);
        }
        //generator nahodnich cisel
        int r = (rand()%(data->hornyInterval - data->dolnyInterval)) + data->dolnyInterval;
        data->obsadene++;
        printf("generator %d \n",r);
        data->pole[data->obsadene] = r;
        pthread_mutex_unlock(data->mutex);
        pthread_cond_signal(data->polePlne);
        // iba pre spomalenie aby som to mohol odkontrolovat
        //sleep(1);

    }
}
int main(){
    pthread_cond_t cond1,cond2;
    pthread_cond_init(&cond1,NULL);
    pthread_cond_init(&cond2,NULL);
    pthread_mutex_t mutex;
    pthread_mutex_init(&mutex,NULL);
    struct data pole = {NULL,10,-1,20,1,&cond1,&cond2,&mutex};
    pole.pole = malloc(sizeof(int) * pole.velkost);
    pthread_t thread1,thread2;
    pthread_create(&thread1,NULL,&thread1_main,&pole);
    pthread_create(&thread2,NULL,&thread2_main,&pole);
    pthread_join(thread1,NULL);
    pthread_join(thread2,NULL);
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond1);
    pthread_cond_destroy(&cond2);
    free(pole.pole);

}