#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h>

int main() {
    // Un pipe necesita un arreglo de 2 enteros para los descriptores de archivo:
    // tuberia[0] será usado para LEER (Receive)
    // tuberia[1] será usado para ESCRIBIR (Send)
    int tuberia[2]; 
    
    char mensaje_enviado[] = "¡Hola Hijo! Este es un mensaje secreto desde el Proceso Padre.";
    char mensaje_recibido[100]; // Búfer para guardar lo que llegue

    printf("==========================================\n");
    printf(" Iniciando simulador de Paso de Mensajes \n");
    printf("==========================================\n\n");

    // 1. Creamos el canal de comunicación (La tubería)
    if (pipe(tuberia) == -1) {
        perror("Error al crear la tubería");
        return 1;
    }

    // 2. Creamos un nuevo proceso usando fork()
    pid_t pid = fork();

    if (pid < 0) {
        perror("Error al crear el proceso hijo");
        return 1;
    } 
    
    if (pid > 0) {
        // ==========================================
        // CÓDIGO DEL PROCESO PADRE (El Emisor)
        // ==========================================
        
        // El Padre solo va a escribir, así que cerramos el extremo de lectura
        close(tuberia[0]); 

        printf("[PADRE] Preparando el mensaje...\n");
        sleep(1); // Simulamos un pequeño retardo
        
        printf("[PADRE] Enviando mensaje por la tubería (SEND).\n");
        
        // Operación SEND: Escribimos en tuberia[1]
        // Enviamos la cadena + 1 para incluir el carácter nulo de terminación '\0'
        write(tuberia[1], mensaje_enviado, strlen(mensaje_enviado) + 1); 
        
        // Cerramos el canal de escritura para indicar que ya no enviaremos más datos
        close(tuberia[1]); 
        
        // El Padre espera a que el Hijo termine su ejecución
        wait(NULL); 
    } 
    else {
        // ==========================================
        // CÓDIGO DEL PROCESO HIJO (El Receptor)
        // ==========================================
        
        // El Hijo solo va a leer, así que cerramos el extremo de escritura
        close(tuberia[1]); 
        
        printf("   [HIJO] Esperando recibir un mensaje (RECEIVE)...\n");
        
        // Operación RECEIVE: Leemos de tuberia[0]
        // Esta función bloquea (congela) al proceso Hijo hasta que lleguen datos por el tubo
        read(tuberia[0], mensaje_recibido, sizeof(mensaje_recibido)); 
        
        printf("   [HIJO] ¡Mensaje recibido exitosamente!\n");
        printf("   [HIJO] Contenido: \"%s\"\n\n", mensaje_recibido);
        
        // Cerramos el canal de lectura
        close(tuberia[0]); 
    }

    return 0;
}