/*
 * parse plan.ini or /cfg/pxe/%E file into low memory
 */
#include	"u.h"
#include	"../port/lib.h"
#include	"mem.h"
#include	"dat.h"
#include	"fns.h"
#include	"io.h"
#include	"ureg.h"
#include	"pool.h"
#include	"../port/netif.h"
#include	"../ip/ip.h"
#include	"pxe.h"

typedef struct {
	char*	name;
	int	start;
	int	end;
} Mblock;

typedef struct {
	char*	tag;
	Mblock*	mb;
} Mitem;

Chan *conschan;

static Mblock mblock[MAXCONF];
static int nmblock;
static Mitem mitem[MAXCONF];
static int nmitem;
static char* mdefault;
static char mdefaultbuf[10];
static int mtimeout;

static char*
comma(char* line, char** residue)
{
	char *q, *r;

	if((q = strchr(line, ',')) != nil){
		*q++ = 0;
		if(*q == ' ')
			q++;
	}
	*residue = q;

	if((r = strchr(line, ' ')) != nil)
		*r = 0;

	if(*line == ' ')
		line++;
	return line;
}

static Mblock*
findblock(char* name, char** residue)
{
	int i;
	char *p;

	p = comma(name, residue);
	for(i = 0; i < nmblock; i++){
		if(strcmp(p, mblock[i].name) == 0)
			return &mblock[i];
	}
	return nil;
}

static Mitem*
finditem(char* name, char** residue)
{
	int i;
	char *p;

	p = comma(name, residue);
	for(i = 0; i < nmitem; i++){
		if(strcmp(p, mitem[i].mb->name) == 0)
			return &mitem[i];
	}
	return nil;
}

/* timeout is in seconds */
int
getstr(char *prompt, char *buf, int size, char *def, int timeout)
{
	int len, isdefault;
	static char pbuf[PRINTSIZE];

	if(conschan == nil)
		panic("getstr: #c/cons not open");
	buf[0] = 0;
	isdefault = (def && *def);
	if(isdefault == 0){
		timeout = 0;
		snprint(pbuf, sizeof pbuf, "%s: ", prompt);
	}
	else if(timeout)
		snprint(pbuf, sizeof pbuf, "%s[default==%s (%ds timeout)]: ",
			prompt, def, timeout);
	else
		snprint(pbuf, sizeof pbuf, "%s[default==%s]: ", prompt, def);
	for (;;) {
		print("%s", pbuf);
		if (timeout > 0) {
			for(timeout *= 1000; timeout > 0; timeout -= 100) {
				if (qlen(kbdq) > 0)	/* if input queued */
					break; 
				tsleep(&up->sleep, return0, 0, 100);
			}
			if (timeout <= 0) {		/* use default */
				print("\n");
				len = 0;
				break;
			}
		}
		buf[0] = '\0';
		len = devtab[conschan->type]->read(conschan, buf, size - 1,
			conschan->offset);
		if(len >= 0)
			buf[len] = '\0';
		switch(len){
		case 0:				/* eof */
		case 1:				/* newline */
			len = 0;
			buf[len] = '\0';
			if(!isdefault)
				continue;
			break;
		}
		if(len < size - 1)
			break;
		print("line too long\n");
	}
	if(len == 0 && isdefault)
		strncpy(buf, def, size);
	return 0;
}

void
askbootfile(char *buf, int len, char **bootfp, int secs, char *def)
{
	getstr("\nBoot from", buf, len, def, secs);
	trimnl(buf);
	if (bootfp)
		kstrdup(bootfp, buf);
}

int
isconf(char *name)
{
	int i;

	for(i = 0; i < nconf; i++)
		if(cistrcmp(confname[i], name) == 0)
			return 1;
	return 0;
}

/* result is not malloced, unlike user-mode getenv() */
char*
getconf(char *name)
{
	int i, n, nmatch;
	char buf[120];

	nmatch = 0;
	for(i = 0; i < nconf; i++)
		if(cistrcmp(confname[i], name) == 0)
			nmatch++;

	switch(nmatch) {
	default:
		print("\n");
		nmatch = 0;
		for(i = 0; i < nconf; i++)
			if(cistrcmp(confname[i], name) == 0)
				print("%d. %s\n", ++nmatch, confval[i]);
		print("%d. none of the above\n", ++nmatch);
		do {
			getstr(name, buf, sizeof(buf), nil, 0);
			n = atoi(buf);
		} while(n < 1 || n > nmatch);

		for(i = 0; i < nconf; i++)
			if(cistrcmp(confname[i], name) == 0)
				if(--n == 0)
					return confval[i];
		break;

	case 1:
		for(i = 0; i < nconf; i++)
			if(cistrcmp(confname[i], name) == 0)
				return confval[i];
		break;

	case 0:
		break;
	}
	return nil;
}

static void
parsemenu(char* str, char* scratch, int len)
{
	Mitem *mi;
	Mblock *mb, *menu;
	char buf[20], *p, *q, *line[MAXCONF];
	int i, inblock, n, show;

	inblock = 0;
	menu = nil;
	memmove(scratch, str, len);
	n = getfields(scratch, line, MAXCONF, 0, "\n");
	if(n >= MAXCONF)
		print("warning: possibly too many lines in plan9.ini\n");
	for(i = 0; i < n; i++){
		p = line[i];
		if(inblock && *p == '['){
			mblock[nmblock].end = i;
			if(strcmp(mblock[nmblock].name, "menu") == 0)
				menu = &mblock[nmblock];
			nmblock++;
			inblock = 0;
		}
		if(*p == '['){
			if(nmblock == 0 && i != 0){
				mblock[nmblock].name = "common";
				mblock[nmblock].start = 0;
				mblock[nmblock].end = i;
				nmblock++;
			}
			q = strchr(p+1, ']');
			if(q == nil || *(q+1) != 0){
				print("malformed menu block header - %s\n", p);
				return;
			}
			*q = 0;
			mblock[nmblock].name = p+1;
			mblock[nmblock].start = i+1;
			inblock = 1;
		}
	}

	if(inblock){
		mblock[nmblock].end = i;
		nmblock++;
	}
	if(menu == nil)
		return;
	if(nmblock < 2){
		print("incomplete menu specification\n");
		return;
	}

	for(i = menu->start; i < menu->end; i++){
		p = line[i];
		if(cistrncmp(p, "menuitem=", 9) == 0){
			p += 9;
			if((mb = findblock(p, &q)) == nil){
				print("no block for menuitem %s\n", p);
				return;
			}
			if(q != nil)
				mitem[nmitem].tag = q;
			else
				mitem[nmitem].tag = mb->name;
			mitem[nmitem].mb = mb;
			nmitem++;
		}
		else if(cistrncmp(p, "menudefault=", 12) == 0){
			p += 12;
			if((mi = finditem(p, &q)) == nil){
				print("no item for menudefault %s\n", p);
				return;
			}
			if(q != nil)
				mtimeout = strtol(q, 0, 0);
			snprint(mdefaultbuf, sizeof mdefaultbuf, "%ld",
				mi-mitem+1);
			mdefault = mdefaultbuf;
		}
		else if(cistrncmp(p, "menuconsole=", 12) == 0){
			p += 12;
			p = comma(p, &q);
			i8250config(p);
		}
		else{
			print("invalid line in [menu] block - %s\n", p);
			return;
		}
	}

again:
	print("\nPlan 9 Startup Menu:\n====================\n");
	for(i = 0; i < nmitem; i++)
		print("    %d. %s\n", i+1, mitem[i].tag);
	for(;;){
		getstr("Selection", buf, sizeof(buf), mdefault, mtimeout);
		mtimeout = 0;
		i = strtol(buf, &p, 0)-1;
		if(i < 0 || i >= nmitem)
			goto again;
		switch(*p){
		case 'p':
		case 'P':
			show = 1;
			print("\n");
			break;
		case 0:
		case '\n':
			show = 0;
			break;
		default:
			continue;
			
		}
		mi = &mitem[i];
	
		p = str;
		p += snprint(p, len, "menuitem=%s\n", mi->mb->name);
		for(i = 0; i < nmblock; i++){
			mb = &mblock[i];
			if(mi->mb != mb && cistrcmp(mb->name, "common") != 0)
				continue;
			for(n = mb->start; n < mb->end; n++)
				p += snprint(p, &str[len] - p, "%s\n", line[n]);
		}

		if(show){
			for(q = str; q < p; q += i){
				if((i = print(q)) <= 0)
					break;
			}
			goto again;
		}
		break;
	}
	print("\n");
}

/* dig out tables created by l16r.s in real mode */
void
readlsconf(void)
{
	int i, n;
	uchar *p;
	MMap *map;
	u64int addr, len;

	/*
	 * we could be running above 1MB, so put bios tables in low memory,
	 * not after end.
	 */
	p = (uchar*)KADDR(BIOSTABLES);
	for(n = 0; n < nelem(mmap); n++){
		if(*p == 0)
			break;
		if(memcmp(p, "APM\0", 4) == 0){
			p += 20;
			continue;
		}
		else if(memcmp(p, "MAP\0", 4) == 0){
			map = (MMap*)p;

			switch(map->type){
			default:
				if(v_flag)
					print("type %ud", map->type);
				break;
			case 1:
				if(v_flag)
					print("Memory");
				break;
			case 2:
				if(v_flag)
					print("reserved");
				break;
			case 3:
				if(v_flag)
					print("ACPI Reclaim Memory");
				break;
			case 4:
				if(v_flag)
					print("ACPI NVS Memory");
				break;
			}
			addr = (((u64int)map->base[1])<<32)|map->base[0];
			len = (((u64int)map->length[1])<<32)|map->length[0];
			if(v_flag)
				print("\t%#16.16lluX %#16.16lluX (%llud)\n",
					addr, addr+len, len);

			if(nmmap < nelem(mmap)){
				memmove(&mmap[nmmap], map, sizeof(MMap));
				mmap[nmmap].size = 20;
				nmmap++;
			}
			p += 24;
			continue;
		}
		else{
			 /* ideally we shouldn't print here */
			print("\nweird low-memory map at %#p:\n", p);
			for(i = 0; i < 24; i++)
				print(" %2.2uX", *(p+i));
			print("\n");
			delay(5000);
		}
		break;
	}
}

void
addconf(char *fmt, ...)
{
	va_list arg;

	va_start(arg, fmt);
	vseprint(BOOTARGS+strlen(BOOTARGS), BOOTARGS+BOOTARGSLEN, fmt, arg);
	va_end(arg);
}

void
dumpbootargs(void)
{
	char *p, *nl;

	/* in the boot, we can only print PRINTSIZE (256) bytes at a time. */
	print("boot args: ");
	for (p = (char *)BOOTARGS; *p != '\0'; p = nl) {
		nl = strchr(p, '\n');
		if (nl != nil) {
			++nl;
			print("%.*s", (int)(nl - p), p);
		}
	}
}

void
changeconf(char *fmt, ...)
{
	va_list arg;
	char *p, *q, pref[20], buf[128];

	va_start(arg, fmt);
	vseprint(buf, buf+sizeof buf, fmt, arg);
	va_end(arg);

	pref[0] = '\n';
	strncpy(pref+1, buf, 19);
	pref[19] = '\0';
	if(p = strchr(pref, '='))
		*(p+1) = '\0';
	else
		print("warning: did not change %s in plan9.ini\n", buf);

	/* find old line by looking for \nwhat= */
	if(strncmp(BOOTARGS, pref+1, strlen(pref+1)) == 0)
		p = BOOTARGS;
	else if(p = strstr(BOOTARGS, pref))
		p++;
	else
		p = nil;

	/* move rest of args up, deleting what= line. */
	if(p != nil && (q = strchr(p, '\n')) != nil)
		memmove(p, q+1, strlen(q+1)+1);

	/* add replacement to end */
	addconf("%s", buf);
}

/*
 *  read configuration file
 */
static char id[8] = "ZORT 0\r\n";

int
dotini(char *inibuf)
{
	int blankline, i, incomment, inspace, n;
	char *cp, *p, *q, *line[MAXCONF];

	cp = inibuf;

	/*
	 * Strip out '\r', change '\t' -> ' '.
	 * Change runs of spaces into single spaces.
	 * Strip out trailing spaces, blank lines.
	 *
	 * We do this before we make the copy so that if we 
	 * need to change the copy, it is already fairly clean.
	 * The main need is in the case when plan9.ini has been
	 * padded with lots of trailing spaces, as is the case 
	 * for those created during a distribution install.
	 */
	p = cp;
	blankline = 1;
	incomment = inspace = 0;
	for(q = cp; *q; q++){
		if(*q == '\r')
			continue;
		if(*q == '\t')
			*q = ' ';
		if(*q == ' '){
			inspace = 1;
			continue;
		}
		if(*q == '\n'){
			if(!blankline){
				if(!incomment)
					*p++ = '\n';
				blankline = 1;
			}
			incomment = inspace = 0;
			continue;
		}
		if(inspace){
			if(!blankline && !incomment)
				*p++ = ' ';
			inspace = 0;
		}
		if(blankline && *q == '#')
			incomment = 1;
		blankline = 0;
		if(!incomment)
			*p++ = *q;	
	}
	if(p > cp && p[-1] != '\n')
		*p++ = '\n';
	*p++ = 0;
	n = p-cp;

	parsemenu(cp, BOOTARGS, n);

	/*
	 * Keep a copy.
	 * We could change this to pass the parsed strings
	 * to the booted programme instead of the raw
	 * string, then it only gets done once.
	 */
	if(strncmp(cp, id, sizeof(id))){
		memmove(BOOTARGS, id, sizeof(id));
		if(n+1+sizeof(id) >= BOOTARGSLEN)
			n -= sizeof(id);
		memmove(BOOTARGS+sizeof(id), cp, n+1);
	}
	else
		memmove(BOOTARGS, cp, n+1);

	n = getfields(cp, line, MAXCONF, 0, "\n");
	for(i = 0; i < n; i++){
		cp = strchr(line[i], '=');
		if(cp == 0)
			continue;
		*cp++ = 0;
		if(cp - line[i] >= NAMELEN+1)
			*(line[i]+NAMELEN-1) = 0;
		confname[nconf] = line[i];
		confval[nconf] = cp;
		nconf++;
	}
	return 0;
}