#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <stdarg.h>
#include <string.h>
typedef int pipe_t[2]; 	/* tipo per la pipe */
/* variabili globali dato che questa soluzione usa una funzione figlio a cui serve la visibilita' di queste variabili */
pipe_t *pipesU; 	/* pipes di Psopra */
pipe_t *pipesD;		/* pipes di Psotto */
int     pid;		/* appoggio per valore pid (pid unico)*/
int     status; 	/* appoggio per wait */
int 	fd; 		/* per la gestione dei file creati  */
int 	nrp;		/* per la gestione dei del valore di ritorno della read da pipe */
char 	*Fsopra;	/* stringa per il nome del file Fsopra */
char 	*Fsotto;	/* stringa per il nome del file Fsotto */
int 	Nfigli,Npipe;	/* numero di figli e numero di pipe da creare */
int 	H,N;		/* variabili per salvare i parametri una volta convertiti da stringhe a numeri interi */
/* abbinamento snprintf+write */
void zprintf(int fd, const char *fmt, ...);
int figlio(char *filename,int indice);
int main(int argc, char **argv) {
        int i;                /* int di appoggio */
        int pid_sopra, pid_sotto; 	/* per salvare i pid dei due processi speciali */
        /* controllo numero di argomenti */
        if (argc!=4) {
                zprintf(2,"Errore nel numero di argomenti\n");
                return 1;
        }
        /*CONTROLLO PARAMETRI*/
        N=atoi(argv[2]);
        /*N=numero linee del file*/
        if(N <= 0)
        {
                zprintf(2,"Errore il secondo parametro non strettamente positivo\n");
                return 2;
        }
        H=atoi(argv[3]);
        if(H < 0)
        {
                zprintf(2,"Errore il terzo parametro non positivo\n");
                return 3;
        }
	/* allocazione di due stringhe */
        Fsotto=malloc(strlen(argv[1])+1+strlen(".sotto"));
        Fsopra=malloc(strlen(argv[1])+1+strlen(".sopra"));
        if(Fsotto==NULL||Fsopra==NULL)
        {
                zprintf(2,"errore nella malloc delle stringhe\n");
                return 4;
        }
        /*creazione di Fsotto ed Fsopra*/
        sprintf(Fsopra,"%s.sopra",argv[1]);
        fd=creat(Fsopra,0644);
        if(fd < 0)
        {
                zprintf(2,"Errore creazione file Fsopra %d\n", Fsopra);
                return 5;
        }
        close(fd); /* chiudiamo il file appena creato dato che il padre non lo usa */
	sprintf(Fsotto,"%s.sotto",argv[1]);
        fd=creat(Fsotto,0644);
        if(fd < 0)
        {
                zprintf(2,"Errore creazione file Fsopra %d\n", Fsopra);
                return 6;
        }
        close(fd); /* chiudiamo il file appena creato dato che il padre non lo usa */

        Npipe=N;
	/* allocazione dei due array di pipe */
        pipesU=malloc(sizeof(pipe_t)*Npipe);
        pipesD=malloc(sizeof(pipe_t)*Npipe);
        if(pipesU==NULL||pipesD==NULL)
        {
                zprintf(2,"errore nella malloc del vettore di pipe\n");
                return 7;
        }
	/* creazione dei due array di pipe */
        for(i=0;i<Npipe;i++)
        {
                if (pipe(pipesU[i])!=0) {
                        zprintf(2,"Impossibile creare la pipe %d di Fsopra\n",i);
                        return 8;
                }
                if (pipe(pipesD[i])!=0) {
                        zprintf(2,"Impossibile creare la pipe %d di Fsotto\n",i);
                        return 9;
                }
        }
        /* creazione figli e attribuzione argomenti */
        Nfigli=N+2;
        for(i=0; i<Nfigli; i++) {
                pid = fork();
                switch (pid) {
                        case 0: /* figlio */
                                if(i<(Nfigli-2))
                                        return(figlio(argv[1],i));
                                else
                                {
                                        if(i==Nfigli-2)
                                                return(figlio(Fsotto,i));
                                        else
                                                return(figlio(Fsopra,i));
                                }
                        case -1:
                                /* errore */
                                zprintf(2,"Errore nella %d fork\n",i);
                                return 10;
                }
/* padre salva i pid dei processi speciali Psotto e Psopra */
      if(i==Nfigli-2) pid_sotto=pid;
      if(i==Nfigli-1) pid_sopra=pid;
        }
/* PADRE */
/*chiusura pipesU e pipesD dato che il padre non le usa */
        for(i=0;i<Npipe;i++)
        {
                close(pipesU[i][0]);
                close(pipesD[i][0]);
                close(pipesU[i][1]);
                close(pipesD[i][1]);
        }
/* Recupero delle informazioni dai processi figli tramite la wait */
        for (i=0; i<Nfigli; i++) {
                pid = wait(&status);
		if (pid < 0)
		 zprintf(2,"Errore in wait\n");
		else
                                if (WEXITSTATUS(status)==255) {
                                        /* convenzione: segnalazione d'errore */
                                        zprintf(1,"Il figlio con pid %d  ha incontrato un errore\n",pid);
                                } else {
				/* necessaria una stampa differeziata per i figli generici e per i figli Psotto e Psopra */
                                        if((pid == pid_sopra) || (pid == pid_sotto))
                                          	zprintf(1,"Il figlio con pid %d ha scritto %d linee\n",pid,WEXITSTATUS(status));
                                        else
			zprintf(1,"Il figlio con pid %d ha contato %d caratteri\n",pid,WEXITSTATUS(status));
                                }
                        }
return 0;
}

int figlio(char *filename,int indice)
{
        char cs[255];   /* per la linea */
        int numlinea=-1,i=0,j=0,conta=0;
	/* numlinea bisogna inizializzarlo a -1 perche' il figlio di indice 0 deve occuparsi della prima linea */
        if(indice<Nfigli-2)
        { /* codice dei figli generici */
                fd=open(filename,O_RDONLY);
                if(fd<0)
                {
                        zprintf(2,"Errore nell'apertura del file %s\n",filename);
                        return 1;
                }

                /* chiusura pipe */
                for(i=0;i<Npipe;i++)
                {
                        close(pipesU[i][0]);
                        close(pipesD[i][0]);
                        if(i!=indice)
                        {
                                close(pipesU[i][1]);
                                close(pipesD[i][1]);
                        }
                }
                i=0;
                /* lettura file a linee */
	while (read(fd,&(cs[i]),1))
 	{
          /* conteggio linee */
          if(cs[i] != '\n')
              i++;
          else
          	{                                       
	 	numlinea++;
	 	if(numlinea == indice)
                   {       
	               	/* siamo sulla linea giusta e quindi deve avvenire la comunicazione nella pipe: il protocollo di comunicazione
			   prevede che il figlio generico mandi a Psotto o Psopra tutto il buffer che contiene quindi la linea oltre a
			   dei caratteri 'spuri'  */
	    		/* incrementiamo i dato che si deve tenere conto nel conteggio del teminatore di linea */
 		 	i++;                              
                        if(i>=H)
                        	write(pipesD[indice][1],cs,sizeof(cs));
                        else
                                write(pipesU[indice][1],cs,sizeof(cs));
                        return (i);
                        }
		else i = 0; /* si deve azzerare l'indice della linea */
 		} 
 	} 
 	return i; /* questo return serve solo se l'ultima linea non termina con il corretto terminatore di linea (\n) */
        }
        else
        {
        /* codice dei figli Psopra e Psotto */ 
        /* stampa di controllo 
        zprintf(2,"sono il figlio Psopra o Psotto %d\n",getpid());
	*/
	/* apriamo in scrittura il file creato dal padre */
        fd=open(filename,O_WRONLY);
        if(fd<0)
        {
                zprintf(2,"Errore nell'apertura del file %s\n",filename);
                return 1;
        }
        /* chiusura pipe */
                for(i=0;i<Npipe;i++)
                {
                        close(pipesU[i][1]);
                        close(pipesD[i][1]);
                }
		if (indice == Nfigli-2)  /* figlio Psotto: NON usa pipesU in lettura  */
		 	for(i=0;i<Npipe;i++)
                        	close(pipesU[i][0]);
		if (indice == Nfigli-1)  /* figlio Psopra: NON usa pipesD in lettura  */
		 	for(i=0;i<Npipe;i++)
                        	close(pipesD[i][0]);

        /* ciclo per la lettura delle pipe: il protocollo di comunicazione prevede la lettura di un buffer di lunghezza prefissata,
           all'interno del quale si trova la linea da scrivere sul proprio file  */
                for(i=0;i<Nfigli-2;i++)
                {      
        	/* stampa di controllo 
                zprintf(2,"Siamo nel ciclo di lettura della pipe per il processo %d iterazione %d\n", getpid(), i);
		*/
                        if(indice==Nfigli-2)
                              nrp=read(pipesD[i][0],cs,sizeof(cs));
                        else
                              nrp=read(pipesU[i][0],cs,sizeof(cs));
        		/* stampa di controllo 
                	zprintf(2,"Errore pid %d legge  %d\n", getpid(), nrp);
			*/
                        /* se abbiamo letto una linea */
			if(nrp !=0)
			{ 
				j = 0;
				/* adesso bisogna estrarre dal buffer un carattere alla volta e scriverlo sul file corretto fino alla fine della linea */
                                while(cs[j] != '\n')
                                {
                                   write(fd,&cs[j],1);
                                   /* stampa di controllo write(1,&cs[j],1); */
                                   j++;
                                } 
			        write(fd, &cs[j],1); /* scriviamo anche il terminatore di linea */
				/* stampa di controllo write(1, &cs[j],1); */
				/* abbiamo scritto una linea nel file e quindi incrementiamo conta */
				conta++;
                                }
                        }
                return conta;
                }
        }

void zprintf(int fd, const char *fmt, ...) {
        /* printf wrapper using write instead */
        static char msg[256];
        va_list ap;
        int n;
        va_start(ap, fmt);
        n=vsnprintf (msg, 256, fmt, ap);
        write(fd,msg,n);
        va_end(ap);
}