#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>

// Manejador de alarma
void alarma() {}

void manejador1() {
    execlp ("ls","ls",NULL);
}

void manejador2() {
    execlp ("pstree","pstree","-p",NULL);
}

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

    // Los pid de cada uno
    pid_t pidEjec, pidA, pidB, pidX, pidY, pidZ, objetivo;

    int seg; // Para los segundos que se pasa por argumento
    seg=atoi(argv[2]); // Los convertimos a int

    char proceso=*argv[1]; // Guardamos el primer argumento en una variable char

    /* Aqui guarda el pid del ejec */
    pidEjec = getpid();

    switch(fork()) {

    case -1 : /* ERROR */
            perror("Error en fork ejec\n");
            exit(1);

    case 0 : /* Hijo de arb (A) */
            pidA = getpid(); // Guardamos el pid de A

            switch(fork()) { /* A crea B */

                case -1 : /* ERROR */
                        perror("Error en fork A\n");
                        exit(1);

                case 0 : /* Hijo de A (B) */

                    switch(fork()) { /* B crea X */

                        case -1 : /* ERROR */
                                perror("Error en fork B\n");
                                exit(1);

                        case 0 : /* X */

                                // Guardamos el pid de X
                                pidX = getpid();

                                printf("Soy el proceso X: mi pid es %d. Mi padre es %d. Mi abuelo es %d. Mi bisabuelo es %d\n", getpid(), getppid(), pidA, pidEjec);
                                signal(SIGALRM,alarma);

                                signal(SIGUSR1, manejador1);

                                alarm(seg);
                                pause();



                                printf("Soy X(%d) y muero\n", getpid());
                                exit(0);
                        default :
                                switch(fork()) { /* B crea Y */

                                    case -1 : /* ERROR */
                                            perror("Error en fork B\n");
                                            exit(1);

                                    case 0 : /* Y */

                                            // Guardamos el pid de Y
                                            pidY = getpid();

                                            printf("Soy el proceso Y: mi pid es %d. Mi padre es %d. Mi abuelo es %d. Mi bisabuelo es %d\n", getpid(), getppid(), pidA, pidEjec);
                                            signal(SIGALRM,alarma);

                                            signal(SIGUSR1, manejador1);

                                            alarm(seg);
                                            pause();



                                            printf("Soy Y(%d) y muero\n", getpid());
                                            exit(0);
                                    default :
                                            switch(fork()) { /* B crea Z */

                                                case -1 : /* ERROR */
                                                        perror("Error en fork B\n");
                                                        exit(1);

                                                case 0 : /* Z */

                                                        //El pid de Z no es necesario guardarlo

                                                        printf("Soy el proceso Z: mi pid es %d. Mi padre es %d. Mi abuelo es %d. Mi bisabuelo es %d\n", getpid(), getppid(), pidA, pidEjec);
                                                        signal(SIGALRM,alarma);
                                                        alarm(seg);
                                                        pause();

                                                        // Determinamos el objetivo que va a ejecutar
                                                        switch(proceso) {
                                                            case 'A' : objetivo=pidA; break;
                                                            case 'B' : objetivo=pidB; break;
                                                            case 'X' : objetivo=pidX; break;
                                                            case 'Y' : objetivo=pidY; break;
                                                            default : printf("Parametro 1 incorrecto, no se hace nada.\n");
                                                        }

                                                        // Envio la señal quien toque
                                                        kill(objetivo, SIGUSR1);

                                                        printf("Soy Z(%d) y muero\n", getpid());
                                                        exit(0);

                                                default : /* B */

                                                    // Guardamos el pid de B
                                                    pidB = getpid();

                                                    // B: su padre (A) esta guardado en pidA, su pidA (arb) en pidEjec
                                                    printf("Soy el proceso B: mi pid es %d. Mi padre es %d. Mi abuelo es %d\n", getpid(), getppid(), pidEjec);

                                                    signal(SIGUSR1, manejador2);

                                                    // B espera a que mueran sus 3 hijos
                                                    wait();
                                                    wait();
                                                    wait();
                                                    printf("Soy B(%d) y muero\n", getpid());
                                                    exit(0);
                                            }
                                }
                    }

                default : /* A */
                        printf("Soy el proceso A: mi pid es %d. Mi padre es %d\n", getpid(), pidEjec);

                        signal(SIGUSR1, manejador2);

                        wait(); /*Espera a su hijo*/
                        printf("Soy A(%d) y muero\n", getpid());
                        exit(0);
                }

    default : /* Raiz del arbol (arb) */
            printf("Soy el proceso ejec: mi pid es %d\n", getpid());
            wait(); /*Espera a su hijo*/
            printf("Soy ejec(%d) y muero\n", getpid());
            exit(0);
    }
}