/* Soluzione della parte C del compito del 16 Luglio 2014 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h> 
#include <sys/stat.h>
#include <string.h>
#include <fcntl.h>

typedef int pipe_t[2];

int main (int argc, char **argv)
{
int N; 		/* numero di file */
int X; 		/* numero di linee */
int pid;	/* pid per fork */
pipe_t *pipes;	/* array di pipe usate a pipeline da primo figlio, a secondo figlio .... ultimo figlio e poi a padre: ogni processo legge dalla pipe i-1 e scrive sulla pipe i */
int i,j; 	/* contatori */
int fd; 	/* file descriptor */
int pidFiglio, status, ritorno;	/* per valore di ritorno figli */
char *primiCar; 	/* array dinamico di caratteri che i figli si passeranno in pipeline e che arriverą al padre */
char ch, chprimo;  	/* carattere letto da linea e carattere da inserire nell'array */
int nr,nw;		/* variabili per salvare valori di ritorno di read e write da/su pipe */
/* int linee = 1;	   serve per mantenere il numero corrente della linea e e' stata usata solo nelle stampe di controllo */

if (argc < 3)
{
	printf("Errore numero di parametri\n");
	exit(1);
}

X = atoi(argv[argc-1]);
printf("Numero di linee %d\n", X);
/* controllo non richiesto, ma inserito per sicurezza */
if (X < 0)
{
	printf("Errore numero linee: non maggiore di zero\n");
	exit(2); 
}

N = argc-2;
printf("Numero di processi da creare %d\n", N);

/* allocazione primiCar: la fa il padre e tutti i figli lo otterranno per copia */
if ((primiCar=(char *)malloc(N*sizeof(char))) == NULL)
{
	printf("Errore allocazione primiCar\n");
	exit(3); 
}

/* allocazione pipe */
if ((pipes=(pipe_t *)malloc(N*sizeof(pipe_t))) == NULL)
{
	printf("Errore allocazione pipe\n");
	exit(4); 
}

/* creazione pipe */
for (i=0;i<N;i++)
	if(pipe(pipes[i])<0)
	{
		printf("Errore creazione pipe\n");
		exit(5);
	}

/* creazione figli */
for (i=0;i<N;i++)
{
	if ((pid=fork())<0)
	{
		printf("Errore creazione figli\n");
		exit(6);
	}
	else if (pid==0)
	{ /* codice figlio */
	printf("Sono il figlio %d\n", getpid());
	/* chiusura pipes inutilizzate */
	for (j=0;j<N;j++)
	{
		if (j!=i)
			close (pipes[j][1]);
		if ((i == 0) || (j != i-1))
			close (pipes[j][0]);
	}
 
	/* apertura file */
	if ((fd=open(argv[i+1],O_RDONLY))<0)
	{
		printf("Impossibile aprire il file %s\n", argv[i+1]);
		exit(-1);
	}
	j = 0;
	while(read(fd,&ch,1)>0)
	{
		if (j == 0) /* se e' il primo carattere della linea allora lo salviamo in chprimo */
  			{
			chprimo = ch;
			/* stampa di controllo 
     			printf("processo di indice %d ha salvato il carattere %c per la linea %d\n",i, chprimo, linee);
			*/
		  }
	
		/* controllo fine linea */
		if (ch == '\n')  /* siamo a fine linea */
     		{
			/* linee++; introdotto solo per stampe di controllo */
			if (i!=0) /* il primo figlio NON deve leggere dal figlio precedente l'array */
		      	{ 
				nr=read(pipes[i-1][0],primiCar, N);
				if (nr!=N) 
						 { 
							printf("Errore in lettura da pipe[%d]\n",i);
							exit(-1);
						 }
			}
/* in ogni modo, quindi sia per il primo figlio che per gli altri, deve essere inserito il carattere al posto giusto */
			primiCar[i] = chprimo;
			/* comunicazione primiCar al figlio seguente  */
			nw=write(pipes[i][1], primiCar, N);
			if (nw!=N) 
			{ 
				printf("Errore in scrittura da pipe[%d]\n",i);
				exit(-1);
		 	}
			j = 0; /* riazzeriamo il conteggio dei caratteri della linea */
  		}
		else
		 	{
				j++; /* incrementiamo il conteggio dei caratteri della linea */
			}	

	}	
	exit(chprimo);
	}
} /* fine for */

/* codice del padre */
/* chiusura pipe: tutte meno l'ultima in lettura */
for(i=0;i<N;i++)
{
	close (pipes[i][1]);
	if (i != N-1) close (pipes[i][0]);
}

/* il padre deve leggere X strutture, tante quante sono le linee lette dai figli */
for(j=0;j<X;j++)
{
	read(pipes[N-1][0], primiCar, N);
	printf("Ricevuto per la linea %d i seguenti primi caratteri:\n", j+1); /* incrementiamo j in modo da rendere piu' chiaro a che linea ci stiamo riferendo */
	for(i=0;i<N;i++)
        	printf("Carattere %c ricevuto dal processo di indice %d per il file %s\n", primiCar[i], i, argv[i+1]);
} 

/* Il padre aspetta i figli */
for (i=0; i < N; i++)
{
        pidFiglio = wait(&status);
        if (pidFiglio < 0)
        {
                printf("Errore in wait\n");
                exit(7);
        }

        if ((status & 0xFF) != 0)
                printf("Figlio con pid %d terminato in modo anomalo\n", pidFiglio);
        else
        { 	ritorno=(int)((status >> 8) & 0xFF);
                printf("Il figlio con pid=%d ha ritornato %c\n", pidFiglio, ritorno);
        } 
}
exit(0);
}