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

#define READERS 5   // liczba czytelnikĂłw

/*
 * - mutex: zapewnia wyłączny dostęp do biblioteki albo czytelnikom albo
 *   pisarzowi
 * - mutex_readers: w rozwiązaniu trzeba wiedzieć czy dany czytelnik jest
 *   pierwszym wchodzącym lub ostatnim wychodzącym by wykonać wtedy dodatkowe
 *   operacje. Ten mutex zapewnia, że sprawdzenie to wykona się poprawnie (nie
 *   będzie sytuacji, że dwóch lub więcej czytelników uzna siebie jednocześnie
 *   za "pierwszego" lub "ostatniego" czytelnika.
 * - mutex_order: zapewnia cechę kolejkowania tak aby nie doszło do zagłodzenia
 *   czytelnikĂłw lub pisarza
 */
pthread_mutex_t mutex, mutex_readers, mutex_order;
sem_t sem_readers;  // licznik czytelnikĂłw

/*
 * Kod symulujący czytanie (krótka operacja)
 */
void read_content(int id) {
    printf("Reading (id=%d)\n", id);
}

/*
 * Kod symulujący pisanie (wymuszona, długa operacja)
 */
void write_content() {
    int i;
    printf("Writing");
    fflush(NULL);
    for (i = 0; i < 3; ++i) {
        sleep(1);
        printf(".");
        fflush(NULL);
    }
    printf("\n");
}

/*
 * Kod kaĹźdego czytelnika.
 */
void *reader(void *id) {
    while (1) {
        int readers;

        pthread_mutex_lock(&mutex_order);
        pthread_mutex_lock(&mutex_readers);
        sem_getvalue(&sem_readers, &readers);
        if (readers == 0)                       // jeśli pierwszy czytelnik
            pthread_mutex_lock(&mutex);         //   to zablokuj bibliotekę
        sem_post(&sem_readers);                 // zwiększ licznik czytelników
        pthread_mutex_unlock(&mutex_order);
        pthread_mutex_unlock(&mutex_readers);

        read_content((int) id);                 // akcja czytania

        pthread_mutex_lock(&mutex_readers);
        sem_wait(&sem_readers);
        sem_getvalue(&sem_readers, &readers);
        if (readers == 0)                       // jeśli ostatni czytelnik
            pthread_mutex_unlock(&mutex);       //   to zwolnij bibliotekę
        pthread_mutex_unlock(&mutex_readers);
    }
}

/*
 * Kod pisarza bardzo przypomina kod producenta. Dodano jedynie "mutex_order"
 * celem zapewnienia cechy kolejkowania żądań dostępu do biblioteki.
 */
void *writer(void *dummy) {
    while (1) {
        pthread_mutex_lock(&mutex_order);
        pthread_mutex_lock(&mutex);
        pthread_mutex_unlock(&mutex_order);
        write_content();
        pthread_mutex_unlock(&mutex);
    }
}

int main() {
    int i;

    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);

    pthread_mutex_init(&mutex, NULL);
    pthread_mutex_init(&mutex_readers, NULL);
    pthread_mutex_init(&mutex_order, NULL);
    sem_init(&sem_readers, 0, 0);

    pthread_t threads[2];
    pthread_create(&threads[0], &attr, writer, NULL);
    for (i = 1; i <= READERS; ++i)
        pthread_create(&threads[i], &attr, reader, (void*) i);

    for (i = 0; i <= READERS + 1; ++i)
        pthread_join(threads[i], NULL);

    pthread_attr_destroy(&attr);
    pthread_mutex_destroy(&mutex);
    pthread_mutex_destroy(&mutex_readers);
    pthread_mutex_destroy(&mutex_order);
    sem_destroy(&sem_readers);

    pthread_exit(NULL);
    return 0;
}