#ifdef _KERNEL_MODE
#	include <Drivers.h>
#	include <KernelExport.h>
#	include <module.h>
#	include <debug.h>
#endif

#include <directories.h>
#include <OS.h>
#include <image.h>
#include <ctype.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>

/* as driver or module */
//#define AS_DRIVER 1

/* do we reboot on loose ? */
//#define FAIL_IN_BSOD_CAUSE_REBOOT 1

/* shortcut to be able to exit (and take a screenshot) */
#define CAN_EXIT_ON_DASH

#define MAX_FAILS_BEFORE_BSOD 0

#ifdef __HAIKU__
#	define FORTUNE_FILE kSystemDataDirectory "/fortunes/Fortunes"
#else
#	define FORTUNE_FILE "/etc/fortunes/default"
#endif

#define KCMD_HELP "A funny KDL hangman game :-)"

#define DEV_ENTRY "misc/hangman"

#define KERNEL_IMAGE_ID 1

#define MIN_LETTERS 3
#define MAX_LETTERS 10

#define MAX_CACHED_WORDS 5

char words[MAX_CACHED_WORDS][MAX_LETTERS+1];

#ifndef __HAIKU__

/* design ripped off from http://www.latms.berkeley.k12.ca.us/perl/node30.html :) */
static char hungman[] = \
"  ____      \n" \
"  |   |     \n" \
"  |   %c     \n" \
"  |  %c%c%c    \n" \
"  |  %c %c    \n" \
"  |         \n";

#else

/* some colors */
static char hungman_ansi[] = \
"  ____      \n" \
"  |   |     \n" \
"  |   \033[36m%c\033[0m     \n" \
"  |  \033[35m%c%c%c\033[0m    \n" \
"  |  \033[35m%c %c\033[0m    \n" \
"  |         \n";

#endif

// for gets,
#define BIGBUFFSZ 128
char bigbuffer[BIGBUFFSZ];

#define BIT_FROM_LETTER(l) (0x1 << (l - 'a'))

status_t init_words(char *from);
status_t init_words_from_threadnames(void);
void print_hangman(int fails);
void display_word(int current, uint32 tried_letters);
int play_hangman(void);
int kdlhangman(int argc, char **argv);

#ifdef _KERNEL_MODE

# ifdef __HAIKU__
extern int kgets(char *buf, int len);
#  define PRINTF kprintf
#  define GETS(a) ({int l; kprintf("hangman> "); l = kgets(a, sizeof(a)); l?a:NULL;})
#  define HIDDEN_LETTER '_'
#  define HUNGMAN hungman_ansi
# else
/* BeOS R5 version, needs some R5 kernel privates... */
/* the kernel pointer to the bsod_gets */
static char *(*bsod_gets)(char *, char *, int);
extern char *(*bsod_kgets)(char *, char *, int);
//extern char *bsod_gets(char *);
/* saved here before panic()ing */
char *(*bsod_saved_kgets)(char *, char *, int);
#  define PRINTF kprintf
#  define GETS(a) ((*bsod_kgets)?(*bsod_kgets):(*bsod_gets))("hangman> ", a, sizeof(a))
#  define HIDDEN_LETTER '_'
#  define HUNGMAN hungman
# endif
#else
/* userland version */
# define PRINTF printf
# define GETS(a) gets(a)
# define dprintf printf
# define HIDDEN_LETTER '.'
#  define HUNGMAN hungman_ansi
#endif /* !_KERNEL_MODE */


status_t
init_words(char *from)
{
	int fd;
	size_t sz, got, beg, end, i;
	int current;
	struct stat st;

	memset((void *)words, 0, sizeof(words));
	fd = open(from, O_RDONLY);
	if (fd < B_OK)
		return fd;
	/* lseek() seems to always return 0 from the kernel ??? */
	if (fstat(fd, &st)) {
		close(fd);
		return B_ERROR;
	}
	sz = (size_t)st.st_size;
//	sz = (size_t)lseek(fd, 0, SEEK_END);
//	dprintf("khangman: lseek(): %ld\n", sz);
	if (sz < 30) {
		dprintf("hangman: fortune file too small\n");
		return B_ERROR;
	}
//	lseek(fd, 0, SEEK_SET);
	//srand((unsigned int)(system_time() + (system_time() >> 32) + find_thread(NULL)));
	srand((unsigned int)(system_time() & 0x0ffffffff));
	for (current = 0; current < MAX_CACHED_WORDS; current++) {
		off_t offset = (rand() % (sz - MAX_LETTERS));
	//	dprintf("current %d, offset %ld\n", current, (long)offset);
		lseek(fd, offset, SEEK_SET);
		got = read(fd, bigbuffer, BIGBUFFSZ - 2);
	//	dprintf("--------------buff(%d):\n%20s\n", current, bigbuffer);
		for (beg = 0; beg < got && isalpha(bigbuffer[beg]); beg++);
		for (; beg < got && !isalpha(bigbuffer[beg]); beg++);
		if (beg + 1 < got && isalpha(bigbuffer[beg])) {
			for (end = beg; end < got && isalpha(bigbuffer[end]); end++);
			if (end < got && !isalpha(bigbuffer[end]) && beg + MIN_LETTERS < end) {
				/* got one */
				/* tolower */
				for (i = beg; i < end; i++)
					bigbuffer[i] = tolower(bigbuffer[i]);
				strncpy(&(words[current][0]), &(bigbuffer[beg]), end - beg);
			} else
				current--;
		} else
			current--;
	}
	close(fd);
/*
	for (current = 0; current < MAX_CACHED_WORDS; current++)
		dprintf("%s\n", words[current]);
*/
	return B_OK;
}


status_t
init_words_from_threadnames(void)
{
	size_t sz, got, beg, end, i;
	int current;
	thread_info ti;

	memset((void *)words, 0, sizeof(words));
	srand((unsigned int)(system_time() & 0x0ffffffff));
	for (current = 0; current < MAX_CACHED_WORDS; ) {
		int offset;
		char *p;
		if (get_thread_info(rand() % 200, &ti) != B_OK)
			continue;
		sz = strnlen(ti.name, B_OS_NAME_LENGTH);
		if (sz <= MIN_LETTERS)
			continue;
		offset = (rand() % (sz - MIN_LETTERS));
		//dprintf("thread '%-.32s' + %d\n", ti.name, offset);
		p = ti.name + offset;
		got = sz - offset;
		for (beg = 0; beg < got && isalpha(p[beg]); beg++);
		for (; beg < got && !isalpha(p[beg]); beg++);
		if (beg + 1 < got && isalpha(p[beg])) {
			for (end = beg; end < got && isalpha(p[end]); end++);
			if (end < got && !isalpha(p[end]) && beg + MIN_LETTERS < end) {
				/* got one */
				/* tolower */
				for (i = beg; i < end; i++)
					p[i] = tolower(p[i]);
				strncpy(&(words[current][0]), &(p[beg]), end - beg);
			} else
				continue;
		} else
			continue;
		current++;
	}
	/*
	for (current = 0; current < MAX_CACHED_WORDS; current++)
		dprintf("%s\n", words[current]);
	*/
	return B_OK;
}


void
print_hangman(int fails)
{
	PRINTF(HUNGMAN,
		(fails > 0)?'O':' ',
		(fails > 2)?'/':' ',
		(fails > 1)?'|':' ',
		(fails > 3)?'\\':' ',
		(fails > 4)?'/':' ',
		(fails > 5)?'\\':' ');
}


void
display_word(int current, uint32 tried_letters)
{
	int i = 0;
	PRINTF("word> ");
	while (words[current][i]) {
		PRINTF("%c", (BIT_FROM_LETTER(words[current][i]) & tried_letters)?(words[current][i]):HIDDEN_LETTER);
		i++;
	}
	PRINTF("\n");
}

int
play_hangman(void)
{
	int current;
	int score = 0;
	int bad_guesses;
	uint32 tried_letters;
	char *str;
	char try;
	int gotit, gotone;

	for (current = 0; current < MAX_CACHED_WORDS; current++) {
		tried_letters = 0;
		gotit = 0;
		for (bad_guesses = 0; bad_guesses < 6; bad_guesses++) {
			do {
				gotit = 0;
				gotone = 1;
				display_word(current, tried_letters);
				str = GETS(bigbuffer);
				if (!str) {
					str = bigbuffer;
					PRINTF("buffer:%s\n", str);
				}
#ifdef CAN_EXIT_ON_DASH
				if (str[0] == '-') /* emergency exit */
					return 0;
#endif
				if (!isalpha(str[0])) {
					PRINTF("not a letter\n");
				} else {
					try = tolower(str[0]);
					if (BIT_FROM_LETTER(try) & tried_letters) {
						PRINTF("%c already tried\n", try);
					} else {
						// REUSE
						str = words[current];
						gotit = 1;
						gotone = 0;
						tried_letters |= BIT_FROM_LETTER(try);
						while (*str) {
							if (!(BIT_FROM_LETTER(*str) & tried_letters))
								gotit=0;
							if (try == *str)
								gotone = 1;
							str++;
						}
					}
				}
				//PRINTF("gotone:%d, gotit:%d, tried_letters:%08lx\n", gotone, gotit, tried_letters);
			} while(tried_letters != 0x03ffffff && !gotit && gotone);
			if (gotit)
				break;
			print_hangman(bad_guesses+1);
		}
		if (bad_guesses < 6) {
			display_word(current, 0x03ffffff);
			if (strlen(words[current]) < 5)
				PRINTF("That was easy :-P\n");
			else if (strlen(words[current]) < 7)
				PRINTF("Good one !\n");
			else
				PRINTF("You got this hard one ! :-)\n");
			score ++;
		}
/**/
		else return score;
/**/
	}
	return score;
}


#ifdef _KERNEL_MODE /* driver parts */


#ifndef __HAIKU__ /* BeOS intimacy revealed */
//char *bsod_wrapper_gets(char *p, int len)
//char *bsod_wrapper_gets(int len, char *p)
char *
bsod_wrapper_gets(char *prompt, char *p, int len)
{
	/* fall back to the normal gets() */
	bsod_kgets = bsod_saved_kgets;
//	if (!bsod_kgets)
//		bsod_kgets = bsod_gets;
	/* and fake some typing */
	strcpy(p, fake_typed);
	return p;
}
#else

#endif


int
kdlhangman(int argc, char **argv)
{
	int score;

	if (argc > 1 && strcmp(argv[1], "--help") == 0) {
		PRINTF("%s\n", KCMD_HELP);
		return 0;
	}

	score = play_hangman();
PRINTF("score %d\n", score);
	if (score > (MAX_CACHED_WORDS - MAX_FAILS_BEFORE_BSOD)) {
		PRINTF("Congrats !\n");
	}
	if (score < (MAX_CACHED_WORDS - MAX_FAILS_BEFORE_BSOD)) {
#ifdef FAIL_IN_BSOD_CAUSE_REBOOT
		PRINTF("Hmmm, sorry, need to trash your hdd... Ok, just a reboot then\n");
		fake_typed = "reboot";
		bsod_kgets = bsod_wrapper_gets;
		return 1;
#else
		PRINTF("Hmmm, sorry, need to trash your hdd... Well, I'll be nice this time\n");
#endif
	}
	//return B_KDEBUG_CONT;
	return B_KDEBUG_QUIT;
}


#  ifdef AS_DRIVER

typedef struct {
	int dummy;
} cookie_t;

const char * device_names[]={DEV_ENTRY, NULL};


status_t
init_hardware(void) {
	return B_OK;
}


status_t
init_driver(void)
{
	status_t err;

	err = init_words(FORTUNE_FILE);
	if (err < B_OK) {
		dprintf("hangman: error reading fortune file: %s\n", strerror(err));
		return B_ERROR;
	}
	get_image_symbol(KERNEL_IMAGE_ID, "bsod_gets", B_SYMBOL_TYPE_ANY, (void **)&bsod_gets);
	add_debugger_command("kdlhangman", kdlhangman, KCMD_HELP);
	return B_OK;
}


void
uninit_driver(void)
{
	remove_debugger_command("kdlhangman", kdlhangman);
}


const char **
publish_devices()
{
	return device_names;
}


status_t
khangman_open(const char *name, uint32 flags, cookie_t **cookie)
{
	(void)name; (void)flags;
	*cookie = (void*)malloc(sizeof(cookie_t));
	if (*cookie == NULL) {
		dprintf("khangman_open : error allocating cookie\n");
		goto err0;
	}
	memset(*cookie, 0, sizeof(cookie_t));
	return B_OK;
err0:
	return B_ERROR;
}


status_t
khangman_close(void *cookie)
{
	(void)cookie;
	return B_OK;
}


status_t
khangman_free(cookie_t *cookie)
{
	free(cookie);
	return B_OK;
}


status_t
khangman_read(cookie_t *cookie, off_t position, void *data, size_t *numbytes)
{
	*numbytes = 0;
	return B_NOT_ALLOWED;
}


status_t
khangman_write(void *cookie, off_t position, const void *data, size_t *numbytes)
{
	(void)cookie; (void)position; (void)data; (void)numbytes;
	//*numbytes = 0;
	/* here we get to kdlhangman */
	fake_typed = "kdlhangman";
	bsod_saved_kgets = bsod_kgets;
	bsod_kgets = bsod_wrapper_gets;
	kernel_debugger("So much more fun in KDL...");

	return B_OK;
}


device_hooks khangman_hooks={
	(device_open_hook)khangman_open,
	khangman_close,
	(device_free_hook)khangman_free,
	NULL,
	(device_read_hook)khangman_read,
	khangman_write,
	NULL,
	NULL,
	NULL,
	NULL
};


device_hooks *
find_device(const char *name)
{
	(void)name;
	return &khangman_hooks;
}


#  else /* as module */


static status_t
std_ops(int32 op, ...)
{
	status_t err;

	switch (op) {
		case B_MODULE_INIT:
			err = init_words(FORTUNE_FILE);
			if (err < B_OK) {
				dprintf("hangman: error reading fortune file: %s\n",
					strerror(err));
				err = init_words_from_threadnames();
				if (err < B_OK) {
					dprintf("hangman: error getting thread names: %s\n",
						strerror(err));
					return B_ERROR;
				}
			}
			add_debugger_command("kdlhangman", kdlhangman, KCMD_HELP);
			return B_OK;
		case B_MODULE_UNINIT:
			remove_debugger_command("kdlhangman", kdlhangman);
			return B_OK;
	}

	return B_ERROR;
}


static struct debugger_module_info sModuleInfo = {
	{
		"debugger/hangman/v1",
		B_KEEP_LOADED,
		&std_ops
	},
	NULL,
	NULL,
	NULL,
	NULL
};

module_info *modules[] = {
	(module_info *)&sModuleInfo,
	NULL
};

#  endif /* AS_DRIVER */

#else

void
kdl_trip(void)
{
	int fd;
	fd = open("/dev/misc/hangman", O_WRONLY);
	if (fd < B_OK) {
		puts("hey, you're pissing me off, no /dev/"DEV_ENTRY" !!!");
		system("/bin/alert --stop 'It would work better with the hangman driver enabled...\nyou really deserve a forced reboot :P'");
		return;
	}
	write(fd, "hangme!", 7);
	close(fd);
}


int
main(int argc, char *argv)
{
	int score; /* how many correct guesses ? */
	/* init */
	if (init_words(FORTUNE_FILE) < B_OK) {
		fprintf(stderr, "error reading fortune file\n");
		return 1;
	}
	score = play_hangman();
	PRINTF("score %d\n", score);
	if (score > (MAX_CACHED_WORDS - MAX_FAILS_BEFORE_BSOD)) {
		PRINTF("Congrats !\n");
	}
	if (score < (MAX_CACHED_WORDS - MAX_FAILS_BEFORE_BSOD)) {
		/* too many fails... gonna kick :p */
		kdl_trip();
	}
	return 0;
}


#endif