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

#define KAPACITA 20
#define VSTUPY 4

#define TRUE 1
#define FALSE 0

#define PRICHOD_MIN 1
#define PRICHOD_MAX 6
#define ODCHOD_MIN 5
#define ODCHOD_MAX 10

struct zdielane_data
{
    volatile unsigned* parkovisko;
    volatile unsigned index;

    pthread_mutex_t* mutex;
    pthread_cond_t* cond;
};

void cakaj_v_rozsahu(unsigned min, unsigned max)
{
    unsigned rozsah = max - min + 1;
    unsigned pocet_sekund = rand() % rozsah + min;

    sleep(pocet_sekund);
}

void* function_generuj(void* zdata)
{
    struct zdielane_data* data = (struct zdielane_data*) zdata;

    printf("ZACIATOK GENERUJ\n");

    while (TRUE)
    {
        cakaj_v_rozsahu(PRICHOD_MIN, PRICHOD_MAX);

        pthread_mutex_lock(data->mutex);
        if (data->index < KAPACITA)
        {
            data->parkovisko[data->index++] = TRUE;
            printf("Zaparkovane %u. auto.\n", data->index);
        }
        else
        {
            printf("ach jaj\n");
            pthread_cond_signal(data->cond);
        }
        pthread_mutex_unlock(data->mutex);
    }

    return NULL;
}

void* function_vyprazdnuj(void* zdata)
{
    struct zdielane_data* data = (struct zdielane_data*) zdata;

    printf("ZACIATOK VYPRAZDNUJ\n");

    while (TRUE)
    {
        pthread_mutex_lock(data->mutex);
        while (data->index < KAPACITA)
        {
            pthread_cond_wait(data->cond, data->mutex);
        }
        pthread_mutex_unlock(data->mutex);

        cakaj_v_rozsahu(ODCHOD_MIN, ODCHOD_MAX);

        pthread_mutex_lock(data->mutex);
        memset((void*) data->parkovisko, 0, sizeof(unsigned));
        data->index = 0;
        printf("Parkovisko sa vyprazdnilo\n");
        pthread_mutex_unlock(data->mutex);
    }

    return NULL;
}

int main(int argc, char** argv)
{
    pthread_mutex_t mutex;
    pthread_mutex_init(&mutex, NULL);

    pthread_cond_t cond;
    pthread_cond_init(&cond, NULL);

    struct zdielane_data data = {
        (unsigned*) malloc(KAPACITA * sizeof(unsigned)),
        0,
        &mutex,
        &cond
    };

    pthread_t threadsVstup[VSTUPY];
    for (int i = 0; i < VSTUPY; i++)
    {
        pthread_create(&threadsVstup[i], NULL, &function_generuj, &data);
    }

    pthread_t threadVystup;
    pthread_create(&threadVystup, NULL, &function_vyprazdnuj, &data);

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

    pthread_join(threadVystup, NULL);

    pthread_cond_destroy(&cond);
    pthread_mutex_destroy(&mutex);

    free((void*) data.parkovisko);

    return EXIT_SUCCESS;
}