#include <iostream>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <vector>
#include <fstream>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

#define MAX_BUFFER 100

///EJERCICIO 1
//Crea un proceso que cree tres procesos hijos de forma secuencial. Los hijos no deben existir a la vez.
//El hijo 2 se generará cuando muera el 1 y el 3 cuando muera el 2
//Evita los procesos zombie

int main(){
    for(int i = 0; i < 3; ++i){
        pid_t pid = fork();
        if(pid != 0){
            int test;
            wait(&test);
        }
        else{
            std::cout << "Soy el hijo" << getpid();
            return 0;
        }
    }
    return 0;
}

///EJERCICIO 3
//Crea un proceso que cree un hijo que a su vez abra un firefox.
//Evita que el hijo quede zombie antes de cerrar el padre.

int main(){
    pid_t pid = fork();
    if(pid == 0){
        execl("usr/bin/chrome", (char*)0);
        std::cout << "Esto no debería salir" << std::endl;
    }
    else{
        int status;
        wait(&status);
        std::cout << "Se cerró el Firefox." << std::endl;
    }
}

///EJERICIO 4
//Crea un proceso que cree dos procesos hijo que abran Firefox y LibreOffice respectivamente.
//Evita que queden zombies antes de acabar el padre.

int main(){
    pid_t pid1, pid2;
    int status1, status2;

    if(pid1 = fork() == 0){
        execl("/usr/bin/firefox", (char*)0);
        std::cout << "Error al ejecutar el hijo 1." << std::endl;
    }
    else{
        if(pid2 = fork() == 0){
            execl("/usr/bin/google-chrome", (char*)0);
            std::cout << "Error en la creación del hijo 2" << std::endl;
        }
        else{
            //Esperamos a que finalice el hijo 2.
            waitpid(pid2, &status2, 0);
        }
        //Esperamos a que finalice el hijo 1.
        waitpid(pid1, &status1, 0);
    }
    //Padre acaba de ejecutarse cuando ambos hijos han finalizado.
    std::cout << "Los hijos han finalizado con exito, soy el padre" << std::endl;
    return 0;
}

///EJERCICIO 5
//Crea un programa en c++ desed Code::BLocks que printe del 1 al 1000
//Crea otro programa que contenga un proceso que cree dos procesos hijos. Desde cada uno de los hijos debe llamarse al programa anterior.
//Comprueba como el dispatcher hace su trabajo.
//Evita que los procesos queden zombies antes de acabar el padre.

void counter(){
    for(int i = 0; i < 1000; ++i){
        std::cout << i << " ";
    }
    std::cout << std::endl;
}

void sonCreator(){
    pid_t pid, pid2;
    int status1, status2;

    if(pid = fork() == 0){
        counter();
    }
    else{
        if(pid2 = fork() == 0){
            counter();
        }
        else{
            //Esperamos a que muera el primer proceso hijo
            waitpid(pid, &status1, 0);
            //Esperamos a que muera el segundo proceso hijo
            waitpid(pid2, &status2, 0);
        }
    }
    std::cout << "Los hijos han finalizado con exito, soy el padre." << std::endl;
}

int main(){
    sonCreator();

    return 0;
}

///EJERCICIO 6
//Crea un programa en C++ que pida algo por teclado, lo printe y vuelva a pedir algo por teclado y printe, hasta que se entre por teclado "Exit"
//Crea otro programa que contenga un proceso que cree otros dos procesos hijos. Desde cada uno de los hijos debe llamarse al programa anterior.
//Evita que los procesos queden zombie. Explica como lo has conseguido.

int main(){
    int status;
    pid_t pid1 = fork();
    char recoge;
    if(pid1 == 0){
        while(1){
            std::cin >> recoge;
            std::cout << "Proceso hijo recoge." << recoge << std::endl;
        }
    }
    else{
        while(1){
            std::cin >> recoge;
            std::cout << "Salta el recoge del padre" << std::endl;
            std::cout << "Proceso padre recoge." << recoge << std::endl,
        }
    }

    return 0;
}

void ControlSalida(int _param){
    char c;
    std::cout << "Quieres salir del programa? S/n: ";
    std::cin >> c;

    if(c == 'S' || c == 's'){
        exit(0);
    }
}

void ControlAlarma(int _param){
    exit(0);
}

int main(){
    signal(SIGINT, ControlSalida);
    signal(SIGALRM, ControlAlarma);
    alarm(20);
    while(1){
        pause();
    }
}

void Despertando(int _param){
    alarm(5);
}

void DespiertaTroll(int _param){
    std::cout << "Despierta el troll" << std::endl;
}

///EJERCICIO 11
int main(){
    pid_t pid = fork();
    if(pid == 0){
        ///HIJO
        std::cout << "Clica tecla para despertar al troll ... ";


        char l;
        std::cin >> l;
        kill(getppid(), SIGUSR1);
        pause();
    }
    else{
        ///PADRE
        signal(SIGUSR1, Despertando);
        signal(SIGALRM, DespiertaTroll);
        while(1) pause();
    }
}

///EJERCICIO 12
//
void SignalEntrada(int _param){
    alarm(5);
}

void SignalDespertar(int _param){
    std::cout << "Se ha despertado troll" << std::endl;
}

int main() {
    std::cout << "Cuantos npc quieres crear?: ";
    int counter;
    std::cin >> counter;
    std::vector<pid_t> pidTrolls;
    for(int i = 0; i < counter; ++i){
        pid_t pid = fork();
        if(pid == 0){
            ///PROCESO TROLL
            signal(SIGUSR1, SignalEntrada);
            signal(SIGALRM, SignalDespertar);

            while(1) pause();
        }
        else{
            ///PROCESO PADRE
            pidTrolls.push_back(pid);
        }
    }
    ///PROCESO PADRE
    std::cout << "Despertamos a los trolls?" << std::endl;
    char tecla;
    std::cin >> tecla;
    for(int i = 0; i < pidTrolls.size(); ++i){
        kill(pidTrolls[i], SIGUSR1);
    }

    while(1) pause();
    return 0;
}

///EJERCICIO 13

pid_t pidMove, pidMap;

void AvisaAlHijoMapa(int _param){
    kill(pidMap, SIGUSR1);
}

void MsgCargaMapa(int _param){
    std::cout << "Se carga nueva zona del mapa" << std::endl;
}

int main(){
    if(pidMove = fork() == 0){
        ///PROCESO HIJO - MOVIMIENTO
        for(int i = 0; i < 5; ++i){
            for(int j = 0; j < 5; ++j){
                std::cout << "(" << i << "," << j << ")" << std::endl;
                sleep(1);
            }
            kill(getppid(), SIGUSR1);
        }
    }
    else{
        ///PROCESO PADRE
        if(pidMap = fork() == 0){
            ///PROCESO HIJO - MAPA
            signal(SIGUSR1, MsgCargaMapa);
            while(1) pause();
        }
        else{
            ///PROCESO PADRE
            signal(SIGUSR1, AvisaAlHijoMapa);
            int status;
            wait(&status);
            kill(pidMap, SIGKILL);
            //while(1) pause();
        }
    }
    ///PROCESO PADRE

    return 0;

}

///1.Cerrar el STD:out
///2.Abrir un fichero en modo WR
///3.couts...
///4.Cerrar este fichero

int main(){
    int fd_in;

    close(1);
    fd_in = open("/home/juan/Escritorio/hola.txt", O_WRONLY);
    if(fd_in < 0){
        std::cout << "Error al abrir el fichero Hola.txt" << std::endl;
        exit(0);
    }

    std::cout << "Hola chicos." << std::endl;

    close(fd_in);
    return 0;
}

int main(){
    int estado;
    pid_t pidHijo;
    int fd[2];
    char buffer[512];
    char buffer2[512];
    char buffer3[512];

    estado = pipe(fd);
    if(estado < 0){
        std::cout << "Error al crear la pipe" << std::endl;
    }

    pidHijo = fork();
    if(pidHijo == 0){
    ///PROCESO HIJO
        close(fd[0]);
        write(fd[1], "Retrasado", 9);
        write(fd[1], "Retrasado2", 10);
        write(fd[1], "Retrasado3", 10);
        std::cout << "Adios hijo" << std::endl;
    }
    else{
    ///PROCESO PADRE
        close(fd[1]);
        read(fd[0], buffer, 9);
        read(fd[0], buffer2, 10);
        read(fd[0], buffer3, 10);
        std::cout << buffer << std::endl;
        std::cout << buffer2 << std::endl;
        std::cout << buffer3 << std::endl;
        std::cout << "Hola" << std::endl;
    }
}

int main(){
    int estado;
    pid_t pidHijo;
    int fd[2];
    char buffer[512];

    estado = pipe(fd);
    if(estado < 0){
        std::cout << "Error al crear la pipe" << std::endl;
    }

    pidHijo = fork();
    if(pidHijo == 0){
        ///PROCESO HIJO
        write(fd[1], "Hola soy el hijo", 16);
        read(fd[0], buffer, 33);
        std::cout << buffer << std::endl;
    }
    else{
        ///PROCESO PADRE
        write(fd[1], "Hola soy el padre", 17);


    }
}

char buffer[512];
int fd[2];

void misCojones(int _param){
    read(fd[0], buffer, 24);
    std::cout << buffer << " recibido en el hijo 1" << std::endl;
}

//Ejercicio 20
int main(){
    int estado;
    pid_t pidHijo1, pidHijo2;
    char buffer2[512];

    estado = pipe(fd);
    if(estado < 0){
        std::cout << "Error al crear la pipe" << std::endl;
        exit(0);
    }

    pidHijo1 = fork();
    if(pidHijo1 == 0){
        ///HIJO 1
        close(fd[1]);
        signal(SIGUSR1, misCojones);
        pause();
    }
    else{
        pidHijo2 = fork();
        if(pidHijo2 == 0){
            ///HIJO 2
            close(fd[1]);
            read(fd[0], buffer2, 24);
            std::cout << buffer2 << " recibido en el hijo 2" << std::endl;
        }
        else{
            ///PADRE
            close(fd[0]);
            write(fd[1], "Te envio esto como padre", 24);
            kill(pidHijo1, SIGUSR1);
            //write(fd[1], "Te envio esto como padre2", 24);
        }
    }
}

int main(){
    int fd_out;

    close(STDOUT_FILENO);
    fd_out = open("/home/juan/Escritorio/hola.txt", O_WRONLY);
    if(fd_out < 0){
        std::cout << "Error al abrir el fichero Hola.txt" << std::endl;
        exit(0);
    }

    std::cout << "Molabas mas cuando eras Crema" << std::endl;

    close(fd_out);
    return 0;
}



//Ejercicio 16 - Parte 2 practica
int main(){
    int fdout = open("/home/juan/Escritorio/hola.txt", O_WRONLY);
    if(fdout < 0){
        exit(0);
    }
    pid_t pid = fork();
    if(pid == 0){
        std::string str="Soy el hijo";
        write(fdout, str.c_str(), str.size());
        close(fdout);
    }
    else{
        int
    }
}

//Ejercicio 21 - Parte 2 practica
int fdPipe1[2];
int fdPipe2[2];

void RecogeDePipe(int _param){
    int num;
    switch (_param)
    {
    case SIGUSR1:
        read(fdPipe1[0], &num, sizeof(int));
        std::cout << "Llega del H1 -->" << std::endl;
        break;
    case SIGUSR2:
        read(fdPipe2[0], &num, sizeof(int));
        std::cout << "Llega del H2 -->" << num << std::endl;
        break;
    default:
        break;
    }
}

int main(){
    ///En las pipes la posición 0 es de lectura y la 1 de escritura
    int pidHijo1, pidHijo2;
    int estado;
    size_t lenght = 512;
    char buffer[512];

    estado = pipe(fdPipe1);
    if(estado < 0){
        std::cout << "Error al crear pipe" << std::endl;
        exit(0);
    }
    estado == pipe(fdPipe2);
    if(estado < 0){
        std::cout << "Error al crear pipe" << std::endl;
        exit(0);
    }

    if(pidHijo1 = fork() == 0){
        ///PRIMER HIJO
        close(fdPipe1[0]);
        close(fdPipe2[0]);
        close(fdPipe2[1]);
        ///ENVIAR MENSAJES
        for(int i = 0; i <= 3; ++i){
            write(fdPipe1[1], &i, sizeof(int));
            kill(getppid(), SIGUSR1);  //El kill no mata al proceso, manda una señarl
            sleep(1);
        }
    }
    else{
        if(pidHijo2 = fork() == 0){
            ///SEGUNDO HIJO
            close(fdPipe2[0]);
            close(fdPipe1[0]);
            close(fdPipe1[1]);
            ///ENVIAR MENSAJES
            for(int i = 0; i <= 3; ++i){
                write(fdPipe2[1], &i, sizeof(int));
                kill(getppid(), SIGUSR2);  //El kill no mata al proceso, manda una señarl
                sleep(1);
            }
        }
        else{
            ///PADRE
            close(fdPipe1[1]);
            close(fdPipe2[1]);
            int status;
            wait(&status);
            wait(&status);
        }
    }

    return 0;
}

//Ejercicio 21 - Versión Alex

pid_t pidHijoUno, pidHijoDos;
int fdUno[2], fdDos[2];

void readPipe(int param)
{
    int num;

    if (param == SIGUSR1) {
        read(fdUno[0], &num, sizeof(int));
        std::cout << num << ", hijo 1\n";
        return;
    } else if (param == SIGUSR2) {
        read(fdDos[0], &num, sizeof(int));
        std::cout << num << ", hijo 2\n";
        return;
    }
}

int main()
{
    size_t length = 512;
    char buffer[512];

    signal(SIGUSR1, readPipe);
    signal(SIGUSR2, readPipe);

    int estadoUno = pipe(fdUno);
    if (estadoUno < 0)
    {
        std::cout << "Error al crear la pipe\n";
        exit(0);
    }

    int estadoDos = pipe(fdDos);
    if (estadoDos < 0)
    {
        std::cout << "Error al crear la pipe\n";
        exit(0);
    }

    pidHijoUno = fork();

    if (pidHijoUno == 0)
    { // Hijo 1
        close(fdUno[0]);
        close(fdDos[0]);
        close(fdDos[1]);

        for (int i = 0; i <= 3; i++)
        {
            write(fdUno[1], &i, sizeof(int));
            kill(getppid(), SIGUSR1);
            sleep(1);
        }
    }
    else
    { // Proceso padre

        pidHijoDos = fork();

        if (pidHijoDos == 0)
        { // Hijo 2
            close(fdUno[0]);
            close(fdUno[1]);
            close(fdDos[0]);

            for (int i = 0; i <= 3; i++)
            {
                write(fdDos[1], &i, sizeof(int));
                kill(getppid(), SIGUSR2);
                sleep(1);
            }
        }
        else
        { // Padre
            close(fdUno[1]);
            close(fdDos[1]);

            // Esperar a los hijoss
            int status;
            wait(&status);
            wait(&status);
        }
    }
}

int main(){
    int* p;
    int shmID = shmget(IPC_PRIVATE, sizeof(int), IPC_CREAT|0666);

    p = (int)shmat(shmID, NULL, 0);
}

///EJERCICIO 24 - DA FRESH
struct Mapa
{
    int x;
    int y;
};
Mapa* mapa;

void Pintar(int _param){
    std::cout << mapa->x << ", " << mapa->y << std::endl;
}

int main(){
    pid_t pidMoverPlayer;

    //Reserva del espacio de memoria compartida
    int shmID = shmget(IPC_PRIVATE, sizeof(Mapa), IPC_CREAT|0666);
    if(shmID < 0){
        std::cout << "Fallo al crear espacio de memoria compartida" << std::endl;
        exit(0);
    }

    //Vinculamos la memoria
    mapa = (Mapa*)shmat(shmID, NULL, 0);
    if(mapa < 0){
        std::cout << "Fallo al vincular memoria" << std::endl;
        exit(0);
    }

    pidMoverPlayer = fork();
    if(pidMoverPlayer == 0){
        ///PROCESO HIJO QUE MUEVE AL PLAYER
        for(int x = 0; x < 5; x++){
            mapa->x = x;
            for(int y = 0; y < 5; y++){
                mapa->y = y;
                kill(getppid(), SIGUSR1);
                sleep(1);
            }
        }
    }
    else{
        signal(SIGUSR1, Pintar);
        pause();
    }

    int status;
    wait(&status);
    shmdt(mapa);
    shmctl(shmID, IPC_RMID, NULL);
}
int number = 10000;
int* life = &number;

int main(){
    int pidDest1, pidDest2, pidDest3, pidDest4;

    int shmID = shmget(IPC_PRIVATE, sizeof(int), IPC_CREAT|0666);
    if(shmID < 0){
        std::cout << "Error al reservar memoria para compartir." << std::endl;
        exit(0);
    }

    life = (int*)shmat(shmID, NULL, 0);
    if(life < 0){
        std::cout << "Error al vincular memoria compartida." << std::endl;
        exit(0);
    }

    pidDest1 = fork();
    if(pidDest1 == 0){
        ///DESTRUCTOR 1
        life -= 100;
        std::cout << "Acabo de pegarle al edificio 100 - " << *life << std::endl;
    }
    else{
        pidDest2 = fork();
        if(pidDest2 == 0){
            ///DESTRUCTOR 2
            life -= 250;
            std::cout << "Acabo de pegarle al edificio 250 - " << *life << std::endl;
        }
        else
        {
            pidDest3 = fork();
            if(pidDest3 == 0)
            {
                ///CONSTRUCTOR 1
                life += 50;
                std::cout << "Acabo de curar al edificio 50 - " << *life << std::endl;
            }
            else
            {
                pidDest4 = fork();
                if(pidDest4 == 0)
                {
                    ///CONSTRUCTOR 2
                    life += 25;
                    std::cout << "Acabo de curar al edificio 25 - " << *life << std::endl;
                }
                else
                {
                    ///PROCESO PADRE
                    if(life <= 0)
                    {
                        std::cout << "BOOOOOOOOOOOOOOOOOOOOOOOOOOM" << std::endl;
                        sleep(2);
                    }
                }
            }
        }
    }

    int status;
    wait(&status);
    shmdt(life);
    shmctl(shmID, IPC_RMID, NULL);
}


//EJERCICIO 24 y 25 de la parte 3 de prácticas
//#define MAX 512

struct MapaDeJuego{
    int posX, posY;
};

MapaDeJuego* mapa;

void Repinta(int _param){
    for(int x = 0; x < MAX; x++){
        for(int y = 0; y < MAX; y++){
            if(x = mapa->posX && y == mapa->posY){
                std::cout << "O";
            }
            else{
                std::cout << "#";
            }
        }
    }
}

int main(){
    struct Datos* p;

    int shmID = shmget(IPC_PRIVATE, sizeof(MapaDeJuego), IPC_CREAT | 0666);

    if(p < 0){
        std::cout << "Error al reservar memoria" << std::endl;
        exit(0);
    }

    mapa = (MapaDeJuego*)shmat(shmID, NULL, 0);
    if(mapa < 0){
        std::cout << "Error al obetener puntero" << std::endl;
        exit(0);
    }

    signal(SIGUSR1, Repinta);
    pid_t pidHijo1 = fork();
    pid_t pidHijo2;
    if(pidHijo1 == 0){
        ///PROCESO HIJO --> MUEVE AL PERSONAJE CADA 1 SEG
        for(int x = 0; x < MAX; x++){
            mapa->posX = x;
            for(int y = 0; y < MAX; y++){
                mapa->posY = y;
                kill(getppid(), SIGUSR1);
                sleep(1);
            }
        }

        exit(0);
    }
    else {
        ///PROCESO PADRE
        pidHijo2 = fork();
        if(pidHijo2 == 0){
            //PROCESO HIJO 2 --> CREA EXPLOSIONES 2x2 que duran cada 5 segundos

        }
        else{
            ///PADRE
            shmdt(mapa);
            ///LIBERAMOS LA ZONA DE MEMORIA COMPARTIDA --> LOS OTROS PROCESOS NO LA PODRÁN USAR
            int status;
            wait(&status);
            shmdt(mapa);
            shmctl(shmID, IPC_RMID, NULL);
        }
    }

    ///PROCESO PADRE --> PINTA EL MAPA CUANDO HAY CAMBIOS

    shmdt(mapa);
    ///LIBERAMOS LA ZONA DE MEMORIA COMPARTIDA --> LOS OTROS PROCESOS NO LA PODRÁN USAR
    int status;
    wait(&status);
    shmdt(mapa);
    shmctl(shmID, IPC_RMID, NULL);

    return 0;
}

#define MAX 100000

void sumaFun(int *numero){
    for(int i = 0; i < MAX; i++){
        (*numero)++;
    }
    shmdt(numero);
}

int main(){
    pid_t pidHijo1, pidHijo2, pidHijo3;

    //Creamos espacio de memoria compartida.
    int shmID = shmget(IPC_PRIVATE, sizeof(int), IPC_CREAT|0666);
    if(shmID < 0){
        std::cout << "Error al crear el espacio de memoria compartida." << std::endl;
    }

    //Vinculamos la variable al espacio de memoria creado antes
    int* suma = (int*)shmat(shmID, NULL, 0);
    if(suma < 0){
        std::cout << "Error al vincular memoria compartida." << std::endl;
    }

    //Creamos los procesos
    pidHijo1 = fork();
    if(pidHijo1 == 0){
        ///PROCESO HIJO 1
        sumaFun(suma);
        exit(0);
    }
    else{
        pidHijo2 = fork();
        if(pidHijo2 == 0){
            ///PROCESO HIJO 2
            sumaFun(suma);
            exit(0);
        }
        else{
            pidHijo3 = fork();
            if(pidHijo3 == 0){
                ///PROCESO HIJO 3
                sumaFun(suma);
                exit(0);
            }
        }
    }




    int status;
    wait(&status);
    wait(&status);
    wait(&status);

    std::cout << "El resultado final es: " << (*suma) << std::endl;

    shmdt(suma);
    shmctl(shmID, IPC_RMID, NULL);
}

///Ejercicio anterior pero con semaforos
void SemWait(int _semID){
    sembuf opSem;
    opSem.sem_num = 0;
    opSem.sem_op = -1;
    opSem.sem_flg = SEM_UNDO;

    int okOP = semop(_semID, &opSem, 1);
    if(okOP < 0){
        std::cout << "Error en el waiter" << std::endl;
    }
}

void semSignal(int _semID){
    sembuf opSem;
    opSem.sem_num = 0;
    opSem.sem_op = 1;
    opSem.sem_flg = SEM_UNDO;

    int okOP = semop(_semID, &opSem, 1);
    if(okOP < 0){
        std::cout << "Error en el signal" << std::endl;
    }
}

void sumaFun(int *numero, int _semID){
    for(int i = 0; i < MAX; i++){
        //Queremos proteger el acceso de los procesos a zona de memoria, para que la suma se realice con éxito
        SemWait(_semID);
        (*numero)++;
        semSignal(_semID);
    }
    shmdt(numero);
}

int main(){
    pid_t pidHijo1, pidHijo2, pidHijo3;

    //Creamos espacio de memoria compartida.
    int shmID = shmget(IPC_PRIVATE, sizeof(int), IPC_CREAT|0666);
    if(shmID < 0){
        std::cout << "Error al crear el espacio de memoria compartida." << std::endl;
    }

    //Vinculamos la variable al espacio de memoria creado antes
    int* suma = (int*)shmat(shmID, NULL, 0);
    if(suma < 0){
        std::cout << "Error al vincular memoria compartida." << std::endl;
    }

    //Creamos espacio para la cantidad de semaforos que le pasamos
    int semID = semget(IPC_PRIVATE, 1, IPC_CREAT|0600);
    if(semID < 0){
        std::cout << "Error al reservar memoria para el semaforo" << std::endl;
    }

    int semInit = semctl(semID, 0, SETVAL, 1);
    if(semInit < 0){
        std::cout << "Error al inicializar el semaforo" << std::endl;
    }

    //Creamos los procesos
    pidHijo1 = fork();
    if(pidHijo1 == 0){
        ///PROCESO HIJO 1
        sumaFun(suma, semID);
        exit(0);
    }
    else{
        pidHijo2 = fork();
        if(pidHijo2 == 0){
            ///PROCESO HIJO 2
            sumaFun(suma, semID);
            exit(0);
        }
        else{
            pidHijo3 = fork();
            if(pidHijo3 == 0){
                ///PROCESO HIJO 3
                sumaFun(suma, semID);
                exit(0);
            }
        }
    }




    int status;
    wait(&status);
    wait(&status);
    wait(&status);

    std::cout << "El resultado final es: " << (*suma) << std::endl;

    shmdt(suma);
    semctl(semID, 0, IPC_RMID, NULL);
    shmctl(shmID, IPC_RMID, NULL);
}

///EJERCICIO 27

void SemWait(int _semID){
    sembuf opSem;
    opSem.sem_num = 0;
    opSem.sem_op = -1;
    opSem.sem_flg = SEM_UNDO;

    int okOp = semop(_semID, &opSem, 1);
    if(okOp < 0){
        std::cout << "Error en wait" << std::endl;
    }
}

void SemSignal(int _semID){
    sembuf opSem;
    opSem.sem_num = 0;
    opSem.sem_op = 1;
    opSem.sem_flg = SEM_UNDO;
    semop(_semID, &opSem, 1);
}

void suma(int* _numero, int _semID){
    const int MAX = 1000000;
    for(int i = 0; i < MAX; i++){
        ///ZONA CRITICA

        ///PROTEGER LA VARIABLE
        SemWait(_semID);
        (*_numero)++;
        ///DESPROTEGER LA ZONA -- signal
        SemSignal(_semID);
    }
    shmdt(_numero);
}

int main(){
    int pidProc1, pidProc2, pidProc3;

    int shmID = shmget(IPC_PRIVATE, sizeof(int), IPC_CREAT | 0666);
    if(shmID < 0){
        std::cout << "No se ha podido reservar memoria." << std::endl;
    }

    int* numero = (int*)shmat(shmID, NULL, 0);

    int semID = semget(IPC_PRIVATE, 1, IPC_CREAT | 0666);
    if(semID < 0){
        std::cout << "Error al reservar la memoria del semaforo." << std::endl;
        exit(0);
    }

    int semInit = semctl(semID, 0, SETVAL, 1);
    if(semInit < 0){
        std::cout << "Error al inicializar el semaforo." << std::endl;
        exit(0);
    }

    pidProc1 = fork();
    if(pidProc1 == 0){
        suma(numero, semID);
        exit(0);
    }
    else{
        pidProc2 =  fork();
        if(pidProc2 == 0){
            suma(numero, semID);
            exit(0);
        }
        else{
            pidProc3 = fork();
            if(pidProc3 == 0){
                suma(numero, semID);
                exit(0);
            }
        }
    }

    int status;
    wait(&status);
    wait(&status);
    wait(&status);

    std::cout << "El resultado de la suma es: " << (*numero) << std::endl;
    shmdt(numero);
    shmctl((shmID), IPC_RMID, NULL);
    semctl(semID, 0, IPC_RMID, NULL);
    return 0;
}