#include <stdio.h>
#include <mpi.h>
#include <stdlib.h>
#include <time.h>
#include <malloc.h>
#define Products 10

int main(int argc, char **argv )
{
  int myid, numprocs;
  int true = 1;
  int false = 0;
  int ncustomers = 20;
  int still_working, messages;
  int i, j, g, index, ready_bb, items, local_bagged_items, customer_items;
  int *all_bagged_items;
  int sumbagged, maxbagged, minbagged;
  float avgbagged;
  /* Note, Products below are defined in order of increasing weight */
  char Groceries[Products][20] = {"Chips","Lettuce","Bread","Eggs", \
                 "Pork Chops","Carrots","Rice","Canned Beans", \
                 "Spaghetti Sauce","Potatoes"};
  MPI_Request *mgr_req;
  MPI_Status status;

  MPI_Init(&argc,&argv);
  MPI_Comm_size(MPI_COMM_WORLD,&numprocs);
  MPI_Comm_rank(MPI_COMM_WORLD,&myid);

  if (numprocs < 2)
    {
      printf("ERROR: Must have at least 2 processes to run\n");
    }
  else
    {
      if (myid == 0)  // Manager
        {
          srand((unsigned)time(NULL)+myid); //initialize random numbers
          all_bagged_items = (int *) malloc((numprocs-1) * sizeof(int));
          mgr_req = (MPI_Request *) malloc((numprocs-1) * sizeof(MPI_Request));
          for (i=1;i<numprocs;i++)
	    {
              /* initially all bagboys will report in as ready: use nonblocking
		 receives, as the expected messages may not yet be present,
                 and we don't care about the order in which they're received */
	      MPI_Irecv(&all_bagged_items[i-1],1,MPI_INT,i,111, \
			MPI_COMM_WORLD,&mgr_req[i-1]);
	      /* ...note, we also use the messages to track all_bagged_items */
	    }
	  for (j=0;j<ncustomers;j++)
	    {
	      /* see how many items the current customer has */
              items = (rand() % 5) + 1;
	      printf("customer %d with %d items\n",j,items);
	      /* wait for any bagboy to report in */
	      MPI_Waitany(numprocs-1,mgr_req,&index,&status);
	      ready_bb = index + 1;
	      printf("Waitany passed, %d is ready\n",ready_bb);
	      /* send items to ready_bb, one at a time */
              for(i=1;i<=items;i++)
                {
                  g = rand() % 10; // determine item type for tag
                  printf("Sending %s, item %d of %d, to bagboy %d\n", \
                    Groceries[g],i,items,ready_bb);
                  MPI_Send(&items,1,MPI_INT,ready_bb,g,MPI_COMM_WORLD);
                } //done sending items
              /* prepare for the message he'll send when he's ready again--
                 this receive replaces the one cleared by MPI_Waitany */
              MPI_Irecv(&all_bagged_items[ready_bb-1],1,MPI_INT, \
			ready_bb,111,MPI_COMM_WORLD,&mgr_req[ready_bb-1]);
	    }
          /* no more customers, tell everyone to go home */
          items = 0;
          g = 999; // special tag, it means we're done
          for (i=1;i<numprocs;i++)
	    {
	      MPI_Send(&items,1,MPI_INT,i,g,MPI_COMM_WORLD);
	    }
	  MPI_Waitall(numprocs-1,mgr_req,MPI_STATUS_IGNORE);
	  /* compute stats on workload */
          sumbagged = 0;
          for (i=0;i<numprocs-1;i++) sumbagged += all_bagged_items[i];
	  avgbagged = (float)sumbagged/(numprocs-1);
	  maxbagged = 0;
	  minbagged = sumbagged;
          for (i=0;i<numprocs-1;i++)
	    {
	      if (all_bagged_items[i] > maxbagged) \
		maxbagged = all_bagged_items[i];
              if (all_bagged_items[i] < minbagged) \
		minbagged = all_bagged_items[i];
	    }
	  printf("Bagboy report, numbers of items bagged by each was:\n");
	  for (i=0;i<numprocs-1;i++) printf("%d ",all_bagged_items[i]);
	  printf("\n%d bagboys bagged %d items, average %f items per bagboy\n", \
		 numprocs-1,sumbagged,avgbagged);
	  printf("Busiest bagboy bagged %d items\n",maxbagged);
	  printf("Least busy bagboy bagged %d items\n",minbagged);
	} // Manager
      else // Worker
        {
          local_bagged_items = 0; // bagboys will count items locally processed
	  still_working = true;
	  while (still_working)
	    {
	      /* tell the manager I'm ready to work! */
              MPI_Send(&local_bagged_items,1,MPI_INT,0,111,MPI_COMM_WORLD);
	      /* wait for items to come in */
	      MPI_Probe(0,MPI_ANY_TAG,MPI_COMM_WORLD,&status);
              if (status.MPI_TAG < 999)
                {
                  customer_items = 0;
                  messages = true;
                  while (messages)
		    {
		      MPI_Recv(&items,1,MPI_INT,0,status.MPI_TAG, \
			   MPI_COMM_WORLD,&status);
	              /* increment the counts of items */
                      local_bagged_items++;
		      customer_items++;
                      printf("%d: Received %20s, item %d of %d\n",myid, \
			     Groceries[status.MPI_TAG],customer_items,items);
                     if (customer_items < items)
		       {
			 MPI_Probe(0,MPI_ANY_TAG,MPI_COMM_WORLD,&status);
		       }
		     else
		       {
			 messages = false;
		       }
		    }
		}
	      else // the 999 tag means: quitting time!
		{
		  printf("Bagboy %d is heading home\n",myid);
		  MPI_Recv(&items,1,MPI_INT,0,status.MPI_TAG, \
			   MPI_COMM_WORLD,&status); // clear final message
		  still_working = false;
		}
	    }
	} // Worker
    }
  MPI_Finalize();
  return 0;
 }