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

pthread_mutex_t mutex;

pthread_cond_t cond_czytelnik;
pthread_cond_t cond_pisarz;

#define MAX_THREADS 100
pthread_t threadArray[MAX_THREADS];

int liczba_czytelnikow_w_czytelni=0;
int liczba_pisarzy_w_czytelni=0;

int liczba_pisarzy_w_kolejcje = 0;
int liczba_czytelnikow_w_kolejce = 0;
int debug = 0;
int indexCzytelnia = 0;
int indexKolejka = 0;

typedef struct
{
    int num;
    char rodzaj;
}kolejka;

typedef struct ticket_lock {
    pthread_cond_t cond;
    pthread_mutex_t mutex;
    unsigned long queue_head, queue_tail;
} ticket_lock_t;

#define TICKET_LOCK_INITIALIZER { PTHREAD_COND_INITIALIZER, PTHREAD_MUTEX_INITIALIZER }

void ticket_lock(ticket_lock_t *ticket)
{
    unsigned long queue_me;

    pthread_mutex_lock(&ticket->mutex);
    queue_me = ticket->queue_tail++;
    while (queue_me != ticket->queue_head)
    {
        pthread_cond_wait(&ticket->cond, &ticket->mutex);
    }
    pthread_mutex_unlock(&ticket->mutex);
}

void ticket_unlock(ticket_lock_t *ticket)
{
    pthread_mutex_lock(&ticket->mutex);
    ticket->queue_head++;
    pthread_cond_broadcast(&ticket->cond);
    pthread_mutex_unlock(&ticket->mutex);
}

kolejka tablicaKolejki[100];
kolejka tablicaCzytelni[100];

void usun_z_kolejki(int n,char b)
{
    kolejka pom;
    int a,j=0;

    for(a=0;a<indexKolejka;a++)
	{
        if(tablicaKolejki[a].num == n && tablicaKolejki[a].rodzaj == b)
		{
			pom=tablicaKolejki[a];
			j=1;
		}

        if(j)
		{
            if(a+1 == indexKolejka)
                indexKolejka--;
            else
                tablicaKolejki[a] = tablicaKolejki[a+1];
        }
    }
    tablicaCzytelni[indexCzytelnia]=pom;
    indexCzytelnia++;
}

void usun_z_czytelni(int n,char b)
{
    kolejka pom;
    int a,j=0;

    for(a=0;a<indexCzytelnia;a++)
	{
        if(tablicaCzytelni[a].num == n && tablicaCzytelni[a].rodzaj == b)
		{
            pom=tablicaCzytelni[a];
            j=1;
        }

        if(j)
		{
            if(a+1 == indexCzytelnia)
                indexCzytelnia--;
            else
                tablicaCzytelni[a] = tablicaCzytelni[a+1];
        }
    }
}

void dodaj_do_kolejki(int n,char b)
{
    kolejka pom;
    pom.num=n;
    pom.rodzaj=b;
    tablicaKolejki[indexKolejka]=pom;
    indexKolejka++;
}

void drukuj()
{
    int i;

    printf("\n****Kolejka****\n");

    for(i = 0; i < indexKolejka; i++)
	{
        if(tablicaKolejki[i].rodzaj == 'c')
            printf("Czytelnik %d\n", tablicaKolejki[i].num);
        if(tablicaKolejki[i].rodzaj == 'p')
            printf("Pisarz %d\n", tablicaKolejki[i].num);
	}

    printf("\n****Czytelnia****\n");

    for(i = 0;i < indexCzytelnia; i++)
	{
        if(tablicaCzytelni[i].rodzaj == 'c')
            printf("Czytelnik %d\n", tablicaCzytelni[i].num);
        if(tablicaCzytelni[i].rodzaj == 'p')
            printf("Pisarz %d\n", tablicaCzytelni[i].num);
	}
}

void *pisarz(void *arg)
{
	while(1)
	{
        pthread_mutex_lock(&mutex);
        liczba_pisarzy_w_kolejcje++;

        //sleep(1);

        printf("ReaderQ: %d WriterQ: %d [in: R:%d W:%d] (pisarz wchodzi do kolejki)\n",liczba_czytelnikow_w_kolejce,liczba_pisarzy_w_kolejcje,liczba_czytelnikow_w_czytelni,liczba_pisarzy_w_czytelni);
        fflush(stdout);
        dodaj_do_kolejki((int)arg,'p');

        if(debug)
			drukuj();

        if(liczba_czytelnikow_w_czytelni > 0 || liczba_pisarzy_w_czytelni > 0 || liczba_czytelnikow_w_kolejce > 0)
			pthread_cond_wait(&cond_pisarz, &mutex);

		printf("obudzono pisarza nr %d\n", (int)arg);

        liczba_pisarzy_w_czytelni++;
        liczba_pisarzy_w_kolejcje--;

        //sleep(1);

        printf("ReaderQ: %d WriterQ: %d [in: R:%d W:%d] (pisarz wchodzi do czytelni)\n",liczba_czytelnikow_w_kolejce,liczba_pisarzy_w_kolejcje,liczba_czytelnikow_w_czytelni,liczba_pisarzy_w_czytelni);
        fflush(stdout);
        usun_z_kolejki((int)arg,'p');

        if(debug)
			drukuj();

        pthread_mutex_unlock(&mutex);

        //sleep(1);

        pthread_mutex_lock(&mutex);
        liczba_pisarzy_w_czytelni--;

        //sleep(1);

        printf("ReaderQ: %d WriterQ: %d [in: R:%d W:%d] (pisarz wychodzi z czytelni)\n",liczba_czytelnikow_w_kolejce,liczba_pisarzy_w_kolejcje,liczba_czytelnikow_w_czytelni,liczba_pisarzy_w_czytelni);
        fflush(stdout);

        usun_z_czytelni((int)arg,'p');

        if(debug)
			drukuj();
        if(liczba_pisarzy_w_czytelni==0)
        {
            if(tablicaKolejki[0].rodzaj=='c')
            {
                pthread_cond_signal(&cond_czytelnik);
            }
            else
            {
                pthread_cond_signal(&cond_pisarz);
            }
        }
        pthread_mutex_unlock(&mutex);
        //sleep(1);
    }
}

void *czytelnik(void *arg)
{
	while(1)
	{
        pthread_mutex_lock(&mutex);
        liczba_czytelnikow_w_kolejce++;

        //sleep(1);

        printf("ReaderQ: %d WriterQ: %d [in: R:%d W:%d] (czytelnik wchodzi do kolejki)\n",liczba_czytelnikow_w_kolejce,liczba_pisarzy_w_kolejcje,liczba_czytelnikow_w_czytelni,liczba_pisarzy_w_czytelni);
        fflush(stdout);
        dodaj_do_kolejki((int)arg,'c');

        if(debug)
			drukuj();

        if(liczba_pisarzy_w_czytelni > 0 || liczba_pisarzy_w_kolejcje > 0)
			pthread_cond_wait(&cond_czytelnik, &mutex);

		printf("obudzono czytelnika nr %d\n", (int)arg);

        liczba_czytelnikow_w_czytelni++;
        liczba_czytelnikow_w_kolejce--;

        //sleep(1);

        printf("ReaderQ: %d WriterQ: %d [in: R:%d W:%d] (czytelnik wchodzi do czytelni)\n",liczba_czytelnikow_w_kolejce,liczba_pisarzy_w_kolejcje,liczba_czytelnikow_w_czytelni,liczba_pisarzy_w_czytelni);
        fflush(stdout);
        usun_z_kolejki((int)arg,'c');

        if(debug)
			drukuj();

        if(tablicaKolejki[0].rodzaj=='c')
			pthread_cond_signal(&cond_czytelnik);

        pthread_mutex_unlock(&mutex);

        //sleep(1);

        pthread_mutex_lock(&mutex);
        liczba_czytelnikow_w_czytelni--;

        //sleep(1);

        printf("ReaderQ: %d WriterQ: %d [in: R:%d W:%d] (czytelnik wychodzi z czytelni)\n",liczba_czytelnikow_w_kolejce,liczba_pisarzy_w_kolejcje,liczba_czytelnikow_w_czytelni,liczba_pisarzy_w_czytelni);
        fflush(stdout);
        usun_z_czytelni((int)arg,'c');

        if(debug)
			drukuj();

        if(liczba_czytelnikow_w_czytelni == 0)
        {
            if(tablicaKolejki[0].rodzaj=='p')
            {
                pthread_cond_signal(&cond_pisarz);
            }
            else
            {
                pthread_cond_signal(&cond_czytelnik);
            }
        }
        pthread_mutex_unlock(&mutex);
        //sleep(1);
    }
}

int main(int argc, char *argv[])
{

    if(argv[3])
		if(!strcmp(argv[3],"-debug"))
			debug = 1;

    pthread_mutex_init(&mutex,NULL);
    pthread_cond_init(&cond_czytelnik,NULL);
    pthread_cond_init(&cond_pisarz,NULL);

	int i, pom = 0;

	for (i = 0; i < atoi(argv[1]); i++)
	{
		pthread_create(&threadArray[pom], NULL, pisarz, (void*)pom);
		pom++;
	}

	for (i = 0; i < atoi(argv[2]); i++)
	{
		pthread_create(&threadArray[pom], NULL, czytelnik, (void*)pom);
		pom++;
	}

	for(i=0; i<atoi(argv[1])+atoi(argv[2]); i++)
	{
		pthread_join(threadArray[i],NULL);
	}

    pthread_cond_destroy(&cond_pisarz);
    pthread_cond_destroy(&cond_czytelnik);
    pthread_mutex_destroy(&mutex);
	return 0;
}