/**
 *@brief Ejercicio 8 de la Practica 2
 *@file Ejercicio8.c
 *@author Antonio Talavera Herranz
 *@author Jaime Velazquez Pazos
 *@grupo 2211
 *@version 1.0
 *@date 20-03-2019
 **/
#include <stdio.h>
#include <stdlib.h>
#include <semaphore.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <unistd.h>
#define N_HIJOS 4
#define SEML "/sem_lectura"
#define SEME "/sem_escritura"
#define SEMC "/sem_cont"
#define SECS 1


void Lectura(pid_t pid, sem_t *sem_lectura, sem_t *sem_escritura, sem_t *cont) {
    int sval;
    sem_wait(sem_lectura);/*Protegemos esta zona Bajando el semaforo de lectura(inicialmente a 1), para que solo pueda acceder un proceso */
    sem_post(cont);
    sem_getvalue(cont, &sval);
/*Incrementamos el semaforo que nos hace de contador*/
    if (sval == 1)/*Si el semaforo contador es 1(el primer proceso que llega), entra en la condicion y bloquea la zona de escritura*/
        sem_wait(sem_escritura);
    sem_post(sem_lectura);/*Salimos de la zona protegida, subiendo el semaforo de lectura*/

    Leer(pid);

    sem_wait(sem_lectura);/*Volvemos a proteger otra zona de codigo bajando el semaforo de lectura*/
    sem_wait(cont);/*El proceso ya ha leido y por tanto sale y resta uno al contador de procesos*/
    sem_getvalue(cont, &sval);
    if (sval == 0)/*Si ya no quedan procesos leyendo (el valor del contador es de 0),se habilita la zona de escritura subiendo su semaforo*/
        sem_post(sem_escritura);
    sem_post(sem_lectura);
}

void Leer(pid_t pid) {
    printf("R-INI %d \n", pid);/*Se simula el proceso de lectura*/
    sleep(1);
    printf("R-FIN %d \n ", pid);
}

void Escritura(pid_t pid, sem_t *sem_escritura) {

    sem_wait(sem_escritura);/*Se protege esta zona de codigo para que solo un proceso pueda leer a la vez, bajando el semaforo de escritura*/
    Escribir(pid);

    sem_post(sem_escritura);

}

void Escribir(pid_t pid) {
    printf("W-INI %d \n", pid);/*Se simula el proceso de escritura*/
    sleep(1);
    printf("W-FIN %d \n", pid);
}

void manejador_SIGINT(int sig) {
    int i;

    kill(0, SIGTERM);
    for (i = 0; i < N_HIJOS; i++)
        wait(NULL);
    exit(EXIT_SUCCESS);


}

void manejador_SIGTERM(int sig) {
    printf("Proceso %d terminando...\n", getpid());
    exit(EXIT_SUCCESS);

}

int main(void) {
    sem_t *sem_lectura, *sem_escritura, *cont = NULL;
    pid_t pid;
    int i;
    struct sigaction act;
    act.sa_handler = manejador_SIGINT;
    if (sigaction(SIGINT, &act, NULL) < 0) {
        perror("ERROR en el PADRE");
        exit(EXIT_FAILURE);
    }
    act.sa_flags = 0;

    if ((sem_lectura = sem_open(SEML, O_CREAT | O_EXCL, S_IRUSR | S_IWUSR, 1)) == SEM_FAILED) {/*Se inicializa el semanforo de lectura a 1*/
        perror("sem_open");
        exit(EXIT_FAILURE);
    }

    if ((sem_escritura = sem_open(SEME, O_CREAT | O_EXCL, S_IRUSR | S_IWUSR, 1)) == SEM_FAILED) {/*Se inicializa el semaforo de escritura a 1*/
        perror("sem_open");
        exit(EXIT_FAILURE);
    }

    if ((cont = sem_open(SEMC, O_CREAT | O_EXCL, S_IRUSR | S_IWUSR, 0)) == SEM_FAILED) {/*Se inicializa el semaforo del contador a 0*/
        perror("sem_open");
        exit(EXIT_FAILURE);
    }

    for (i = 0; i < N_HIJOS; i++) {/*bucle que crea N_HIJOS hijos*/
        pid = fork();

        if (pid == 0) {
            act.sa_handler = manejador_SIGTERM;

            if (sigaction(SIGTERM, &act, NULL) < 0) {/*Se prepara la señal SIGTERM que se enviara al hijo*/
                perror("ERROR en el HIjo");
                exit(EXIT_FAILURE);

            }
            while (1) {/*Mientras la señal SIGTERM no llegue, se repite este bucle infinitas veces*/
                Lectura(getpid(), sem_lectura, sem_escritura, cont);
                sleep(SECS);
            }
        }
    }
    if (pid > 0) {
        while (1) {/*El proceso padre llamara a la funcion de escritura infinitas veces*/
            Escritura(getppid(), sem_escritura);
            sleep(SECS);

        }
        sem_close(sem_lectura);/*Se cierra el semaforo de lectura*/
        sem_unlink(SEML);

        sem_close(sem_escritura);/*Se cierra el semaforo de escritura*/
        sem_unlink(SEME);

        sem_close(cont);/*Se cierra el semaforo contador*/
        sem_unlink(SEMC);
    }


    return 0;
}