/* Soluzione della parte C del compito dell'8 Giugno 2011 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h> 
#include <sys/stat.h>
#include <string.h>
#include <fcntl.h>
#include <ctype.h>

typedef int pipe_t[2];
typedef struct{
        char Cx; 	/* carattere C1 o C2 del testo */
	long int pos; 	/* posizione corrente del carattere nel file */
		} s_pos;

int main (int argc, char **argv)
{
int N; 			/* numero di file */
int pid;		/* per fork */
pipe_t *pipes;		/* array di pipe usate a per la comunicazione fra nipoti e padre */
pipe_t p;		/* pipe usata fra figlio e nipote */
int i,j; 		/* contatori */
int fd; 		/* file descriptor */
int status, ritorno;	/* per valore di ritorno figli */
char C1,C2, ch;  	/* caratteri da cercare e carattere letto da linea */
s_pos curF, curN; 	/* strutture usate dal figlio e dal nipote */
int occ;		/* numero di occorrenze usato sia da figli che da nipoti */
int nr;			/* variabile per salvare valore di ritorno di read su pipe */

/* controllo sul numero di parametri almeno 2 file (anche se non richiesto) e due caratteri */
if (argc < 5)
{
	printf("Errore numero di parametri\n");
	exit(1);
}

/* controlliamo che il penultimo parametro e l'ultimo parametro siano singoli caratteri */
if (strlen(argv[argc-2]) != 1 || strlen(argv[argc-1]) != 1)
{
	printf("Errore penultimo o ultimo parametro non singolo carattere\n");
	exit(2);
}
 
/* individuiamo i caratteri da cercare */
C1 = argv[argc-2][0];
C2 = argv[argc-1][0];
/* stampa di debugging */
printf("Caratteri da cercare %c e %c\n", C1, C2);

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

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

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

/* creazione figli */
for (i=0;i<N;i++)
{
	if ((pid=fork())<0)
	{
		printf("Errore creazione figli\n");
		exit(5);
	}
	if (pid==0)
	{ 	/* codice figlio */
		printf("Sono il processo figlio di indice %d e pid %d sto per creare il nipote che leggera' sempre dal mio stesso file %s\n", i, getpid(), argv[i+1]);
		/* nel caso di errore in un figlio o in un nipote decidiamo di ritornare un valore -1 */
		/* Chiusura delle pipe non usate nella comunicazione con il padre  */
		for (j=0; j < N; j++)
		{
			close(pipes[j][0]);
			if (i != j) close(pipes[j][1]);
		}

		/* creiamo la pipe di comunicazione con il nipote */
		if(pipe(p)<0)
		{
			printf("FIGLIO-Errore creazione pipe\n");
			exit(-1); /* decidiamo, in caso di errore, di tornare -1 che verra' interpretato come 255 e quindi un valore NON accettabile */
		}

		if ( (pid = fork()) < 0)
		{
			printf("Errore nella fork di creazione del nipote\n");
			exit(-1); /* decidiamo, in caso di errore, di tornare -1 che verra' interpretato come 255 e quindi un valore NON accettabile */
		}	
		if (pid == 0) 
		{
			/* codice del nipote */
			printf("Sono il processo nipote del figlio di indice %d e pid %d\n", i, getpid());
			/* Chiusura delle pipe rimasta aperta del figlio per la comunicazione con il padre  */
			close(pipes[j][1]);
			/* chiusura pipe non usata nella comunicazione con il figlio */
			close(p[0]);

			/* sia il figlio che il nipote devono aprire (con due open separate per avere l'I/O pointer separato) lo stesso file in lettura, dato che dovranno cercare un carattere */
			if ((fd=open(argv[i+1], O_RDONLY)) < 0)
			{
                               	printf("NIPOTE-Errore nella open del file %s\n", argv[i+1]);
				exit(-1); /* decidiamo, in caso di errore, di tornare -1 che verra' interpretato come 255 e quindi un valore NON accettabile */
                        }
			/* inizializzazione contatore di occorrenze */
			occ=0;
			/* inizializzazione campo carattere della struttura */
			curN.Cx = C2;
		        while (read(fd, &ch, 1))
			{	
			/* controlliamo se abbiamo trovato il carattere C2 */
				if (ch == C2)  
				{ 	
					/* per ricavare la posizione del carattere si puo' usare la funzione lseek */	
					curN.pos=lseek(fd, 0L, SEEK_CUR) - 1; /* decrementiamo perche' consideriamo le posizioni da 0 */
					/* si deve mandare l'informazione al figlio */
					write(p[1], &curN, sizeof(curN));
					/* incrementiamo numero di occorrenze che andra' ritornato al figlio */
					occ++;
				}
				else
					; /* non si deve fare nulla */
			}
				exit(occ); /* torniamo il valore richiesto dal testo che ci indica che sara' minore di 255 */
			}
			else 
			{ 
				/* codice figlio */
			  	/* chiusura pipe non usata nella comunicazione con il nipote */
			  	close(p[1]);

				/* il figlio ha un codice molto simile al nipote, con la differenza che si deve leggere via via le strutture inviate dal nipote */

				/* sia il figlio che il nipote devono aprire (con due open separate per avere l'I/O pointer separato) lo stesso file in lettura, dato che dovranno cercare un carattere */
				if ((fd=open(argv[i+1], O_RDWR)) < 0)
				{
                                	printf("FIGLIO-Errore nella open del file %s\n", argv[i+1]);
					exit(-1); /* decidiamo, in caso di errore, di tornare -1 che verra' interpretato come 255 e quindi un valore NON accettabile */
                        	}
			
				/* inizializzazione contatore di occorrenze */
				occ=0;
		        	while (read(fd, &ch, 1))
				{	
					/* inizializzazione campo carattere della strutturai: nota bene dentro al ciclo perche' questo campo puo' cambiare */
					curF.Cx = C1;
					/* controlliamo se abbiamo trovato il carattere  */
					if (ch == C1)  
					{ 	
						/* per ricavare la posizione del carattere si puo' usare la funzione lseek */	
						curF.pos=lseek(fd, 0L, SEEK_CUR) - 1; /* decrementiamo perche' consideriamo le posizioni da 0 */
						/* si deve a questo punto leggere la struttura inviata dal nipote */
						nr=read(p[0], &curN, sizeof(curN));
						if (nr != 0)
					 	{
							/* se siamo riusciti a leggere, allora verifichiamo i dati */
							if (curF.pos >= curN.pos)
							{
								/* se la posizione e' maggiore o uguale, al padre dobbiamo mandare le informazioni del nipote */
								curF.Cx = curN.Cx;
								curF.pos = curN.pos;
							 }
						/* si deve mandare l'informazione al padre */
						write(pipes[i][1], &curF, sizeof(curF));
						/* incrementiamo numero di occorrenze che andra' ritornato al padre */
						occ++;
						}
						else
							break; /* decidiamo di uscire dal ciclo while */
					}
					else
						; /* non si deve fare nulla */
				}
				/* il figlio deve aspettare il nipote e stampare il suo pid con il valore ritornato (come richiesto dal testo) */
				pid = wait(&status);
				if (pid < 0)
				{	
					printf("Errore in wait\n");
					exit(-1);
				}
				if ((status & 0xFF) != 0)
				{	
    					printf("Nipote con pid %d terminato in modo anomalo\n", pid);
					exit(-1);
				}
    				else
					printf("Il nipote con pid=%d ha ritornato %d\n", pid, ritorno=(int)((status >> 8) & 0xFF));

				exit(occ); /* torniamo il valore richiesto dal testo che ci indica che sara' minore di 255 */
			}
		}
	}
	
/* Codice del padre */
/* Il padre chiude i lati delle pipe che non usa */
	for (i=0; i < N; i++)
	{
		close(pipes[i][1]);
 	}

/* Il padre recupera le informazioni dai figli in ordine di indice */

	for (i=0; i < N; i++)
	{
		/* si devono recuperare tutte le infomazione inviate da ogni figlio */
		while (read(pipes[i][0], &curF, sizeof(curF)))
		{
			if (curF.Cx == C1)
				printf("Il figlio di indice %d ha trovato il carattere %c nella posizione %ld nel file %s\n", i, curF.Cx, curF.pos, argv[i+1]);
			else
				printf("Il nipote del figlio di indice %d ha trovato il carattere %c nella posizione %ld nel file %s\n", i, curF.Cx, curF.pos, argv[i+1]);

		}	
	}	

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

		if ((status & 0xFF) != 0)
    		printf("Figlio con pid %d terminato in modo anomalo\n", pid);
    		else
		{ ritorno=(int)((status >> 8) &	0xFF); 
		  if (ritorno==255)
 			printf("Il figlio con pid=%d ha ritornato %d e quindi vuole dire che ci sono stati dei problemi\n", pid, ritorno);
		  else  printf("Il figlio con pid=%d ha ritornato %d\n", pid, ritorno);
		}
	}
	exit(0);
}