#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <time.h>
#include <limits.h>
#include <signal.h>

#define READ 0
#define WRITE 1
#define MAX_PROCESSES 5
#define MAX_FILENAME_LENGTH 20

int main(int argc, char *argv[])
{
      int num_processes;
      pid_t process_ids[MAX_PROCESSES];
      int fd[MAX_PROCESSES][2];
      int i;
      int child_num;
      int rand_number;

      char pipe_message_input[LINE_MAX], pipe_message_output[LINE_MAX];
      char input_file_name[MAX_FILENAME_LENGTH], output_file_name[MAX_FILENAME_LENGTH];

      FILE *input, *output;

      int is_child = 0;

      if (argc < 3 ) {
	      printf("Please enter correct number of slave processes (2-5) and the input file name.\n");
	      exit(1);
      }

      num_processes = atoi(argv[1]);
      if (num_processes < 2 || num_processes > 5) {
	      printf("Please input a number between 2 and 5\n");
	      exit(1);
      }
      printf("Number of child processes: %d\n", num_processes);

      srand(time(NULL));

      //create n pipes
      for (i = 0; i < num_processes; i++) {
      	      if (pipe(fd[i]) == -1) {
		      //pipe failed
		      printf("Creating pipe #%d failed!\n", i);
		      exit(1);
		    }
      }

      //fork processes and setup is_child == 1 for children
      for (i = 0; i < num_processes; i++) {
      	      //making sure slave processes are not forking
      	      if (!is_child) {

		      process_ids[i] = fork();

		      if (process_ids[i] < 0) {
			      printf("fork() #%d failed!\n", i);
			      exit(1);
		      }

		      if (process_ids[i] == 0) {
			      //this is the child, let's make him aware of it
			      is_child = 1;
			      child_num = i;
		      }

		    }
      }

      //closing pipe ends
      if (is_child) {
      	      //close write end for children
      	      close(fd[child_num][WRITE]);
      } else {
      	      //close read end for all pipes in parent
      	      for (i = 0; i < num_processes; i++) {
			    close(fd[i][READ]);
		    }
      }

      //input file name and open file
      if (!is_child) {
	      memcpy(input_file_name, argv[2], strlen(argv[2]) + 1);
	      input = fopen(input_file_name, "r");
	      if (input == NULL) {
		      printf("Error opening file in master process.\n");
		      exit(1);
	      }
	      
	      printf("Master: opened file %s.\n", input_file_name);
      }

      //output file name for each child
      if (is_child) {
      	      sprintf(output_file_name, "%d.txt", child_num + 1);
      	      output = fopen(output_file_name, "w");
      	      if (output == NULL) {
			    printf("Error opening file in slave process %d.\n", child_num + 1);
			    exit(1);
		    }
	      printf("Child: opened file %d.txt\n", child_num+1);
      }

      if (!is_child) {
      	      printf("Master: getting ready to read from file!\n");
	      //read from file and write into pipes
	      while (fgets(pipe_message_input, LINE_MAX, input) != NULL) {
		      rand_number = (rand() % num_processes);
		      write(fd[rand_number][WRITE], pipe_message_input, strlen(pipe_message_input)+1);
		      printf("\t Main: sent message to pipe %d  -> %s", rand_number+1, pipe_message_input);
		      //parent unhangs child after sending him the message
		      printf("\t Main: continuing child %d\n", rand_number+1);
		      kill(process_ids[rand_number], SIGCONT);
		      waitpid(process_ids[rand_number], NULL, WUNTRACED);
	      }
	      fclose(input);

	      printf("Master: closing pipes!\n");
	      for (i = 0; i < num_processes; i++) {
		      close(fd[i][WRITE]);
		      close(fd[i][READ]);
	      }

	      for (i = 0; i < num_processes; i++) {
		      kill(process_ids[i], SIGCONT);
	      }
      }

      if (is_child) {
	      while (1) {
	      	      //read until WRITE side of pipe is closed
	      	      printf("Child %d: holding...\n", child_num+1);
	      	      //child stops itself
	      	      kill(getpid(), SIGSTOP);
	      	      printf("Child %d continued.\n", child_num+1);
	      	      printf("Child %d: Reading from pipe.\n", child_num+1);

		      if (read(fd[child_num][READ], pipe_message_output, LINE_MAX) == 0) {
		      	      printf("Child %d: pipe closed. exiting.\n");
		      	      fclose(output);
		      	      exit(1);
		      	      break;

		      } else {
			      printf("Child #%d recieved message %s\n", child_num+1, pipe_message_output);
			      fputs(pipe_message_output, output);
		      }

	      }
		      fclose(output);
      }

      wait(NULL);

      return 0;
}