#include <stdio.h>
#include <sys/stat.h>
#include <signal.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <sys/sem.h>
#include <sys/wait.h>

int rura[2];
//ID procesów do sygnałow, zatrzymano -> czy byl sygnal stopu
int pid[3];
int zatrzymane = 0;
int semafor; //semafor chroniacy plik

void Operacja_sem(int num, int op)
{
	//num
	//sem0 - blokuje zapis, sem1 - blokuje odczyt
	//operacja
	//+1 - podnies semafor, -1 - opusc semafor
	struct sembuf sem;
	sem.sem_op = op;
	sem.sem_num = num;

	if(semop(semafor, &sem, 1) == -1)
		semop(semafor, &sem, 1);

	//Dopóki poprawnie nie wykonasz operacji to ja powtorz
	//Czemu ? Bo sygnaly sie nie lubią z tego typu operacjami i jak byś jakiś wysłał jakiś bez tego zabezpieczenia to by proces
	//Podniosl/ opuscil raz za duzo semafor i wszystko by diabli wzieli;
}

//na poczatku sytuacja wyglada tak:
//p1 zna kazdego
//p2 zna tylko p3
//p3 nie zna nikogo

//DO sygnalow potrzebne sa pozostale PID-y - rozeslemy je przez queue - mechanizmem do sygnalow

void p1()
{
	pid[0] = getpid();

	//wysyla swoj pod do p2 przez rure
	char pidP1[10];
	sprintf(pidP1, "%d", getpid());
	write(rura[1], pidP1, sizeof(pidP1));

	char odczyt;

	while(1)
	{
		while(zatrzymane);
		//wysylamy po jednym znaku, czytamy ze standardowego wejscia
		if(fread(&odczyt, 1, 1, stdin))
		{
			//rura sie domyslnie samo synchronizuje
			write(rura[1], &odczyt, 1); //WYslij wiadomosc przez fifo do P2
		}
	}
}





void proc1()
{
	pid[0] = getpid();

	//wysyla swoj pod do p2 przez rure
	//char pidP1[10];
	//sprintf(pidP1, "%d", getpid());
	//write(rura[1], pidP1, sizeof(pidP1));

	char odczyt[0];

	while(1)
	{
		while(zatrzymane);
		//wysylamy po jednym znaku, czytamy ze standardowego wejscia
		if(fread(&odczyt, 1, 1, stdin))
		{
			Operacja_sem(0, -1);
			FILE *plik = fopen("plik", "w"); // Otworz plik do zapisu
			fwrite(odczyt, 1, 1, plik); // Zapisz do pliku
			fclose(plik);
			Operacja_sem(1, 1);
			printf("Wczytalem znak : %c", odczyt[0]);
		}
	}
}
















void p2()
{
	pid[1] = getpid();

	//odbiera pid p1
	char pidP1[10];
	read(rura[0], &pidP1, sizeof(pidP1));
	pid[0] = atoi(pidP1);

	//wysyla plikiem pid do p3
	Operacja_sem(0, -1);
	FILE *plik = fopen("plik", "w"); // Otworz plik do zapisu
	fwrite(pidP1, 10, 10, plik); // Zapisz do pliku
	fclose(plik);
	Operacja_sem(1, 1);

	sprintf(pidP1, "%d", getpid());

	Operacja_sem(0, -1);
	plik = fopen("plik", "w"); // Otworz plik do zapisu
	fwrite(pidP1, 10, 10, plik); // Zapisz do pliku
	fclose(plik);
	Operacja_sem(1, 1);


	int i = 0;
	char odczyt;
	while(1)
	{
		while(zatrzymane);

		if(read(rura[0], &odczyt, 1)) //odczyt pipe
		{
			//zamienia odebrany znak na hex
			char hex[3];
			sprintf(hex, "%02x ", (unsigned char) odczyt);


			//wysyla znak do p3
			Operacja_sem(0, -1);
			plik = fopen("plik", "w"); // Otworz plik do zapisu
			fwrite(hex, 3, 3, plik); // Zapisz do pliku
			fclose(plik);
			Operacja_sem(1, 1);

			//jak wyslales 15 znakow lub trafiles na enter - wyslij enter
			if(i++ == 14 || odczyt == '\n')
			{
				i = 0;
				Operacja_sem(0, -1);

				FILE *plik = fopen("plik", "w"); // Otworz plik do zapisu
				fwrite(" \n", 3, 3, plik); // Zapisz do pliku
				fclose(plik);

				Operacja_sem(1, 1);
			}
		}
	}
}










void proc2()
{	/*
	pid[1] = getpid();

	//odbiera pid p1
	char pidP1[10];
	read(rura[0], &pidP1, sizeof(pidP1));
	pid[0] = atoi(pidP1);

	//wysyla plikiem pid do p3
	Operacja_sem(0, -1);
	FILE *plik = fopen("plik", "w"); // Otworz plik do zapisu
	fwrite(pidP1, 10, 10, plik); // Zapisz do pliku
	fclose(plik);
	Operacja_sem(1, 1);

	sprintf(pidP1, "%d", getpid());

	Operacja_sem(0, -1);
	plik = fopen("plik", "w"); // Otworz plik do zapisu
	fwrite(pidP1, 10, 10, plik); // Zapisz do pliku
	fclose(plik);
	Operacja_sem(1, 1);
	*/

	char odczyt[0];
	while(1)
	{
		while(zatrzymane);

		Operacja_sem(1, -1); // Opusc semafor do czytania
		FILE *plik = fopen("plik", "r"); // Otworz plik do czytania
		if(fread(odczyt, 1, 1, plik)) //odczyt pipe
		{
			//zamienia odebrany znak na hex
			char hex[3];
			sprintf(hex, "%02x ", (unsigned char) odczyt);


			//wysyla znak do p3
			write(rura[1], hex, sizeof(hex));

			fclose(plik);	//Zamknij plik
			Operacja_sem(0, 1); // Podnies semafor do pisania
		}
	}
}
















void p3()
{
	char pidP[10];

	Operacja_sem(1, -1); // Opusc semafor do czytania
	FILE *plik = fopen("plik", "r"); // Otworz plik do czytania
	fread(pidP, 10, 10, plik); // Czytaj
	fclose(plik);	//Zamknij plik
	Operacja_sem(0, 1); // Podnies semafor do pisania
	pid[0] = atoi(pidP);

	Operacja_sem(1, -1); // Opusc semafor do czytania
	plik = fopen("plik", "r"); // Otworz plik do czytania
	fread(pidP, 10, 10, plik); // Czytaj
	fclose(plik);	//Zamknij plik
	Operacja_sem(0, 1); // Podnies semafor do pisania
	pid[1] = atoi(pidP);

	pid[2] = getpid();

	char odczyt[3];
	while(1)
	{
		while(zatrzymane);

		Operacja_sem(1, -1); // Opusc semafor do czytania
		plik = fopen("plik", "r"); // Otworz plik do czytania
		fread(odczyt, 3, 3, plik); // Czytaj
		fclose(plik);	//Zamknij plik
		Operacja_sem(0, 1); // Podnies semafor do pisania

		fprintf(stdout, "%s", odczyt); // Wydrukuj na strumień standardowy
		fflush(stdout); //wymus wyczyszczenie bufora

	}
}











void proc3()
{	/*
	char pidP[10];

	Operacja_sem(1, -1); // Opusc semafor do czytania
	FILE *plik = fopen("plik", "r"); // Otworz plik do czytania
	fread(pidP, 10, 10, plik); // Czytaj
	fclose(plik);	//Zamknij plik
	Operacja_sem(0, 1); // Podnies semafor do pisania
	pid[0] = atoi(pidP);

	Operacja_sem(1, -1); // Opusc semafor do czytania
	plik = fopen("plik", "r"); // Otworz plik do czytania
	fread(pidP, 10, 10, plik); // Czytaj
	fclose(plik);	//Zamknij plik
	Operacja_sem(0, 1); // Podnies semafor do pisania
	pid[1] = atoi(pidP);

	pid[2] = getpid();
	*/
	char odczyt[3];
	int i = 0;
	while(1)
	{
		while(zatrzymane);

		if(read(rura[0], &odczyt, 3)) //odczyt pipe
		{
		fprintf(stdout, "%s", odczyt); // Wydrukuj na strumień standardowy
		fflush(stdout); //wymus wyczyszczenie bufora
			if(x++ == 14){
			printf("\n");
			x = 0;
			}

		}
	}
}
















 /*
  * jest 6 sygnalow. Podstawowe i wtorne
  * Podstawowe wysyla uzytkownik
  *
  * W przypadku otrzymania podstawowego sygnalu nalezy go zamienic na wtorny i obsluzyc
  * W przypadku wtornego, tylko obsluzyc
  *
  * NP.
  * P1 dostaje stop (10)
  * P1 rozsyla sygnal 18
  * P1 obsluguje 10 (zatrzymuje sie)
  *
  * P2 dostaje 18
  * P2 obsluguje 18 (zatrzymuje sie)
  *
  * Bez tej 18 procesy by zaczely grac w ping ponga
  */
void sygnalOdb(int sygnal)
{
	if(sygnal < 13) //2,10,12 -> procesy pierwotne
	{
		int sygnal2;

		if(sygnal == 2) //sygnal numer 2 "zamienia sie" w 14
			sygnal2 = 14;
		else if(sygnal == 10)
			sygnal2 = 18;
		else if(sygnal == 12)
			sygnal2 = 20;

		for(int i = 0; i < 3; i++) //wyslij wtorny do kazdego oprocz siebie
			if(pid[i] != getpid())
				kill(pid[i], sygnal2);
	}

	for(int i = 0; i < 3; i++) //obsluga sygnalow
		if(pid[i] == getpid()) //jak nie jestes matka
		{
			if(sygnal == 2 || sygnal == 14) //jak 2 lub 14 to zakoncz itd.
				exit(3);
			else if(sygnal == 10 || sygnal == 18) //stop
				zatrzymane = 1;
			else if(sygnal == 12 || sygnal == 20) //wznow
				zatrzymane = 0;
		}
}

int main(void)
{
	//tworze pipe
	pipe(rura);

	//TWorze tablice semaforow
	semafor = semget(7777, 2, 0777 | IPC_CREAT);

	//UStawiam numerSygi poczatkowe semaforow - mozna pisac, nie mozna czytac
	semctl(semafor, 0, SETVAL, 1);
    semctl(semafor, 1, SETVAL, 0);

    //rejestracja sygnalow
    signal(2, sygnalOdb);
    signal(10, sygnalOdb);
    signal(12, sygnalOdb);
    signal(18, sygnalOdb);
    signal(14, sygnalOdb);
    signal(20, sygnalOdb);

 	if((pid[2] = fork()) == 0) // PROCES 3
 	{
		p3();
	}

 	if((pid[1] = fork()) == 0) // P2
 	{
		p2();
	}

	if((pid[0] = fork()) == 0) // P1
	{
		p1();
	}

	//czekaj na koneic dzialania
	waitpid(pid[0], NULL, 0);
	waitpid(pid[1], NULL, 0);
	waitpid(pid[2], NULL, 0);

	//Usuwanie semaforów
	semctl(semafor, 0, IPC_RMID);
	//usun plik
	remove("plik");

	return 0;
}