// Ein spezielles Neuron mit genau einer Aufgabe
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>

#define STARTSIG SIGUSR1	// nach Erhalt des Signals wird die
				// Konfigdatei gelesen
#define MAXNR 100		// max. Anzahl Neuronen
#define SIGNR (SIGRTMAX-SIGRTMIN+1)		

int weight[100];		// Gewichtungen aller Eingangsleitungen
int outneuron[MAXNR];		// Ausgangsleitung zu einem Neuron
int outsig[MAXNR];		// Zuordnung Signalnr/Leitung
int map[MAXNR];			// PIDs der aktiven Neuronen
int nmap, nout;			// Anzahl verwendeter Neuronen/Leitungen

volatile int started = 0;
volatile int counter = 0;
int limit = 100;

// Proz. wird beim Eintreffen eines Signals eines anderen Neurons aufgerufen
// es muss die Gewichtung der jeweiligen Leitung berücksichtigt werden
void handler (int sig)
{
	counter += weight[sig-SIGRTMIN];
}

// fängt das Startsignal vom Verwalter ab; started wird auf 1 gesetzt und
// damit die Warteschleife im Hauptprg. verlassen
void start_handler ()
{
	started = 1;
}

void usage ()
{
	fprintf (stderr, "Usage: neron config nr\n");
	exit (1);
}

int main (int argc, char * argv[])
{
	struct sigaction act;
	int i, neuron, pid, arg1, arg2, nr;
	FILE * file;
	char line[100], key[100];
	int NR;

	if (argc != 3)
		usage ();
	if (sscanf (argv[2], "%d", &NR) != 1)
		usage ();

	nout = 0, nmap = 0;
	for (i=0; i<SIGNR; ++i) {
		weight[i] = 0;
	}
	/* Signal Handler für die Neuronen installieren */
	act.sa_handler = handler;
	act.sa_flags = 0;
	sigemptyset (&act.sa_mask);

	for (i=SIGRTMIN; i<= SIGRTMAX; ++i) {
		sigaddset (&act.sa_mask, i);
		weight[i-SIGRTMIN] = 0;
	}
	for (i=SIGRTMIN; i<= SIGRTMAX; ++i) {
		if (sigaction (i, &act, NULL) < 0) {
			perror ("sigaction");
			exit (1);
		}
	}
	act.sa_handler = start_handler;	// Starthandler vom Verwalter
	act.sa_flags = 0;
	sigemptyset (&act.sa_mask);
	sigaction (SIGUSR1, &act, NULL);
	while (!started) {		// Warten aufs Startsignal d. Verwalters
		select (0, NULL, NULL, NULL, NULL);
	}
	file = fopen (argv[1], "r");	// KonfigDatei öffnen & einlesen
	if (file == NULL) {
		perror ("open");
		exit (1);
	}
	/* Read input */
	while (1) {
		fgets (line, 100, file);	// 1 Zeile d. Konfigdatei
		if (feof (file))		// Eingabeende verläßt while
			break;
		if ((sscanf (line, "%s", key) == 1) &&	// MAP
		    (strcasecmp (key, "map") == 0)) {
			if ((sscanf (line, "%*s %d %d", &neuron, &pid) != 2) ||
			    (pid <= 0) || (neuron >= MAXNR) || (neuron < 0)) {
				fprintf (stderr, "Parse Error: %s\n", line);
				exit (1);
			}
			map[neuron] = pid;
			continue;
		}
		if (sscanf (line, "%d %s %d %d", &nr, key, &arg1, &arg2) != 4) {
			fprintf (stderr, "Parse error %s\n", line);
			exit (1);
		}
		if (nr != NR)		// KonfigZEile geht mich nix an!
			continue;
		if (strcasecmp (key, "in") == 0) {	// IN
			if ((arg1 < 0) || (arg1 > SIGNR)) {
				fprintf (stderr, "Bad input\n");
				exit (1);
			}
			weight[arg1] = arg2;	// Gewichtung merken
		} else if (strcasecmp (key, "out") == 0) {	// OUT
			if ((arg1 < 0) || (arg1 >= MAXNR) || (arg2 < 0)
			    || (arg2 >= SIGNR)) {
				fprintf (stderr, "Bad input\n");
				exit (1);
			}
			outneuron[nout] = arg1;	// Zielneuron merken
			outsig[nout] = SIGRTMIN+arg2;
			nout++;
		} else {
			fprintf (stderr, "Parse Error %s\n", line);
			exit (1);
		}
	}
	/* Ready to go */
	while (1) {		// warten auf Signale anderer Neuronen
		if (counter >= limit) {	// Eingangslimit erreicht
			counter = 0;	// Ausgangssignale verschicken
			for (i=0; i<nout; ++i) {
				kill (map[outneuron[i]], outsig[i]);
			}
			printf ("Neuron %d: Limit reached\n", NR);
		}
		select (0, NULL, NULL, NULL, NULL);
	}
	return 0;
}