/* 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 <sys/wait.h>

#define PERM 0644

typedef int pipe_t[2];

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 dal 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);
	}
	
	/* Calcolo del numero di file */
	N = argc - 1;
	
	/* Allocazione dell'array di N pipe */
	piped = (pipe_t *) malloc (N*sizeof(pipe_t));
	if(piped == NULL)
	{
		printf("Errore nella allocazione della memoria per le pipe\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\n");
			exit(4);
		}
		
		if (pid == 0) /* codice del figlio */
		{
			if (i != 0) /* codice figli slave */
			{
				/* Chiusura lati pipe */
				for(j=0; j<N; j++)
				{
					close(piped[j][0]);
					if(j != i-1) /* la pipe di indice 0 viene usata dallo slave P1 che ha indice 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 e quindi decidiamo di tornare 0 */
				}
				/* stampa di debugging */
				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 */
					{ 
						if (buffer[0] == buffer[j-1])
						{
						/* se il primo e ultimo carattere (chiaramente escluso il terminatore) sono uguali ... */
						/* comunica la linea (con il terminatore) al master: si inviano sempre 120 caratteri! */
							write(piped[i-1][1], buffer, sizeof(buffer));
							cont++; /* si incrementa il contatore delle linee inviate al master */
						}
						j = 0; /* si deve riazzerare l'indice del buffer di linea */
					}
					else j++; /* si deve incrementare l'indice del buffer di linea */
				}	
				/* Il figlio slave 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 pipe */
				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++)
					{	
						/* si legge la linea inviata dal figlio j+1-esimo, andando a leggere sempre 120 caratteri */ 
						nr = read(piped[j][0], buffer, sizeof(buffer));
						if (nr != 0) 
						{ 
							finito = 0; /* almeno un processo non e' finito */
			  	  			k = 0;
				  			/* si deve andare a scrivere la linea ricevuta sul file creato: la scrittura deve pero' essere fatta fino a che non si trova il terminatore di linea */
			  	  			while (buffer[k] != '\n')
			  	  			{	
			  					write(fdw, &buffer[k], 1);
			  	  				k++;
			  	  			}		
				  			/* si deve andare a scrivere anche il terminatore di linea */
			  	  			write(fdw, &buffer[k], 1);
				  			cont++; /* si incrementa il contatore delle linee scritte sul file */
 						}	
					}	
			 	}
				/* Il figlio master ritorna il numero di linee scritte sul file */
				exit(cont);
			}	
		}
			
		else /* padre*/	
			if (i == 0) pid_master = pid; /* salviamo il pid del master */ 
	}
	
	/* Codice del padre */

	/* Chiusura lati pipe: N.B. Il padre NON usa le pipe!  */
	for (j=0; j<N; j++)
	{
		close(piped[j][0]);
		close(piped[j][1]);
	}
	
	/* aspetto ogni figlio generato e recupero il valore */
	for (i=0; i< N+1 ; i++)
	{
		pid=wait(&status);
		if (pid < 0)
		{
			printf("Errore in wait\n");
			exit(9);
		}
		if ((status & 0xFF) != 0)
			printf("Figlio con pid %d terminato in modo anomalo\n", pid);
    		else
 		{
			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);
		}
	}	
exit(0);
}