#include <stdio.h>                     // Archivos Necesarios con funciones y comandos para IPC
#include <sys/types.h>                 //
#include <sys/ipc.h>
#include <sys/time.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <ctype.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include "semaph.h"

#define SHMKEY ((key_t) 9876)
#define SEMKEY1 ((key_t) 7984)
#define SEMKEY2 ((key_t) 7988)       //Definición de ciertas constantes
#define PERMS 0666                   //Permisos para escritura y lectura
#define BSIZE 256
#define FIFOTX "betofifo"

int i, filed;
char datos[BSIZE];
struct timeval tini;                 //Variable tiempo de inicio de transmisiones
struct timeval tfin;                 //Variable tiempo final de transmisiones
struct timezone tz;                  //Variable obsoleta pero necesaria para gettimeofday
long tabla[4][4000];                 //tabla para guardar datos de índice y tiempo de transmisiones
typedef struct _buffer {
	char	data[BSIZE];		
	int	size;			
} BUFFER;
BUFFER		 *buf;
int	shmid;                       //identificador de Memoria
int emptybuf_sem, fullbuf_sem;       //Semáforos

datawr()
{
	for (i=0;i<256;i++)          //Estafunción escribe un paquete de 256 bytes de caracteres
	datos[i]=(char)(i);
	}

llenarcolumna(){                     //Esta función llena la primera columna de la tabla con
	for(i=0;i<4000;i++)          //múltiplos de 256 bytes para indicar eje X
	tabla[0][i]=(1+i)*256;
}        	
		
writermem()
{
	sem_wait(fullbuf_sem);		       //Función de lectura de memoria
	write((int)buf,datos,sizeof(datos));   //una vez que se encuentre llena
	sem_signal(emptybuf_sem);
		
}

readermem()
{
	sem_wait(emptybuf_sem);                //Función de escritura de memoria
	read((int)buf,datos,sizeof(datos));    //una vez que esté vacía
	sem_signal(fullbuf_sem);
}	
	

wrpipe(int pip)
{
	write(pip,datos,sizeof(datos));	       //Escritor de la pipa
}


rdpipe(int pip)
{
	read (pip,datos,sizeof(datos));        //lector de la pipa
}


main(int argc, char *argv[])                 /*Programa principal*/
{
	FILE *fd;                            //Descriptor para archivo
	int rango;                           //Rango ingresado en KB
	int cant;                            //Cantidad de paquetes
	int pipa[2];
	pid_t pid;
	int i;

	if (argc<2)
		{printf("\nUsar:edipc <rango en KB>\n"); //Se especifica uso de edipc
		exit(0);}
	
	if (argc>2)
		{printf("\nDemasidados Argumentos\nUsar:edipc <rango en KB>\n"); //Se especifica uso de edipc
		exit(0);}
	
	rango=atoi(*++argv);
	if (rango>1000){
		printf("Usar rango <=1000 KB\n");  //Se especifica uso de edipc
		exit(0);
		}
		
	datawr();          //Se crea los paquetes
	llenarcolumna();   //Se llena la tabla
	cant=rango*4;      //Se determina cantidad de paquetes (4*cantidad de KBytes
        fd=fopen("tabla.txt","w");  //Se crea archivo tabla.txt para escritura
        pipe(pipa);
                                                                 //     Transmisión de datos por pipa
        if((pid=fork())<0){                                      //
        	printf("Fallo de Fork\n");                       //
	        exit(0);}                                        //
                                                                 //      Se inicia el contador de tiempo
	gettimeofday(&tini,&tz);        	                 //
	if (pid==0) {close(pipa[1]);                             //
		for (i=0;i<cant;i++){                            //
			wrpipe(pipa[1]);}                        //      Proceso hijo escribe a la pipa
		        exit(0);}                                //
                                                                 //
	else close (pipa[0]);                                    //
		for (i=0;i<cant;i++){                            //
			rdpipe(pipa[0]);                         //     Proceso padre lee de la pipa
                        gettimeofday(&tfin,&tz);                 //     Indica tiempo de término
                        tabla[1][i]=tfin.tv_usec-tini.tv_usec;}  //     Se guardan datos en la tabla
                                                                 //
        waitpid(pid,0,NULL);                                     //

       	
        unlink(FIFOTX);                                          //      Transmisón de datos por FIFO
                                                                 //      Se inicializa la fifo
       	if (mkfifo(FIFOTX, PERMS) < 0) {                         //
        printf("Error al crear fifo\n");                         //
        exit(0);}                                                //
       	                                                         //
        if ((filed = open(FIFOTX, O_RDWR)) < 0) {                //      Se abre la FIFO para lectura y escritura
        printf("Error al abrir fifo\n");                         //
        exit(0);}                                                //
                                                                 //
        if((pid=fork())<0){                                      //
        	printf("Fallo de Fork\n");                       //
	        exit(0);}                                        //
                                                                 //
	gettimeofday(&tini,&tz);        	                 //      Se toma tiempo de inicio de transimsión
	if (pid==0) {                            		 //
		for (i=0;i<cant;i++){                            //
			write(filed,datos,sizeof(datos));}       //     Proceso hijo escribe en la FIFO
		        exit(0);}                                //
                                                                 //
	else 			                                 //
		for (i=0;i<cant;i++){                            //
			read(filed,datos,sizeof(datos));         //     Proceso padre lee de la FIFO
                        gettimeofday(&tfin,&tz);                 //     Se obtiene tiempo defin de transmisión
                        tabla[2][i]=tfin.tv_usec-tini.tv_usec;}  //     Se guardan los datos en la tabla
                                                                 //
        waitpid(pid,0,NULL);                                     //
       	close(filed);                                            //
       	unlink(FIFOTX);                                          //     Se cierra la FIFO

       	
       	(shmid = shmget(SHMKEY , sizeof(BUFFER),PERMS | IPC_CREAT));    //   Creación espacio Memoria Compartida
		 buf = (BUFFER *) shmat(shmid, (char *) 0, 0);          //
                                                                        //
	if ( (fullbuf_sem = sem_create(SEMKEY1, 0)) < 0)                //   Inicialización de los semáforos
		{printf("No se puede crear semáforo\n");                //
		exit(0);}					        //
	if ( (emptybuf_sem = sem_create(SEMKEY2, 1)) < 0)               //
		{printf("No se puede crear semáforo\n");        	//
		exit(0);}                                               //
		                                                        //
         if((pid=fork())<0){                                            //
        	printf("Fallo de Fork\n");                              //
	        exit(0);}                                               //
	  gettimeofday(&tini,&tz);                                      //  Tiempo de inicio de transmisiones
	                                                                //
	if (pid==0) {for(i=0;i<cant;i++)                                //
		writermem();                                            //  Se escribe en la memoria
		exit(0);}                                               //
                                                                        //
	else    for(i=0;i<cant;i++)                                     //
		{readermem();                                           //  Se lee de la memoria
		gettimeofday(&tfin,&tz);                                //  Obtención de tiempo de finalización
  		tabla[3][i]=tfin.tv_usec-tini.tv_usec;}                 //  Se guardan los datos en la tala
                                                                        //
        waitpid(pid,0,NULL);                                            //
	                                                                //  Se cierra espacio compartido
	if (shmdt(buf) < 0)                                             //
			perror("server: can't detach shared memory ");  //
	                                                                //
	sem_close(emptybuf_sem);                                        //  Se cierran los semáforrs
	sem_close(fullbuf_sem);                                         //
       	                                                                //

        for (i=0;i<cant;i++)
        	//Se imprimen todos los datos de la tabla en un archifo graph.txt
        	fprintf(fd,"\t%d\t%d\t%d\t%d\n",tabla[0][i],tabla[1][i],tabla[2][i],tabla[3][i]);
       	
	fclose(fd); //Se cierra el descriptor de archivos para datos de la tabla graph.txt
	       	
	system("gnuplot graph.txt"); //Se genera el gráfico
       	
        printf("Este programa ha finalizado\n");    //Fin Del Progama
        exit(0);
}