/* Soluzione della Prova d'esame del 4 Giugno 2010 - Parte C */
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>

#define PERM 0644

typedef int pipe_t[2];

/* -------- Variabili globali ---------- */

int main(int argc, char **argv) {
	
	/* -------- Variabili locali ---------- */
	int N; 		/* numero di file passati sulla riga di comando */
	int pid_master;	/* variabile per process identifier per il master */
	int pid;	/* variabile per process identifier per le fork */
	int fdr;	/* file descriptor per ciascun file */
	int fdw;	/* file descriptor per file creato da MASTER */
	int nr;		/* numero di caratteri letti dalla pipe dal MASTER */
	int status;	/* variabile di stato per la wait */
	pipe_t *piped;	/* array dinamico di pipe descriptors */
	int i, j, k;	/* indici per i cicli */
	char buffer[120]; 	/* buffer per leggere i caratteri */
	int cont;	/* variabile per conteggio linee */
	int finito;	/* variabile che serve al MASTER per sapere se non ci sono piu' linee da leggere */
	/* ------------------------------------ */
	
	/* Controllo sul numero di parametri */
	if(argc < 2)
	{
		printf("Errore nel numero dei parametri: almeno 1!\n");
		exit(1);
	}
	
	/* Salvo in maniera opportuna i dati dalla riga di comando */
	N = argc - 1;
	
	/* Allocazione dell'array di N pipe descriptors*/
	piped = (pipe_t *) malloc (N*sizeof(pipe_t));
	if(piped == NULL)
	{
		printf("Errore nella allocazione della memoria\n");
		exit(2);
	}
	
	/* Creazione delle N pipe slave-master */
	for(i=0; i<N; i++)
	{
		if(pipe(piped[i])<0)
		{
			printf("Errore nella creazione delle pipe\n");
			exit(3);
		}
	}
	
	/* Ciclo di generazione dei figli: ne dobbiamo creare N + 1 (c'e' anche il master) */
	for(i=0; i<N+1; i++)
	{
		if( (pid = fork()) < 0)
		{
			printf("Errore nella fork");
			exit(4);
		}
		
		if(pid == 0) /* codice del figlio */
		{
			if (i != 0) /* codice figli slave */
			{
			/* Chiusura lati pipes */
			for(j=0; j<N; j++)
			{
				close(piped[j][0]);
				if(j != i-1)
					close(piped[j][1]);
			}
			
			/* Apertura del file associato: attenzione l'indice e' i dato che il primo slave inizia con i = 1 */
			if((fdr=open(argv[i], O_RDONLY))<0)
			{
				printf("Errore nella apertura del file %s\n", argv[i]);
				exit(0); /* nessun numero di linee in questo caso. */
			}
			
			printf("Figlio %d: analizzo il file %s\n", getpid(), argv[i]);
		
			j = 0;
			cont = 0;
			while(read(fdr, &(buffer[j]), 1)>0)
			{
				if(buffer[j] == '\n') /* trovato fine linea */
					{ 
					 write(1, &buffer[0], 1);
					 write(1, &buffer[j-1], 1);
					 write(1, "\n", 1);

					if (buffer[0] == buffer[j-1])
					{
					/* se il primo e ultimo carattere sono uguali ... */
					/* comunica la linea (con il terminatore) al MASTER: si inviano sempre 120 caratteri! */
					write(piped[i-1][1], buffer, sizeof(buffer));
					write(1, buffer, j+1);
					cont++;
					}
					j = 0;
					}
				else j++;
			}
			
			/* Il figlio ritorna il numero di linee comunicate al MASTER */
			exit(cont);
			}
			else 
			{
			/* codice figlio MASTER */
			if ((fdw = creat("UGUALE", PERM)) < 0)
			{
				printf("Errore nella creazione del file UGUALE\n");
				exit(0); /* nessun numero di linee in questo caso. */
			}

			/* Chiusura lati pipes */
			for(j=0; j<N; j++)
			{
				close(piped[j][1]);
			}
			finito = 0; /* all'inizio supponiamo che non sia finito nessuno slave */
			cont = 0;
			while (!finito)
			{
				finito = 1; 
	 			for(j=0; j<N; j++)
				{	
				nr = read(piped[j][0], buffer, sizeof(buffer));
		printf("Valore di nr %d\n", nr);
				if (nr != 0) 
				{ finito = 0;
			  	  k = 0;
			  	  while (buffer[k] != '\n')
			  	  {	
			  		write(fdw, &buffer[k], 1);
			  		write(1, &buffer[k], 1);
			  	  	k++;
			  	  }	
			  	  write(fdw, &buffer[k], 1);
			  	  write(1, &buffer[k], 1);
				  cont++;
 				}
				}
			 }
			exit(cont);
			 }
	}
			
else /* padre*/	
if (i == 0) pid_master = pid; /* salviamo il pid del master se serve */ 
	}
	
/* Codice del padre */

/* Chiusura lati pipes */
for(j=0; j<N; j++)
{
	close(piped[j][0]);
	close(piped[j][1]);
}
	
/* aspetto ogni figlio e raccolgo il valore */
for(i=0; i< N+1 ; i++)
	{
		pid=wait(&status);
		cont = (status >> 8) & 0xFF;
		if (pid == pid_master) 
		printf("Il figlio MASTER con pid %d ha ritornato %d numero di linee\n", pid, cont);
		else printf("Il figlio slave con pid %d ha ritornato %d numero di linee\n", pid, cont);
	}
}