#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <err.h>

pid_t pid, pid1, pid2, pid3;
int descriptor[2];

union semun
{
	int val;
	struct semid_ds *buf;
	unsigned short int *array;
	struct seminfo *__buf;
};

int semlock(int semid)
{
	struct sembuf opr;
	opr.sem_num = 0;
	opr.sem_op = -1;
	opr.sem_flg = 0;

	if (semop(semid, &opr, 1) == -1) {
		warn("Błąd blokowania semafora!\n");
		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("Błąd odblokowania semafora!\n");
		return 0;
	}
	else {
		return 1;
	}
}

char *decToHexa(int n)
{
    char hexaDeciNum[100];

    int i = 0;
    while(n!=0)
    {
        int temp  = 0;

        temp = n % 16;

        if(temp < 10)
        {
            hexaDeciNum[i] = temp + 48;
            i++;
        }
        else
        {
            hexaDeciNum[i] = temp + 55;
            i++;
        }

        n = n/16;
    }

    return *hexaDeciNum;
}

void PP1(char *input, int semid1, int semid2)
{
	FILE *fifo = fopen("FIFO", "w");
	FILE *in = fopen(input, "r");

	if(in != NULL && fifo != NULL)
	{
		printf("Pliki zostały otwarte poprawnie.\n");
	}
	else
	{
		printf("Błąd otwarcia pliku. Kończenie pracy procesu.\n");
		return;
	}

	char buffer[15];
	int i;

	semlock(semid1);
    printf("PP1:\n");
    for(i = 0; i < 15; i++)
    {
		buffer[i] = fgetc(in);
		printf("%c ", buffer[i]);
	}
	printf("\n");
	fputs(buffer, fifo);

    fclose(fifo);
    fclose(in);

	semunlock(semid2);
}

void PP2(int semid2, int semid3)
{
	FILE *fifo = fopen("FIFO", "r");

	pipe(descriptor);

	if(pipe != NULL && fifo != NULL)
	{
		printf("Pliki zostały otwarte poprawnie.\n");
	}
	else
	{
		printf("Błąd otawrcia pliku. Kończenie pracy procesu.\n");
		return;
	}

	const void* buffer[15];
	int i;

	semlock(semid2);
	printf("PP2:\n");
	for(i = 0; i < 15; i++)
	{
		//buffer[i] = decToHexa(fgetc(fifo));
		buffer[i] = fgetc(fifo);
		printf("%c ", buffer[i]);
	}
	printf("\n");
	close(descriptor[0]);

	for(i = 0; i < 15; i++)
	{
		write(descriptor[1], buffer[i], sizeof(buffer[i]));
	}

	fclose(fifo);

	semunlock(semid3);
}

void PP3(int semid3, int semid1)
{
	close(descriptor[1]);

	int i;
	char data[4];

	semlock(semid3);
	printf("PP3:\n");
	for(i = 0; i < 15; i++)
	{
		read(descriptor[0], data, sizeof(data));
	}
	printf("\n");

	semunlock(semid1);
}

int main(int argc, char *argv[])
{
	key_t key1, key2, key3;
	int   semid1, semid2, semid3;
	union semun ctl;
	ctl.val = 1;
	if ((key1 = ftok(".", 'A')) == -1)
		errx(1, "Blad tworzenia klucza!");
	if ((semid1 = semget(key1, 1, IPC_CREAT | 0600)) == -1)
		errx(2, "Blad tworzenia semafora!");
	if (semctl(semid1, 0, SETVAL, ctl) == -1)
		errx(3, "Blad ustawiania semafora!");
	if ((key2 = ftok(".", 'B')) == -1)
		errx(1, "Blad tworzenia klucza!");
	if ((semid2 = semget(key2, 1, IPC_CREAT | 0600)) == -1)
		errx(2, "Blad tworzenia semafora!");
		ctl.val = 1;
	if (semctl(semid2, 0, SETVAL, ctl) == -1)
		errx(3, "Blad ustawiania semafora!");
	if ((key3 = ftok(".", 'A')) == -1)
		errx(1, "Blad tworzenia klucza!");
	if ((semid3 = semget(key3, 1, IPC_CREAT | 0600)) == -1)
		errx(2, "Blad tworzenia semafora!");
	if (semctl(semid3, 0, SETVAL, ctl) == -1)
		errx(3, "Blad ustawiania semafora!");
	semlock(semid2);
	semlock(semid3);
	mkfifo("FIFO", 0777);

	pid = getpid();

	if(!fork())
	{
		pid1 = getpid();
		PP1(argv[1], semid1, semid2);
	}

	if(!fork())
	{
		pid2 = getpid();
		PP2(semid2, semid3);
	}

	if(!fork())
	{
		pid3 = getpid();
		PP3(semid3, semid1);
	}

	return 0;
}