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

#define _GNU_SOURCE

void invertion(char* strinv);
void casechanger(char* strcase);
void koi8er(char* strkoi);
void swapper(char* strswp);
void sigcatch(int);
int flag;

//Функции обработки строки для процесса 1.

void invertion(char* strinv){  // Инверсия строки.
    int len = strlen(strinv);
    for (int pos = 2; pos - 2 < (len - 2) / 2; pos++) {
        char res = strinv[pos];
        strinv[pos] = strinv[len - 1 - (pos - 2)];
        strinv[len - 1 - (pos - 2)] = res;
    }
}

void koi8er(char* strkoi) {  // Перевод строки в koi8.
    int len = strlen(strkoi);
    for (int dig = 0; dig < len; dig++) {
        if (strkoi[dig] >= 'a' && strkoi[dig] <= 'z') {
            strkoi[dig] += 96;
        } else  {
            strkoi[dig] += 160;
        }
    }
}

void swapper(char* strswp) {  // Перестановка соседних символов строки.
    int swplen = strlen(strswp);
    for (int pl = 1; pl < swplen / 2; pl++) {
        char swp = strswp[2 * pl];
        strswp[2 * pl] = strswp[2 * pl + 1];
        strswp[2 * pl + 1] = swp;
    }
}

 // Функции обработки строки для Процесса 2.
void casechanger(char* strcase) {  // Функция управления регистром букв в строке.
    int len = strlen(strcase);
    switch (strcase[1]) {
        case '1':
            for (int ch = 0; ch < len; ch++) {
                strcase[ch] = toupper(strcase[ch]);
            }
            break;

        case '2':
            for (int ch = 0; ch < len; ch++) {
                strcase[ch] = tolower(strcase[ch]);
            }
            break;

        case '3':
            for (int ch = 0; ch < len; ch++)
                if (toupper(strcase[ch]) == strcase[ch]) {
                    strcase[ch] = tolower(strcase[ch]);
                } else {
                    strcase[ch] = toupper(strcase[ch]);
                }
            break;

    }
}

void sigcatch(int sig) {  // Функция перехвата сигнала прерывания для ввода команд.
    signal(SIGINT, sigcatch);

    printf("\n\t////////////////////////////////////\n");
    printf("\n\tEnter the type of string alteration.\n");
    printf("%s%s%s%s%s",
            "Commands for Tier 1 alteration :\n\t",
            "/def1 - string is not altered;\n\t",
            "/invert - invert the string;\n\t",
            "/swap - swap nearby pairs of symbols in string;\n\t",
            "/koi8 - convertion to koi-8.\n"
            );
    printf("%s%s%s%s%s",
            "Commands for Tier 2 alteration :\n\t",
            "/def2 - string is not altered;\n\t",
            "/upreg - make all characters in upper case;\n\t",
            "/lowreg - make all characters inlower case\n\t" ,
            "/swreg - swap the register of each character;\n"
            );
    printf("\n\t////////////////////////////////////\n");

    char cmnd[10];
    scanf("%s", cmnd);
    if (!strcmp(cmnd, "/def1")) {
        flag %= 10;
        printf("\tDefault 1\n");
        return;
    }

    if (!strcmp(cmnd, "/invert")) {
        flag = flag % 10 + 10;
        printf("\tInvert str\n");
        return;
    }

    if (!strcmp(cmnd, "/swap")) {
        flag = flag % 10 + 20;
        printf("\tSwap Sym\n");
        return;
    }

    if (!strcmp(cmnd, "/koi8")) {
        flag = flag % 10 + 30;
        printf("\tKoi-8\n");
        return;
    }

    if (!strcmp(cmnd, "/def2")) {
        flag = (flag / 10) * 10;
        printf("\tDefault 2\n");
        return;
    }

    if (!strcmp(cmnd, "/upreg")) {
        flag = (flag / 10) * 10 + 1;
        printf("\tUp Reg\n");
        return;
    }

    if (!strcmp(cmnd, "/lowreg")) {
        flag = (flag / 10) * 10 + 2;
        printf("\tLow Reg\n");
        return;
    }

    if (!strcmp(cmnd, "/swreg")) {
        flag = (flag / 10) * 10 + 3;
        printf("\tSwap Reg\n");
        return;
    }

    if (!strcmp(cmnd, "/out")) {
        flag = 44;
        printf("\tExit\n");
        return;
    }
    printf("\tCommand not found\n");
}

int main(int argc, char *argv[])
{
    int pipefd[2];
    int pipemy[2];
    pid_t pid0 = getpid(), pid1, pid2, ppid;

    if (pipe(pipefd) == -1) {  // Создание канала Процесс 0-Процесс 1.
        perror("pipe");
        exit(EXIT_FAILURE);
    }

    pid1 = fork();  // Порождение Процесса 1.
    if (pid1 == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if (getppid() == pid0) {
        if (pipe(pipemy) == -1) {  // Создание канала Процесс 1-Процесс 2.
            perror("pipe");
            exit(EXIT_FAILURE);
        }

        pid2 = fork();  // Порождение Процесса 2.
        if (pid2 == -1) {
             perror("fork");
             exit(EXIT_FAILURE);
        }
    }
    ppid = getppid();

    int i = 0;
    if ((getpid() != pid0) && pid2)
    {
        close(pipefd[1]);
        close(pipemy[0]);
        signal(SIGINT, SIG_IGN);
        while(1) {
            char buf[50];
            i = 0;
            // Процесс 1 усыпляет себя до тех пор, пока его не пробудит Процесс 0.
            kill(getpid(), SIGSTOP);

            do {
                read(pipefd[0], buf + i, 1);
                i++;
            } while (buf[i - 1] != '\n');

            buf[i] = '\0';

            switch(buf[0]) { // Выявление способа обработки строки по коду в ней.
                case '1':
                    invertion(buf);
                    break;

                case '2':
                    swapper(buf);
                    break;

                case '3':
                    koi8er(buf);
                    break;

                default:
                    break;
            }

            int m = 2;
            int len_buf = strlen(buf);
            write(1,"\tProc 1 : ", 11);
            write(1, buf, len_buf);
            printf("\n");
            buf[i - 1] = '\n';
            // После передачи в канал обработанной строки Процесс 1 пробуждает Процесс 2.
            write(pipemy[1], buf, i );
            kill(pid2, SIGCONT);
        }
        _exit(EXIT_SUCCESS);
    }
    else
    if ((getpid() != pid0) && (!pid2))
    {
        close(pipefd[0]);
        close(pipefd[1]);
        close(pipemy[1]);
        signal(SIGINT, SIG_IGN);
        while(1)
        {
            i = 0;  // Процесс 2 усыпляет себя в ожидании строки от Процесса 1.
            char final[50];
            kill(getpid(), SIGSTOP);


            do {
                read(pipemy[0], final + i, 1);
                i++;
            } while (final[i - 1] != '\n');


            final[i] = '\0';
            casechanger(final);
            i = 2;
            int len_final = strlen(final);
            write(1,"\tProc 2 : ", 11);
            write(1, final, len_final);
            printf("\n");
        }
    }


     else
        { //beginnig of work
        char inputer[50];
        close(pipefd[0]);
        signal(SIGINT, sigcatch);
        printf("Enter the string to alt it in different ways:\n");
        inputer[0] = inputer[1] = '0';
        while (1)
        {
            i = 2;
            do {
                read(0, inputer + i, 1);
                i++;
            } while (inputer[i - 1] != '\n');
            char transl;
            for (int m = 0; m < 2; m++)
            {
                if (!m) {
                    transl = flag / 10;
                } else {
                    transl = flag % 10;
                }
                 switch (transl) {
                    case 0:
                        inputer[m] = '0';
                        break;

                    case 1:
                        inputer[m] = '1';
                        break;

                    case 2:
                        inputer[m] = '2';
                        break;

                    case 3:
                        inputer[m] = '3';
                        break;

                    default:
                        printf("bye ...");
                        break;
                }
            }
            if (flag == 44) {
                printf("\tExiting...\n\n");
                kill(pid1,SIGTERM);
                kill(pid2, SIGTERM);
                return 0;
            }
            inputer[i - 1] = '\0';
            write(1,"\tProc 0 : ", 11);
            int len_inputer = strlen(inputer);
            write(1, inputer, len_inputer);
            printf("\n");
            inputer[i - 1] = '\n';
            write(pipefd[1], inputer, i);
// Процесс 0 пробуждает процесс 1 после отправки ему строки для обработки.
            kill(pid1, SIGCONT);
        }
        wait(NULL);
        exit(EXIT_SUCCESS);

    }
    return 0;
}