#include <stdio.h>

#include <stdlib.h>

#include <sys/wait.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <unistd.h>

#include <string.h>

#include <fcntl.h>

#define P_C1 "fifo_pc1"

#define P_C2 "fifo_pc2"

#define C1_P "fifo_c1p"

#define C2_P "fifo_c2p"



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

    if(mkfifo(P_C1, 0600)

            || mkfifo(P_C2, 0600)

            || mkfifo(C1_P, 0600)

            || mkfifo(C2_P, 0600)) {

        perror("Error creating fifos");

        unlink(P_C1);

        unlink(P_C2);

        unlink(C1_P);

        unlink(C2_P);

        exit(1);

    }



    int f1 = fork();

    if(-1 == f1) {

        perror("Error on child 1");

    } else if (0 == f1) {

        int p_c1 = open(P_C1, O_RDONLY);

        int c1_p = open(C1_P, O_WRONLY);

        if(p_c1 < 0 || c1_p < 0) {

            perror("C1 - Failed to open fifos");

            exit(1);

        }

        int len = 0;

        if(0 >= read(p_c1, &len, sizeof(int))) {

            perror("C1 - Error on read length");

            exit(1);

        }

        char *msg = malloc(sizeof(char) * len);

        if(0 >= read(p_c1, msg, sizeof(char) * len)) {

            perror("C1 - Error reading message");

            exit(1);

        }

        char *rez = malloc(sizeof(char) * len);

        int count = 0;

        for(int i = 0; i < len; i++) {

            if(msg[i] == 'a' || msg[i] == 'e' || msg[i] == 'i' || msg[i] == 'o' || msg[i] == 'u' ||

                    msg[i] == 'A' || msg[i] == 'E' || msg[i] == 'I' || msg[i] == 'O' || msg[i] == 'U') {

                rez[count++] = msg[i];

            }

        }

        free(msg);

        rez[count++] = 0;



        if(0 > write(c1_p, &count, sizeof(int))) {

            perror("C1 - Error writing length");

            exit(1);

        }



        if(count > 0) {

            if(0 > write(c1_p, rez, sizeof(char) * count)) {

                perror("C1 - Error writing result");

                exit(1);

            }

        }



        free(rez);

        close(p_c1);

        close(c1_p);

        exit(0);

    }



    int f2 = fork();

    if(-1 == f2) {

        perror("Error on child 2");

    } else if (0 == f2) {

        int p_c2 = open(P_C2, O_RDONLY);

        int c2_p = open(C2_P, O_WRONLY);

        if(p_c2 < 0 || c2_p < 0) {

            perror("C2 - Failed to open fifos");

            exit(1);

        }

        int len = 0;

        if(0 >= read(p_c2, &len, sizeof(int))) {

            perror("C2 - Error on read length");

            exit(1);

        }

        char *msg = malloc(sizeof(char) * len);

        if(0 >= read(p_c2, msg, sizeof(char) * len)) {

            perror("C2 - Error reading message");

            exit(1);

        }

        char *rez = malloc(sizeof(char) * len);

        int count = 0;

        for(int i = 0; i < len; i++) {

            if(msg[i] >= '0' && msg[i] <= '9') {

                rez[count++] = msg[i];

            }

        }

        free(msg);

        rez[count++] = 0;

        if(0 > write(c2_p, &count, sizeof(int))) {

            perror("C2 - Error writing length");

            exit(1);

        }

        if(count > 0) {

            if(0 > write(c2_p, rez, sizeof(char) * count)) {

                perror("C1 - Error writing result");

                exit(1);

            }

        }

        free(rez);

        close(p_c2);

        close(c2_p);

        exit(0);

    }



    int p_c1 = open(P_C1, O_WRONLY);

    int c1_p = open(C1_P, O_RDONLY);

    int p_c2 = open(P_C2, O_WRONLY);

    int c2_p = open(C2_P, O_RDONLY);

    char *in = malloc(sizeof(char) * 100);

    scanf("%s", in);

    int len = strlen(in);

    if(0 > write(p_c1, &len, sizeof(int))) {

        perror("P - Error writing message length to C1");

    } else {

        if(0 > write(p_c1, in, sizeof(char) * len)) {

            perror("P - Error writing message to C1");

        }

    }



    if(0 > write(p_c2, &len, sizeof(int)))  {

        perror("P - Error writing message length to C2");

    } else {

        if(0 > write(p_c2, in, sizeof(char) * len)) {

            perror("P - Error writing message to C2");

        }

    }

    free(in);



    int rez_len = 0;

    if (0 >= read(c1_p, &rez_len, sizeof(int))) {

        perror("P - Error reading length from C1");

        rez_len = 0;

    }

    if(rez_len > 0) {

        char *rez = malloc(sizeof(char) * rez_len);

        if(0 >= read(c1_p, rez, sizeof(char) * rez_len)) {

            perror("P - Error reading message from C1");

        } else {

            printf("First child: %s\n", rez);

        }

        free(rez);

    }



    rez_len = 0;

    if (0 >= read(c2_p, &rez_len, sizeof(int))) {

        perror("P - Error reading length from C2");

        rez_len = 0;

    }

    if(rez_len > 0) {

        char *rez = malloc(sizeof(char) * rez_len);

        if(0 >= read(c2_p, rez, sizeof(char) * rez_len)) {

            perror("P - Error reading message from C1");

        } else {

            printf("Second child: %s\n", rez);

        }

        free(rez);

    }

    unlink(P_C1);

    unlink(P_C2);

    unlink(C1_P);

    unlink(C2_P);

    wait(NULL);

    wait(NULL);



    return 0;

}