#include <common.h>

/**
** User function main #6:  exit, fork, exec, kill, waitpid, sleep, write
**
** Reports, then loops spawing userW, sleeps, then waits for or kills
** all its children.
**
** Invoked as:  main6  x  c  b
**	 where x is the ID character
**		   c is the child count
**		   b is wait/kill indicator ('w', 'W', or 'k')
*/

#ifndef MAX_CHILDREN
#define MAX_CHILDREN 50
#endif

USERMAIN(main)
{
	int count = 3; // default child count
	char ch = '6'; // default character to print
	int nap = 8; // nap time
	bool_t waiting = true; // default is waiting by PID
	bool_t bypid = true;
	char buf[128];
	uint_t children[MAX_CHILDREN];
	int nkids = 0;
	char ch2[] = "*?*";

	// process the command-line arguments
	switch (argc) {
	case 4:
		waiting = argv[3][0] != 'k'; // 'w'/'W' -> wait, else -> kill
		bypid = argv[3][0] != 'w'; // 'W'/'k' -> by PID
		// FALL THROUGH
	case 3:
		count = str2int(argv[2], 10);
		// FALL THROUGH
	case 2:
		ch = argv[1][0];
		break;
	default:
		sprint(buf, "main6: argc %d, args: ", argc);
		cwrites(buf);
		for (int i = 0; i <= argc; ++i) {
			sprint(buf, " %s", argv[argc] ? argv[argc] : "(null)");
			cwrites(buf);
		}
		cwrites("\n");
	}

	// fix the secondary output message (for indicating errors)
	ch2[1] = ch;

	// announce our presence
	write(CHAN_SIO, &ch, 1);

	// set up the argument vector
	char *argsw[] = { "userW", "W", "10", "5", NULL };

	for (int i = 0; i < count; ++i) {
		int whom = spawn(ProgW, argsw);
		if (whom < 0) {
			swrites(ch2);
		} else {
			children[nkids++] = whom;
		}
	}

	// let the children start
	sleep(SEC_TO_MS(nap));

	// collect exit status information

	// current child index
	int n = 0;

	do {
		int this;
		int32_t status;

		// are we waiting for or killing it?
		if (waiting) {
			this = waitpid(bypid ? children[n] : 0, &status);
		} else {
			// always by PID
			this = kill(children[n]);
		}

		// what was the result?
		if (this < SUCCESS) {
			// uh-oh - something went wrong

			// "no children" means we're all done
			if (this != E_NO_CHILDREN) {
				if (waiting) {
					sprint(buf, "!! %c: waitpid(%d) status %d\n", ch,
						   bypid ? children[n] : 0, this);
				} else {
					sprint(buf, "!! %c: kill(%d) status %d\n", ch, children[n],
						   this);
				}
			} else {
				sprint(buf, "!! %c: no children\n", ch);
			}

			// regardless, we're outta here
			break;

		} else {
			// locate the child
			int ix = -1;

			// were we looking by PID?
			if (bypid) {
				// we should have just gotten the one we were looking for
				if (this != children[n]) {
					// uh-oh
					sprint(buf, "** %c: wait/kill PID %d, got %d\n", ch,
						   children[n], this);
					cwrites(buf);
				} else {
					ix = n;
				}
			}

			// either not looking by PID, or the lookup failed somehow
			if (ix < 0) {
				int i;
				for (i = 0; i < nkids; ++i) {
					if (children[i] == this) {
						ix = i;
						break;
					}
				}
			}

			// if ix == -1, the PID we received isn't in our list of children

			if (ix < 0) {
				// didn't find an entry for this PID???
				sprint(buf, "!! %c: child PID %d term, NOT FOUND\n", ch, this);

			} else {
				// found this PID in our list of children
				if (ix != n) {
					// ... but it's out of sequence
					sprint(buf, "== %c: child %d (%d,%d) status %d\n", ch, ix,
						   n, this, status);
				} else {
					sprint(buf, "== %c: child %d (%d) status %d\n", ch, ix,
						   this, status);
				}
			}
		}

		cwrites(buf);

		++n;

	} while (n < nkids);

	exit(0);

	return (42); // shut the compiler up!
}