#include <iostream>
#include <sys/types.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include<sys/wait.h>
#include <string.h>
using namespace std;

int funkcja_dziecka()
{

    execl("/usr/bin/cal","cal",NULL);
    return 0;
}


void funkcja_dziecka2(int *fd)
{
    for (int i=1; i<=10; i++)
    {

        if((write(fd[1], &i,sizeof(int) )!=-1))//jak write zwraca cos roznego od -1 to dziala
            sleep(1);
        else abort();//jak write zwroci -1 to blad, zakoncz program
    }
    exit(0);//zakoncz
}
void funkcja_dziecka3(int *fd, int id)
{
    char text[2];
    if (id == 0)   //czy jest potomkiem A
    {
        text[0] = 'A';

    }
    if (id == 1)   // czy jest potomkiem B
    {
        text[0] = 'B';

    }
    for (int i = 0; i < 10; i++)
    {
        text[1] = i + 48;
        write(fd[1], &text, sizeof(text));
    }
    exit(0);
}
void zad21()
{
    pid_t p;
    p=fork();

    if(p==-1)
    {
        //jak jets blad przerywamy program

        perror("fork");
        abort();
    }

    if(p==0)
    {
        try
        {
            int ret=funkcja_dziecka();
            exit(ret);
        }
        catch(...)
        {
            exit(1);
        }
    }

    else
    {
        wait(NULL);

    }
}
int zad22()
{
    pid_t p;
    int dane;
    int fd[2];
    pipe(fd);
    if(pipe(fd) < 0)
    {
        printf("Blad funkcji pipe\n");
        return -1;
    }



    p=fork();

    if(p==-1)
    {
        //jak jets blad przerywamy program

        perror("fork");
        abort();
    }

    if(p==0)
    {
        try
        {

            funkcja_dziecka2(fd);

        }
        catch(...)
        {
            exit(1);
        }

    }




    else//rodzic
    {
        while (read(fd[0], &dane, sizeof(int))) //czytanie od potomka
        {
            cout << dane << std::endl; //wyswietlenie tego co odczytal
        }
        int *status;
        wait(&status);
    }
}
int zad23()
{
    pid_t p;
    int id=0;//by rozronic potomkow
    int fdA[2]; // deskryptor dla potomka A
    int fdB[2]; // deskryptor dla potomka B
    if(pipe(fdA) < 0)
    {
        printf("Blad funkcji pipe\n");
        return -1;
    }
    if(pipe(fdB) < 0)
    {
        printf("Blad funkcji pipe\n");
        return -1;
    }

    p=fork();
    if(p!=0)
    {
        id++;
        p=fork();//drugi potomek
    }

    if(p==-1)
    {
        //jak jets blad przerywamy program

        perror("fork");
        abort();
    }

    if(p==0)
    {
        try
        {
            if(id==0) funkcja_dziecka3(fdA,id);
            if(id==1) funkcja_dziecka3(fdB,id);
        }
        catch(...)
        {
            exit(1);
        }

    }
    else
    {

        //close(filefdA[1]); //zamkniecie strumienia pisania
        //close(filefdB[1]); //zamkniecie strumienia pisania
        char dane[2];
        while (read(fdA[0], &dane, sizeof(dane)) > 0) //dopoki potomek A pisze -> czytaj
        {
            std::cout << dane << std::endl; //wyswietlenie bufora
        }
        while (read(fdB[0], &dane, sizeof(dane)) > 0) //dopoki potomek B pisze -> czytaj
        {
            std::cout << dane << std::endl; //wyswietlenie bufora
        }
        int * status;
        wait(&status); //obsluga zakonczenia potomka
    }

}

void zad24()
{
}


int main()
{
    //zad21();
    // zad22();
    zad23();
    return 0;
}