#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <err.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <wait.h>
#include <errno.h>
#include <pthread.h>
#include <time.h>
#include <sys/prctl.h>

#define FIFO "/tmp/my_fifo"
#define BUFF 1
#define COUNT 2

#if defined(__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED)
#else
    union semun {
        int val;
        struct semid_ds *buf;
        unsigned short int *array;
        struct seminfo *__buf;
    };
#endif


int  des;
int pid;
int desF;
char buf[BUFF];
int n;
int n2;
//char buf1[BUFF];
unsigned char buf2[BUFF];
char xA[10];

int   semid;
int   semid2;
int   semid3;

/*--Pipe--*/
int pdes[2];
int counter = 0;
char string[]={'a'};

int wartP = 0;
int wartD = 0;
int zm=0;
int zm2=0;
int zm3=0;
int zm4=0;

int semlock(int semid) {
    struct sembuf opr;

    opr.sem_num =  0;
    opr.sem_op  = -1;        // blokowanie
    opr.sem_flg =  0;        // operacja blokujaca

    if (semop(semid, &opr, 1) == -1){
        warn("Blad blokowania semafora!");
        return 0;
    }else{
        return 1;
    }
}

int semunlock(int semid) {
    struct sembuf opr;

    opr.sem_num = 0;
    opr.sem_op  = 1;
    opr.sem_flg = 0;

    if (semop(semid, &opr, 1) == -1){
        warn("Blad odblokowania semafora!");
        return 0;
    }else{
        return 1;
    }
}

void zablokowanieProcP(int signal)
{
    if(zm==0)
    {
        psignal(signal,"\nProces 1: Otrzymalem sygnal");
        printf("Proces 1 wstrzymany\n");
        zm=1;

        semlock(semid3);
        semlock(semid2);
    }
    else psignal(signal,"\nNie można ponownie użyć sygnału: ");
    //sleep(3);

    return;
}

void odblokowanieProcP(int signal)
{
    if(zm==1)
    {
        psignal(signal,"\nProces 1: Otrzymalem sygnal");
        printf("Proces 1 wznowiony\n");

        zm=0;

        semunlock(semid3);
        semunlock(semid2);

    }
    else psignal(signal,"\nNie można ponownie użyć sygnału: ");
    return;
}

void zablokowanieProcD(int signal){
    if(zm2==0)
    {
        psignal(signal,"\nProces 2: Otrzymalem sygnal");
        printf("Proces 2 wstrzymany\n");

        zm2=1;

        semlock(semid2);
        semlock(semid3);
    }
    else psignal(signal,"\nNie można ponownie użyć sygnału: ");
    //sleep(3);

    return;
}

void odblokowanieProcD(int signal){
    if(zm2==1)
    {
        psignal(signal,"\nProces 2: Otrzymalem sygnal");
        printf("Proces 1 wznowiony\n");

        zm2=0;

        semunlock(semid2);
        semunlock(semid3);

    }
    else psignal(signal,"\nNie można ponownie użyć sygnału: ");
    return;
}

void zabicieProcP(int signal){
    if(zm3==0)
    {
        psignal(signal,"\nProces 1: Otrzymalem sygnal");
        printf("Proces 1 zabity\n");
        wartP=1;
    }
    else psignal(signal,"\nNie można ponownie użyć sygnału: ");
    //sleep(3);

    return;
}

void zabicieProcD(int signal){
    if(zm4==0)
    {
        psignal(signal,"\nProces 2: Otrzymalem sygnal");
        printf("Proces 2 zabity\n");
        wartD=1;
        semunlock(semid);
    }
    else psignal(signal,"\nNie można ponownie użyć sygnału: ");
    //sleep(3);

    return;
}


/*----Proces 1------*/
void *threadProcess1(void *arg) {

    signal(SIGUSR1, zablokowanieProcP);
    signal(SIGUSR2, odblokowanieProcP);
    signal(SIGBUS, zabicieProcP);

    des = open( "/tmp/file.txt", O_WRONLY);
    while(1)
    {

        semlock(semid);     //wejście w proces 1
        if((semctl(semid2, 0, GETVAL))==1) break;
        lseek(des,0,SEEK_SET);
        n=read(0,buf,sizeof(buf));
        if(n==0 || wartP==1)
        {
            semunlock(semid2);
            break;
        }


        printf("Proces 1: %d\n",*buf);
        write(des,buf,sizeof(buf));

        semunlock(semid2);  //odblokowanie procesu 2

        semunlock(semid3);
        semlock(semid3);


        bzero(buf,sizeof(buf));
        //bzero(buf2,sizeof(buf));
    }
    printf("Proces1 zakonczyl dzialanie\n");
    semunlock(semid2);
    //close(des);
    pthread_exit(0);
}

/*----Proces 2------*/
void *threadProcess2(void *arg) {

    signal(SIGUSR1, zablokowanieProcD);
    signal(SIGUSR2, odblokowanieProcD);
    signal(SIGBUS, zabicieProcD);

    des=open("/tmp/file.txt",O_RDONLY);

    desF = open(FIFO,O_WRONLY);
    while(1)
    {

        semlock(semid2);    //wejście w proces 2
        if((semctl(semid, 0, GETVAL))==1 || wartD==1)   //semafor procesu pierwszego jest 1, a w tym miejscu powinien byc na 0, gdyby proces 1 był aktywny
        {
            //printf("tut\n");
            break;
        }
        lseek(des,0,SEEK_SET);
        n=read(des,buf,sizeof(buf));


        printf("Proces 2: %d\n",*buf);


        semunlock(semid);   //odblokowanie procesu 1

        write(desF,buf,sizeof(buf));
        printf("FIFO zapis: %d\n",*buf);

        bzero(buf,sizeof(buf));

    }
    printf("Proces 2 zakonczyl dzialanie\n");
    semunlock(semid2);
    //close(desF);
    close(des);
    //unlink(FIFO);

    pthread_exit(0);
}



int main(void)
{
    int err;
    int cnt;
    /* tablica, w ktorej umiescimy informacje watkach :-) */
    pthread_t p_thread[COUNT];

    //Dolaczamy wszystkie watki, czyli czekamy, az sie zakoncza.
    /*
    for(cnt = 0; cnt < COUNT; cnt++)
    {
        pthread_join(p_thread[cnt], NULL);
    }*/



    des = open( "/tmp/file.txt", O_CREAT | O_RDWR | O_APPEND,  0666 );
    close(des);

    /*Semafor 1*/
    key_t key;

    union semun ctl;

    if ((key = ftok(".", 'A')) == -1)
        errx(1, "Blad tworzenia klucza!");

    if ((semid = semget(key, 1, IPC_CREAT | 0600)) == -1)
        errx(2, "Blad tworzenia semafora!");

    /* Inicjujemy semafor jako podniesiony (S = 1). */
    ctl.val = 1;
    if (semctl(semid, 0, SETVAL, ctl) == -1)
        errx(3, "Blad ustawiania semafora!");
    //semunlock(semid);

    /*Semafor 2*/
    key_t key2;


    if ((key2 = ftok(".", 'B')) == -1)
        errx(1, "Blad tworzenia klucza!");

    if ((semid2 = semget(key2, 1, IPC_CREAT | 0600)) == -1)
        errx(2, "Blad tworzenia semafora!");

    /* Inicjujemy semafor jako podniesiony (S = 1). */
    ctl.val = 1;
    if (semctl(semid2, 0, SETVAL, ctl) == -1)
        errx(3, "Blad ustawiania semafora!");

    semlock(semid2);    //wstrzymanie procesu 2

    /*------------------*/

    /*Semafor 3 - synchronizacja sygnałów z proc1 do proc2*/
    key_t key3;


    if ((key3 = ftok(".", 'C')) == -1)
        errx(1, "Blad tworzenia klucza!");

    if ((semid3 = semget(key3, 1, IPC_CREAT | 0600)) == -1)
        errx(2, "Blad tworzenia semafora!");

    /* Inicjujemy semafor jako podniesiony (S = 1). */
    ctl.val = 1;
    if (semctl(semid3, 0, SETVAL, ctl) == -1)
        errx(3, "Blad ustawiania semafora!");

    semlock(semid3);    //wstrzymanie procesu 3


    /*Semafor 4 - synchronizacja sygnałów z proc2 do proc3*/
    key_t key4;
    int   semid4;

    if ((key4 = ftok(".", 'D')) == -1)
        errx(1, "Blad tworzenia klucza!");

    if ((semid4= semget(key4, 1, IPC_CREAT | 0600)) == -1)
        errx(2, "Blad tworzenia semafora!");

    /* Inicjujemy semafor jako podniesiony (S = 1). */
    ctl.val = 1;
    if (semctl(semid4, 0, SETVAL, ctl) == -1)
        errx(3, "Blad ustawiania semafora!");

    semlock(semid4);    //wstrzymanie procesu 4

    /*------------------------------------------*/


    /*FIFO*/
    umask(0);
    mknod(FIFO, S_IFIFO|0666, 0);

    /*--Pipe--*/
    pipe(pdes);

    //signal(SIGUSR1, zablokowanieProcP);
    //signal(SIGUSR2, odblokowanieProcP);

    /* Proces 1 - pobiera dane z STDIN (deskryptor 0) i zapisuje w pliku */
    if(fork())
    {
        //rodzic
        /* Proces 2 - odczytuje z pliku i przekazuje dane za pomocą FIFO do procesu 3 */
        if(fork())
        { //rodzic
            if(fork())
            {
                /*for(cnt = 0; cnt < COUNT; cnt++)
                {
                    pthread_join(p_thread[cnt], NULL);
                }*/
                while( ( pid = waitpid(-1, NULL, 0) ) )
                {
                    if (errno == ECHILD)
                    {
                        break;
                    }
                }
            }
            else
            {
                //signal(SIGUSR1, zablokowanieProcT);
                //signal(SIGUSR2, odblokowanieProcT);
                prctl(PR_SET_NAME,"Proces3",0,0,0);

                /* Proces 3 - wypisuje otrzymane dane na STDOUT (deskryptor 1) */
                desF = open(FIFO,O_RDONLY);

                while(1)
                {
                    semunlock(semid3);
                    n=read(desF,buf2,sizeof(buf2));

                    if(n==0)
                    {
                        break;
                    }

                    printf("FIFO odczyt: %x\n",*buf2);
                    //write(1,buf2,sizeof(buf2));
                    semlock(semid3);
                    bzero(buf2,sizeof(buf2));
                }
                printf("Proces3 zakonczyl dzialanie\n");
                close(desF);
                unlink(FIFO);
                //sleep(100);
            }

        }
        else
        { //dziecko - proces 2

            cnt=1;
            err = pthread_create(&p_thread[cnt], NULL, threadProcess2, (void *)cnt);
            if(err != 0)
                fprintf(stderr, "Error creating the thread\n");
            prctl(PR_SET_NAME,"Proces2",0,0,0);
            pthread_join(p_thread[1], NULL);
        }



    }
    else //dziecko - proces 1
    {
        cnt=0;
        err = pthread_create(&p_thread[cnt], NULL, threadProcess1, (void *)cnt);
        if(err != 0)
            fprintf(stderr, "Error creating the thread\n");
            prctl(PR_SET_NAME,"Proces1",0,0,0);
        pthread_join(p_thread[0], NULL);
    }



    return 0;
}