#include <stdio.h>
#include <stdlib.h>
#include <setjmp.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>

#define STACK_SIZE 8192
#define NPROC      128

#define SNONE      0  /* no process there */
#define SRUN       1  /* process can run */
#define SSLEEP     2  /* blocked process */
#define SMAIN      3  /* process cannot run, except if no more processes are ready */

/*
 *   Structure of a process (a thread)
 */ 
struct proc {
	int     p_state;             /* state */
	jmp_buf p_buf;               /* cpu registers */
	char    p_stack[STACK_SIZE]; /* stack */
	void*   p_wchan;
};

struct proc proc[NPROC];   /* the processes */
char* stack;               /* lower adress of the stack (stack goes from stack to stack + STACK_SIZE */
int stack_index;           /* an index used when we copy the stack */
int current;

int save_in(int i) {
	/* save registers */
	if(setjmp(proc[i].p_buf) == 0) {
		/* save stack */
		for(stack_index=0; stack_index<STACK_SIZE; stack_index++)
			proc[i].p_stack[stack_index] = stack[stack_index];

		return 0;
	} else {
		/* be carreful: don't use any local variable to restore the stack of the new process */
		/* basically, we are restoring the stack of the new process */
		/* if we use a local variable, this variable will be in the stack (in the stack of the old process) */
		/* when we will restore the stack of the new process, we will overwrite this local variable, which will take a strange value! */
		/* => don't use local variable, and don't use memcpy as memcpy may use local variable */
		
		/* restore stack (stack_index and current are both global variables) */
		for(stack_index=0; stack_index<STACK_SIZE; stack_index++)
			stack[stack_index] = proc[current].p_stack[stack_index];

		return 1;
	}
}

int elect() {
	for(int i=0; i<NPROC; i++)
		if(proc[(current + 1 + i) % NPROC].p_state == SRUN)
			return (current + 1 + i) % NPROC;

	/* no more process, try to find the main process */ 
	for(int i=0; i<NPROC; i++)
		if(proc[i].p_state == SMAIN)
			return i;

	fprintf(stderr, "should not happen");
	exit(1);
}

void commut() {
	if(save_in(current) == 0) {
		/* mark to as the new process */
		current = elect();

		/* restore registers */
		longjmp(proc[current].p_buf, 1);
	}
}

void alarm_handler(int n) {
	alarm(1);
	commut();
}

int fork() {
	for(int i=0; i<NPROC; i++)
		if(proc[i].p_state == SNONE) {
			proc[i].p_state = SRUN;
			return save_in(i);
		}

	printf("no more entry\n");
	return -1;
}

void quit() {
	proc[current].p_state = SNONE;
	commut();
}

#define HIDE_ALL  0
#define HIDE_NONE 32

void spl(int n) {
	sigset_t set;
	sigemptyset(&set);
	for(int i=n; i<32; i++)
		sigaddset(&set, i);
	sigprocmask(SIG_SETMASK, &set, 0);
}

void my_sleep(void* wchan) {
	spl(HIDE_ALL);
	proc[current].p_wchan = wchan;
	proc[current].p_state = SSLEEP;
	spl(HIDE_NONE);
	commut();
}

void my_wakeup(void* wchan) {
	for(int i=0; i<NPROC; i++) {
		if(proc[i].p_state == SSLEEP && proc[i].p_wchan == wchan)
			proc[i].p_state = SRUN;
	}
}

/*
 *  processes
 */
struct inbox {
	int hasMessage;
	int message;
} inbox;

void f() {
	while(!inbox.hasMessage) {
		my_sleep(&inbox);
	}

	printf("Receive: %d\n", inbox.message);

	quit();
}

void g() {
	printf("Sleeping\n");
	sleep(1);
	printf("Sending message\n");
	inbox.message = 42;
	inbox.hasMessage = 1;
	my_wakeup(&inbox);

	quit();
}

/*
 *  bootstrap
 */
int main(int argc, char** argv) {
	struct sigaction sa;

	sa.sa_handler = alarm_handler;
	sigemptyset(&sa.sa_mask);
	sa.sa_flags = SA_NODEFER;

	sigaction(SIGALRM, &sa, 0);

	/* a random variable on the stack (in the frame of main) */
	char var;

	stack = &var - STACK_SIZE; /* the lower adress of the stack is at &var - STACK_SIZE */
	current = 0;               /* we are the main and will be elected at the end. Big hack here :) */

	for(int i=0; i<NPROC; i++)
		proc[i].p_state = SNONE;

	
	proc[0].p_state = SMAIN; /* save main in proc[0], but we cannot elect this process */
	if(save_in(0) == 0) {    /* save my state */
		/* if I'm saved, I start the f and g processes */
		if(fork() == 1)
			f();
		else if(fork() == 1)
			g();
		
		/* start the scheduler */
		alarm(1);
		/* leave the processor */
		commut();
	}

	printf("good bye\n");
	return 0;
}