/* Soluzione parte C:
per la sincronizzazione dei figli occorre creare uno schema di pipe "circolare", ossia una pipe che colleghi ogni figlio a quello precedente e successivo. Si noti che l'ultimo processo figlio ha la pipe collegata al padre, e che il primo processo figlio parte in maniera indipendente. 
Si scriverà sempre sul lato i+1 e si leggerà da quello i:
figlio 0  == pipe 1 ==>   figlio 1  == pipe 2 ==> ... 
                                   figlio i == pipe i+1 ==>
ma l'ultimo figlio è collegato al padre tramite una pipe (i+1)%n = 0 */
/* SI PRECISA CHE RISPETTO AL TESTO FORNITO QUESTA SOLUZIONE INVECE CHE PASSARE AL PADRE IL VALORE MINIMO DELLE OCCORRENZE CONTATE, PASSA IL MASSIMO: NEL CODICE SI RIPORTERA' UN ULTERIORE COMMENTO IN CORRISPONDENZA DEL TEST CHE BASTA INVERTIRE PER AVERE IL COMPORTAMENTO RICHIESTO DAL TESTO FORNITO. */
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/wait.h>
#include <stdio.h>
#include <string.h>

/* definisco un tipo per un array di due interi */
typedef int pipe_t[2];		 


/* definizione di una struttura dati che racchiuda il numero di occorrenza del carattere e il PID del processo figlio corrente. Questa struttura verra' passata tramite le pipe da un figlio all'altro. */
typedef struct {
	int occorrenza;
	int PID;
		} s_occ;


/* Inizio del programma vero e proprio */
int main(int argc, char **argv) {
int n;		/* Numero di processi figli da creare */
int i;		/* Contatore per la generazione delle pipe/figli*/
int j;		/* Contatore per la chiusura dei lati non usati delle pipe */
pipe_t *p;	/* Puntatore ad un array di pipe */
char chpassato; /*carattere passato come parametro*/
char ch;   	/*carattere utilizzato nella read del file*/
int status; 	/*utilizzato come status di ritorno dei figli*/ 
int fd; 	/*file descriptor generico */
int pid;     	/* valore di ritorno della fork o pid del processo corrente */ 
s_occ cur_occ;	/* struttura che ogni figlio deve usare */
s_occ pipe_occ;	/* struttura che verrà passata lungo la pipe */
int ritorno;	/*variabile per valore di ritorno */

/* controllo sul numero dei parametri: devo avere almeno un file e un carattere quindi almeno tre argomenti (argv[0] compreso) */
if( argc < 3) 
{ 	printf("Uso: %s num variabile di file, almeno 2\n", argv[0]);
	exit(1);
}

/* il numero di figli da generare è pari al numero di file passati come argomento, quindi argc-2 */
n = argc-2;
if (strlen(argv[argc-1]) != 1)
{ 	printf("L'ultimo parametro non è un singolo carattere, ma è una stringa: %s\n", argv[argc-1]);
	exit(2);
}

/* il numero di figli da generare è pari al numero di file passati come argomento, quindi argc-2 */
/* il carattere passato come parametro si trova nell'ultima posizione della lista degli argomenti, ossia argc-1 */ 
chpassato=argv[argc-1][0];

/* allocazione delle pipe: occorre un numero di pipe pari al numero di figli (una viene usata per la comunicazione con il padre) */    
p = (pipe_t *)malloc(sizeof(pipe_t)*n);  
if( p == NULL ) {
printf("Impossibile allocare il vettore di pipe\n");
exit(3);
}

for(i=0; i<n; i++) {
	if(pipe(p[i]) != 0) {
		printf("Errore nella creazione della pipe %d\n", i);
		exit(4);
				}
}

/* creazione degli n figli. Dove la fork ritorna 0 significa che sono nel codice del figlio, altrimenti nel padre o in errore se ho -1 */
for(i=0; i<n; i++) {
	pid = fork();
	/* controllo del valore di ritorno della fork */
	if( pid == -1 ){
	printf("Errore nella fork %d-esima\n",i);
	exit(5);
	}
	else
	if( pid == 0 ){
	/* CODICE DEL FIGLIO */
	/* anzitutto chiudo i lati della pipe che non uso con questo figlio. Chiudo in scrittura tutte le pipe eccetto la i+1, chiudo in lettura tutte le pipe eccetto i. */
	for(j=0; j<n; j++) {
		if( j!=i && j!=((i+1)%n)){
			close(p[j][0]);		/* lato lettura */
			close(p[j][1]);		/* lato scrittura */
			}
		}
	close(p[i][1]);	
	/* non devo scrivere sulla pipe i-esima */
	close(p[(i+1)%n][0]);	
	/* non devo leggere dalla pipe i+1 */
	/* il figlio 0-esimo non legge dalla sua pipe */
	if( i == 0 ){ close(p[0][0]); } 
	/* inizializzo la mia struttura dati */
	cur_occ.PID = getpid();
	cur_occ.occorrenza = 0;
	/* apro il file i-esimo e leggo un carattere alla volta contando il numero di occorrenze */
	fd = open(argv[i+1], O_RDONLY);   
	if (fd < 0) {
	printf("Errore nell'apertura del file %s\n", argv[i+1]);
	exit(6);
	}
	while (read(fd,&ch,1)) { 
		if (chpassato==ch) 
			cur_occ.occorrenza++;
		}
	close(fd);

/* salvo il valore di ritorno */
	ritorno =  cur_occ.occorrenza;
/* ora posso comunicare al figlio seguente la mia informazione. ATTENZIONE: il figlio 0-esimo non deve leggere da nessuna pipe, ma gli altri figli devono prima confrontare la loro informazione con quella ricevuta sulla pipe. */
	if ( i != 0 ){
/* se non sono il primo processo, resto bloccato sulla read fino a quando non mi viene passato un qualche dato */
	read(p[i][0],&pipe_occ,sizeof(s_occ));
/* printf("ho ricevuto occ=%d e pid=%d\n", pipe_occ.occorrenza, pipe_occ.PID);
 */
	/* confronto i dati ricevuti */
/* SI PRECISA CHE RISPETTO AL TESTO FORNITO QUESTA SOLUZIONE INVECE CHE PASSARE
AL PADRE IL VALORE MINIMO DELLE OCCORRENZE CONTATE, PASSA IL MASSIMO:
 BASTA INVERTIRE IL TEST PER AVERE IL COMPORTAMENTO RICHIESTO DAL TESTO FORNITO. */

	if (pipe_occ.occorrenza >= cur_occ.occorrenza ){
	cur_occ.occorrenza = pipe_occ.occorrenza;
						}
		}
	/* invio i dati */
/* printf("sto per inviare occ=%d e pid=%d\n", cur_occ.occorrenza, cur_occ.PID);
*/
	write(p[(i+1)%n][1],&cur_occ,sizeof(s_occ));
	/* chiudo le pipe che ho usato */
	close(p[(i+1)%n][1]);
	close(p[i][0]);
	/* termino il processo ritornando il valore delle occorrenze (supposto minore di 255) */
	exit(ritorno);
}	/* FINE CODICE DEL FIGLIO */
}		/* fine del ciclo for */ 
/* CODICE DEL PADRE */
/* chiudo tutte le pipe non usate */  
for (j=0;j<n;j++)  {
if( j != 0 ){	
/* non devo chiudere la pipe lettura dell'ultimo figlio */          
close (p[j][0]);
} 
close (p[j][1]);
} 
/* leggo i valori passati dall.ultimo figlio */
read(p[0][0],&cur_occ,sizeof(s_occ));
printf("\nNumero di occorrenze: %d figlio pid=%d\n",cur_occ.occorrenza,cur_occ.PID);    
/* Attesa della terminazione dei figli */
for(i=0;i<n;i++) {
	pid = wait(&status);
	if(WIFEXITED(status)) /* se il figlio e` uscito normalmente... */
	printf("Figlio pid: %d terminato con exit: %d\n", pid, WEXITSTATUS(status));
	else
	printf("Figlio con pid: %d terminato in modo anomalo\n", pid);
}
}	/* fine del main */