#include "./stdinc.h"

// Name:	npipe.c
// Purpose:	Make a pipeline with N identical processes; i.e., it
//		is equivalent to:
//			npipe < TestInput | npipe | ... | npipe
//		where there are N processes.
// Usage:	npipe [-d] [-n N]
//	-a	Run alternate plumbing algorithm
//	-d	Turn debugging messages on
//	-n N	# processes in pipe
// Method:
//	Consider the case of N=4, a 4-stage pipeline.  To minimize code,
//	want to exploit some regularity in viewing the computation.  If
//	we group the pipeline in the following manner, we see that all
//	stages except the last are structurally identical:
//
//		{ { { npipe | } npipe | } npipe | } npipe
//
//	( Note that we could also group from right-to-left. ) One way to
//	implement this is to have the child redirect stdin to a pipe while
//	the parent redirects stdout to a pipe.
// Note:
// o All msgs go to stderr
// o The role of the parent and child can be switched.
//

// --| constants |--
const	int	CHUNK = 10;

// --| prototypes |--
void getArgs(int argc, char *argv[]);
int do_io(int which);		// read (write) from (to) stdin (stdout);
				//	return #bytes written to stdout
int do_plumbing(int n);		// setup n pipes; return which child
int do_plumbing_alt(int n);	// alternate algorithm

// --| command line args |--
int	N = 3;		// -n N
int	alt = 0;	// -a (alternate algorithm where pipes are created
			//	first then assigned to processes)

// --| other global variables |--
int	fd[2];		// pipe fd
int	nbytes;		// #bytes read
unsigned int byte_sum;	// sum of all bytes

// --| inline functions |--
static inline void
pipe_stdout(int fd[]) {
  Dup2(fd[1], STDOUT_FILENO);
  close(fd[0]);
  close(fd[1]);
}

static inline void
pipe_stdin(int fd[]) {
  Dup2(fd[0], STDIN_FILENO);
  close(fd[0]);
  close(fd[1]);
}

static inline void
sum_bytes (char buf[], int n) {	// sum up bytes in buffer
  for (int i=0; i<n; i++)	byte_sum += (unsigned char) buf[i];
}

int
main (int argc, char *argv[]) {
  int	which;
  int	nbytes;		// #bytes written to stdout

  DEBUG( (stderr, "++ pid %d starting up\n", getpid()) );
  getArgs(argc, argv);

  if (alt)	which = do_plumbing_alt(N-1);
  else		which = do_plumbing(N-1);
  nbytes = do_io(which);
  fprintf(stderr, "pid %d:  nbytes = %d, byte_sum = %d\n",
  					getpid(), nbytes, byte_sum);
  return 0;
}

// --| get command line args |--
void
getArgs(int argc, char *argv[]) {
  int	c;
  int	ok = 1;
       
  while ((c = getopt(argc, argv, "adn:")) != -1) {
    switch(c) {
      case 'a':
        alt = 1;
      	break;
      case 'd':
        debug = 1;
      	break;
      case 'n':
        N = atoi(optarg);
      	break;
      default:	
        ok = 0;
	DEBUG( (stderr, "getArgs:  Unknown flag %c\n", c) );
        break;
    }
  }
  DEBUG( (stderr, "alt = %d, debug = %d, N = %d\n", alt, debug, N) );
  if (!ok) {
    DEBUG( (stderr, "Usage:  npipe [-a] [-d] [-n N] < Command\n") );
    exit(1);
  }
}

// --| do the plumbing |--
// Return which child where which in {0:N-1}
int
do_plumbing(int npipes) {
  pid_t	cpid;
  int	which;		// which instance

DEBUG( (stderr, "++ pid = %d:  do_plumbing running\n", getpid()) );
  for (int i=0; i<npipes; i++ ) {
    Pipe(fd);
DEBUG( (stderr, "++ pid = %d, do_plumbing:  fd[] = (%d, %d)\n",
					getpid(), fd[0], fd[1]) );
    cpid = Fork();
    if (cpid == 0) {	// child continues to fork other processes
      which = i+1;
      pipe_stdin(fd);
    } else {		// parent breaks out immediately
      which = i;
      pipe_stdout(fd);
      break;
    }
  }
DEBUG( (stderr, "++ pid = %d:  do_plumbing done. which = %d\n",
						getpid(), which) );
  return which;
}

// --| do the plumbing (alternate algorithm) |--
// Return which child where which in {0:N-1}
// Note:  This algorithm constructs all pipes first and then the
//	children use the one they need.
// Also:  It is a kludge and doesn't clean up like it should.
int
do_plumbing_alt(int npipes) {
  pid_t	cpid;
  int	which;		// which instance
  int	fd[npipes][2];

DEBUG( (stderr, "++ pid = %d:  do_plumbing_alt running\n", getpid()) );
  for (int i=0; i<npipes; i++ ) {
    Pipe(fd[i]);
DEBUG( (stderr, "++ pid = %d, do_plumbing:  fd[] = (%d, %d)\n",
				getpid(), fd[i][0], fd[i][1]) );
  }
  for (int i=0; i<npipes; i++ ) {
    cpid = Fork();
    if (cpid == 0) {	// child continues to fork other processes
      which = i+1;
      pipe_stdin(fd[i]);
    } else {		// parent breaks out immediately
      which = i;
      pipe_stdout(fd[i]);
      break;
    }
  }
DEBUG( (stderr, "++ pid = %d:  do_plumbing_alt done. which = %d\n",
						getpid(), which) );
  return which;
}

// --| do the I/O |--
// Read from stdin, and write to stdout until EOF
// which	which child {0:N-1}
// return	#bytes written
int
do_io(int which) {
  int	n;
  char	buf[CHUNK];
  int	nbytes;

DEBUG( (stderr, "++ pid = %d:  do_io running\n", getpid()) );
  byte_sum = 0;
  nbytes = 0;
  while ((n=Read(STDIN_FILENO, buf, CHUNK)) > 0) {
DEBUG( (stderr, "++ pid = %d, rc = %d, CHUNK = %d\n", getpid(), n, CHUNK) );
    nbytes += n;
    sum_bytes(buf,n);
    Write(STDOUT_FILENO, buf, n);
  }
DEBUG( (stderr, "++ pid = %d:  do_io out of loop with nbytes = %d, byte_sum = %d\n",
						getpid(), nbytes, byte_sum) );
  if (which < (N-1))	close(STDOUT_FILENO);	// or let exit handle
  return nbytes;
}