#include "common.h"
#include <string.h>
#include <stdlib.h>

#include <avr/eeprom.h>

#include "config.h"
#include "debug.h"
#include "xmalloc.h"
#include "crc.h"
#include "command.h"

#include "env.h"


#define ENV_SIZE	(CONFIG_ENV_SIZE - sizeof(uint16_t) -1)
#define ACTIVE_FLAG	1
#define OBSOLETE_FLAG	0


#define DELIM 		"\0"


#define ENV_GET_VAL	(1<<0)


/*
 * Default Environment
 */
const FLASH char default_env[] = {
	"bootdelay="	"3"		DELIM
	"bootcmd="	"reset; loadf; go $(startaddr)"	DELIM
	"baudrate="	"115200"	DELIM
	"startaddr="	"0"		DELIM
	DELIM
};




typedef struct environment_s {
	uint16_t	crc;		/* CRC16 over data bytes	*/
	uint8_t		flags;		/* active/obsolete flags	*/
	char		data[ENV_SIZE]; /* Environment data		*/
} env_t;



typedef struct env_item_s {
#define EF_N_EEP	(1<<7)		/* Variable name is in EEPROM */
#define EF_V_EEP	(1<<6)		/* Variable value is in EEPROM */
#define EF_DIRTY	(1<<0)		/* Variable is new or value changed */
	uint8_t flags;
	union {
		uint16_t eep;
		char	 *ram;
	} name;
	union {
		uint16_t eep;
		char	 *ram;
	} val;
} env_item_t;

static uint8_t env_valid;
static env_item_t env_list[CONFIG_ENVVAR_MAX];
static int entrycount;


static char env_get_char(uint16_t index)
{
	unsigned int off = CONFIG_ENV_OFFSET;

	if (env_valid == 2)
		off = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;

	return (char) eeprom_read_byte((const uint8_t *)off + index + 
				offsetof(env_t, data));
}


uint16_t ee_name_get(char *buf, env_item_t *ep)
{
	int i = 0;
	char c;
	
	if (ep->flags & EF_N_EEP) {

		while ((c = env_get_char(ep->name.eep + i)) != '=' &&
				c != '\0' && i < CONFIG_SYS_ENV_NAMELEN) {

			buf[i] = c;
			i++;
		}
		if (i > 0 && c != '=') {
			debug("** ee_name: '%s' not '=' terminated!\n", buf);
		}
	} else {
		strncpy(buf, ep->name.ram, CONFIG_SYS_ENV_NAMELEN);
		i = strnlen(buf, CONFIG_SYS_ENV_NAMELEN);
	}
	buf[i] = '\0';
	return i;
}


uint16_t ee_val_get(char *buf, uint16_t index, int len)
{
	int i = 0;
	char c;
	
	while ((c = env_get_char (index + i)) != '\0' && i < len) {
		buf[i] = c;
		i++;
	};
		
	buf[i] = '\0';
	
	/* TODO: len check */
	
	return i;
}

static
int comp_env_key_item(const void *key, const void *item)
{
	char buf[CONFIG_SYS_ENV_NAMELEN+1];
	env_item_t *ep = (env_item_t *) item;
	
	ee_name_get(buf, ep);
	
	return strcmp((char *) key, buf);
}

static
int comp_env_items(const void *m1, const void *m2)
{
	char b1[CONFIG_SYS_ENV_NAMELEN+1];
	char b2[CONFIG_SYS_ENV_NAMELEN+1];
	
	env_item_t *ep1 = (env_item_t *) m1;
	env_item_t *ep2 = (env_item_t *) m2;
	
	ee_name_get(b1, ep1);
	ee_name_get(b2, ep2);
	
	return strcmp(b1, b2);
}

#if 0
env_item_t * ee_entry_get(const char *s, env_item_t *ep, uint_fast8_t flag)
{
	char name[CONFIG_SYS_ENV_NAMELEN+1];
	uint16_t idx = 0;
	int nlen;
	
//printf_P(PSTR("*** ee_entry_get:        >>>>>>>>> ENTER <<<<<<<<<\n"));


	while ((nlen = ee_name_get(name, idx)) != 0 && idx < CONFIG_ENV_SIZE) {
	
//printf_P(PSTR("**  idx: %d, name: '%s', s: '%s', nlen: %d, cpres:%d\n"), 
//		idx, name, s, nlen, strncmp(name, s, nlen));
	
		if (strncmp(name, s, nlen) == 0)
			break;
			
		idx += nlen + 1;
		while (env_get_char(idx++) != 0)
			;
	}
	
	if (nlen) {
		char *vp;
		ep->flags = EF_N_EEP;
		ep->name.eep = idx;
		if (flag & ENV_GET_VAL) {
			vp = xmalloc(CONFIG_SYS_CBSIZE);
			nlen = ee_val_get(vp, idx + nlen + 1, CONFIG_SYS_CBSIZE);
			ep->val = xrealloc(vp, nlen + 1);
		} else
			ep->val = NULL;


//printf_P(PSTR("*** ee_entry_get:        >>>>>> LEAVE 0x%.4x <<<<<\n"), 
//			(unsigned int) ep);
		return ep;
	}

//printf_P(PSTR("*** ee_entry_get:        >>>>>> LEAVE <NULL> <<<<<\n"));
	return NULL;
}			
#endif

#if 0
static char p_env_name_buf[CONFIG_SYS_ENV_NAMELEN+1];

static char *dbg_p_env_name(env_item_t *p)
{
	if (p->flags & EF_N_EEP) {
		if (ee_name_get(p_env_name_buf, p) != 0)
			return p_env_name_buf;
		else
			return "<NULL>";
	}
	return "<NO EEP_NAME>";
}
#endif

int env_item_print(env_item_t *ep)
{
	char buf[CONFIG_SYS_ENV_NAMELEN+1];
	int len;
	env_item_t e = *ep;
	
	ee_name_get(buf, ep);
	len = printf_P(PSTR("%s="), buf);
	
	if (e.val.ram != NULL) {
		while (1) {
			char c;
			if (e.flags & EF_V_EEP) 
				c = env_get_char(e.val.eep++);
			else
				c = *e.val.ram++;
			
			if (c != '\0') {
				putchar(c);
				len++;
			} else
				break;
		}
	}
	putchar('\n');
	len ++;

	return len;
}	


int env_item_save(env_item_t *ep, uint16_t offset, int space_left)
{
	char buf[CONFIG_SYS_ENV_NAMELEN+1];
	int len;
	env_item_t e = *ep;

debug("-- env_item_save(%04x, %04x, %d)\n",
		ep, offset, space_left);
	
	len = ee_name_get(buf, ep);
	if (len == 0)
		return 0;
	buf[len++] = '=';
	space_left -= len;

if ((unsigned) len < sizeof(buf))
	buf[len] = '\0'; /* terminate for debugging */
debug("   len: %d, buf: '%s', space_left: %d\n", len, buf, space_left);
	
	if (space_left <= 0)
		return 0;
	
	eeprom_update_block(buf, (uint8_t *) offset, len);
	offset += len;
	
	if (e.val.ram != NULL) {
		char c;
		do {
			if (e.flags & EF_V_EEP) 
				c = env_get_char(e.val.eep++);
			else
				c = *e.val.ram++;
			
			eeprom_update_byte((uint8_t *) offset, c);
			offset++;
			space_left--;
			len++;
		} while ((c != '\0') && space_left );
	}
	return len;
}	


/*
 * Update
 *
 */
int env_item_update(env_item_t *ep)
{
	char buf[CONFIG_SYS_ENV_NAMELEN+1];
	uint_fast8_t len;
	char c;
	unsigned pos = 0;
			
	/* get name from old loc. (eeprom or ram */
	len = ee_name_get(buf, ep);
	buf[len++] = '=';
	
debug("-- env_item_update(%04x)\n", ep);
if (len < sizeof(buf))
	buf[len] = '\0'; /* terminate for debugging */
debug("   len: %d, buf: '%s'\n", len, buf);

	/* search this name in new eeprom env */
	 /* TODO: eliminate this ugly hack */
		uint8_t save_env_valid = env_valid;
		env_valid = (env_valid == 2) ? 1 : 2;
		
debug("   len: %d, buf: '%s', env_valid: %d\n", len, buf, env_valid);

	while ((c = env_get_char(pos)) != '\0' && pos < (ENV_SIZE - len)) {
		uint_fast8_t i = 0;

debug("     while: c: %02x, pos: %d\n       ", c, pos);

		while (c == buf[i] &&  i <= len) {

debug("%02x ", c);

			++i;
			c = env_get_char(pos + i);
		}

debug("\n     c: %02x, i: %d, pos: %d\n", c, i, pos);

		if (i == len) {
			if ((ep->flags & EF_N_EEP) == 0)
				free(ep->name.ram);
			ep->name.eep = pos;
			if ((ep->flags & EF_V_EEP) == 0)
				free(ep->val.ram);
			ep->val.eep = pos + i;
			ep->flags &= ~EF_DIRTY;
			ep->flags |= EF_N_EEP | EF_V_EEP;
			
			/* TODO: */
			env_valid = save_env_valid;
			return 0;
		}
		pos += i + 1;
		while (((c = env_get_char(pos++)) != '\0') && pos < (ENV_SIZE - len))
			;

debug("\n     c: %02x, i: %d, pos: %d\n", c, i, pos);

	}
	/* TODO: */
	env_valid = save_env_valid;
	
	/* name not found */
	return -1;
}	


int envlist_import(void)
{
	char name[CONFIG_SYS_ENV_NAMELEN+1];
	uint16_t idx = 0;
	int nlen;
	env_item_t e;
	
	e.flags = EF_N_EEP | EF_V_EEP;
	e.name.eep = idx;
	while ((nlen = ee_name_get(name, &e)) != 0 && idx < ENV_SIZE) {
	
		if (entrycount <= CONFIG_ENVVAR_MAX) {
			e.val.eep = idx + nlen + 1;
	
			env_list[entrycount++] = e;

			idx += nlen + 1;
			while (env_get_char(idx++) != 0 && idx < ENV_SIZE)
				;
			e.name.eep = idx;
		} else {
			debug("** Too many environment variables!\n");
			break;
		}
	}
	qsort(env_list, entrycount, sizeof(env_item_t), comp_env_items);

	return 0;
}

static env_item_t *envlist_search(const char *name)
{
	return bsearch(name, env_list, entrycount, 
				sizeof(env_item_t), comp_env_key_item);
}
			
#if 0
env_item_t *envlist_insert(const char *key, env_item_t *e)
{
	const size_t size = sizeof(env_item_t);

	if (entrycount < CONFIG_ENVVAR_MAX) {
		env_list[entrycount++] = *e;
		qsort(env_list, entrycount, size, comp_env_items);

		return bsearch(key, env_list, entrycount, 
					size, comp_env_key_item);
		
	} else
		return NULL;
}	
#endif

env_item_t *envlist_enter(env_item_t *e)
{
	char *key = e->name.ram;
	const size_t size = sizeof(env_item_t);
	env_item_t *ep;
	
	ep = bsearch(key, env_list, entrycount, 
			size, comp_env_key_item);
					
	if (ep == NULL) {
		if (entrycount < CONFIG_ENVVAR_MAX) {
			
			env_list[entrycount++] = *e;
			qsort(env_list, entrycount, size, comp_env_items);
			ep = bsearch(key, env_list, entrycount, 
						size, comp_env_key_item);
		}
	} else { 
		if ((ep->flags & EF_V_EEP) == 0) {
			free(ep->val.ram);
		}
		ep->val.ram = e->val.ram;
	}		

	if (ep != NULL) {
		ep->flags |= EF_DIRTY;
		ep->flags &= ~EF_V_EEP;
		
		if ((ep->flags & EF_N_EEP) == 0) {
			int nlen = strnlen(key, CONFIG_SYS_ENV_NAMELEN);
			char *name = xmalloc(nlen + 1);
			if (name == NULL) {
				printf_P(PSTR("## Can't malloc %d bytes\n"), 
					nlen + 1);
				return NULL;
			}
			strcpy(name, key);
			name[nlen] = '\0';
			ep->name.ram = name;
		}
	}

	return ep;		
}	


static env_item_t *envlist_get(const char *name, uint_fast8_t flag)
{
	env_item_t *ep;
	
	ep = envlist_search(name);

	if (ep != NULL && (flag & ENV_GET_VAL)) {
		if (ep->flags & EF_V_EEP) {
			char *vp;
			uint_fast8_t len;
			/* TODO: function that gets len of val, 
			   to get rid of xrealloc */ 
			vp = xmalloc(CONFIG_SYS_CBSIZE);
			len = ee_val_get(vp, ep->val.eep, CONFIG_SYS_CBSIZE);
			ep->val.ram = xrealloc(vp, len + 1);
			ep->flags &= ~EF_V_EEP;
		}
	}			
	
	return ep;
}

int env_item_delete(env_item_t *ep)
{
	if (entrycount == 0)
		return -1;
	if ((ep->flags & EF_V_EEP) == 0) 
		free(ep->val.ram);
	if ((ep->flags & EF_N_EEP) == 0) 
		free(ep->name.ram); 

	entrycount--;
	size_t size = sizeof(env_item_t);
	memmove(ep, ep + 1, (env_list - ep)*size + entrycount*size);

	return 0;		
}

static int envlist_delete(const char *name)
{
	env_item_t *ep = bsearch(name, env_list, entrycount, 
				sizeof(env_item_t), comp_env_key_item);

	if (ep != NULL)
		return env_item_delete(ep);

#if 0
	dump_ram((uint8_t *) &env_list[0], entrycount * sizeof(env_item_t),
			"=== env_list:");
	dump_heap();
	debug("** entrycount: %d\n", entrycount);
	for (int i=0; i<entrycount; i++) {
		printf_P(PSTR("** env var [%d] "), i);
		env_item_print(&env_list[i]);
	}
#endif

	return 1;
}
			
char *getenv(const char *name)
{
	env_item_t *ep;
	char *ret = NULL;

	debug("** getenv: %s\n", name);
	
	ep = envlist_get(name, ENV_GET_VAL);
	if (ep != NULL)
		ret = ep->val.ram;
#if 0
	dump_ram((uint8_t *) &env_list[0], entrycount * sizeof(env_item_t),
			"=== env_list:");
	dump_heap();
	debug("** entrycount: %d\n", entrycount);
	for (int i=0; i<entrycount; i++) {
		printf_P(PSTR("** env var [%d] "), i);
		env_item_print(&env_list[i]);
	}
#endif
	return ret;
}

uint16_t env_crc(uint16_t data_offset)
{
	uint16_t crc; 
	uint16_t i;
	char c, c0;

	crc = 0xffff;
	c = 0xff;
	for (i = 0; !(c == 0 && c0 == 0) && i < ENV_SIZE; i++)
	{
		c0 = c; 
		c = eeprom_read_byte((const uint8_t *) data_offset + i);
		crc = crc16(crc, c);
	}
	return crc ;
}

int saveenv(void)
{
	unsigned int off     = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;
	unsigned int off_red = CONFIG_ENV_OFFSET;
	unsigned int pos;
	int len, left;
	uint16_t crc;
	int rc = 0;

	if (env_valid == 2) {
		off	= CONFIG_ENV_OFFSET;
		off_red	= CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;
	}

	eeprom_update_byte((uint8_t *) off + offsetof(env_t, flags), 0xff); 

	pos = off + offsetof(env_t, data);
	left = ENV_SIZE - 1;
	for (int i = 0 ; i < entrycount; i++) {
		len = env_item_save(&env_list[i], pos, left);
		if (len == 0) {
			return 1;
		}
		pos += len;
		left -= len;
	}
	/* terminate list */
	eeprom_update_byte((uint8_t *) pos, 0);
	crc = env_crc(off + offsetof(env_t, data));
	eeprom_update_word((uint16_t *) off + offsetof(env_t, crc), crc);
	eeprom_update_byte((uint8_t *) off + offsetof(env_t, flags), 
					ACTIVE_FLAG);

	if (rc == 0) {
		while (entrycount != 0) {
			env_item_delete(&env_list[entrycount-1]);
		}
		eeprom_update_byte((uint8_t *) off_red + offsetof(env_t, flags), 
					OBSOLETE_FLAG);
		env_valid = (env_valid == 2) ? 1 : 2;

		envlist_import();
	}
	
	return rc;
}

/*-----------------------------------------------------------------------------*/

int set_default_env(void)
{
	char buf[64];
	uint16_t eep = CONFIG_ENV_OFFSET + offsetof(env_t, data);
	unsigned int len = ENV_SIZE;
	unsigned int i, src = 0;
	char c = 0xff, c0 = c;
#if 0
printf_P(PSTR("\n\n** set_default_env()\n"));
#endif
	if (env_valid == 1) {
		eep = CONFIG_ENV_OFFSET + offsetof(env_t, data) + CONFIG_ENV_SIZE;
	}

	while (len)  {
		memcpy_P(buf, default_env+src, sizeof(buf));
		for (i=0; i < (len < sizeof(buf) ? len : sizeof(buf)) &&
				!(c == 0 && c0 == 0);
				i++) {
			c0 = c; c = buf[i];
		}
		eeprom_update_block(buf, (char *) eep, i);
#if 0
		printf_P(PSTR("eeprom_update_block: eep: 0x%.4x, i:%d\n"), 
			(unsigned int) eep, i);
		dump_ram((uint8_t *) buf, i, "=== buf:");
		dump_eep((const uint8_t *) eep, i);
#endif
		if (c == 0 && c0 == 0)
			len = 0;
		if (len > sizeof(buf))
			len -= sizeof(buf);
		src += sizeof(buf);
		eep += sizeof(buf);
	}

#if 0
	dump_eep(0, 128);
#endif
	return 0;
}


int env_check(uint16_t offset)
{
	uint16_t crc, stored_crc; 

	/* read old CRC */
	stored_crc = eeprom_read_word(
		(const uint16_t *) offset + offsetof(env_t, crc));
	crc = env_crc(offset + offsetof(env_t, data));

	debug_cond((crc != stored_crc),
		"** crc eep: 0x%.4x, crc new: 0x%.4x\n", stored_crc, crc);
	
	return crc == stored_crc;
}

int _env_init(void)
{
	unsigned int off_env[2];
	uint8_t flags[2], crc_ok[2];

	off_env[0] = CONFIG_ENV_OFFSET;
	off_env[1] = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;

	for (uint_fast8_t i = 0; i < 2; i++) {
		/* read FLAGS */
		flags[i] = eeprom_read_byte ((uint8_t *) off_env[i] + 
					offsetof(env_t, flags));

		/* check CRC */
		crc_ok[i] = (
			eeprom_read_word((uint16_t *) off_env[i] + 
					offsetof(env_t, crc))
			== env_crc(off_env[i] + offsetof(env_t, data))
		);
	}

	if (!crc_ok[0] && !crc_ok[1]) {
		env_valid = 0;
debug("crc1: %02x, crc2: %02x, flag1 %02x, flag2 %02x, env_valid: %d\n",
	crc_ok[0], crc_ok[1], flags[0], flags[1], env_valid);
		return 0;

	} else if (crc_ok[0] && !crc_ok[1]) {
		env_valid = 1;
	} else if (!crc_ok[0] && crc_ok[1]) {
		env_valid = 2;
	} else {
		/* both ok - check serial */
		if (flags[0] == ACTIVE_FLAG && flags[1] == OBSOLETE_FLAG)
			env_valid = 1;
		else if (flags[0] == OBSOLETE_FLAG && flags[1] == ACTIVE_FLAG)
			env_valid = 2;
		else if (flags[0] == 0xFF && flags[1] == 0)
			env_valid = 2;
		else if (flags[1] == 0xFF && flags[0] == 0)
			env_valid = 1;
		else /* flags are equal - almost impossible */
			env_valid = 1;
	}
	
debug("crc1: %02x, crc2: %02x, flag1 %02x, flag2 %02x, env_valid: %d\n",
	crc_ok[0], crc_ok[1], flags[0], flags[1], env_valid);

	return 0;
}


int env_init(void)
{
	_env_init();
	if (env_valid == 0) {
		printf_P(PSTR("*** Warning - bad CRC, "
				"using default environment\n\n"));
		set_default_env();
	}
	entrycount = 0;
	envlist_import();
	return 0; 
}	


/*
 * Command interface: print one or all environment variables
 *
 * Returns -1 in case of error, or length of printed string
 */
static int env_print(char *name)
{
	int len = -1;

	if (name) {		/* print a single name */
	
		env_item_t *ep = envlist_search(name);
		if (ep != NULL)
			len = env_item_print(ep);

	} else {		/* print whole list */
		len = 0;
		for (int i = 0 ; i < entrycount; i++) {
			len += env_item_print(&env_list[i]);
		}
	}
	return len;
}

int env_print_ramsize(void)
{
	int size = 0;
	uint8_t name_cnt = 0;
	uint8_t val_cnt = 0;
	
	for (int i = 0 ; i < entrycount; i++) {
		if ((env_list[i].flags & EF_N_EEP) == 0 &&
				(env_list[i].name.ram != NULL)) {
			name_cnt++;
			size += strlen(env_list[i].name.ram) + 3;
		}
		if ((env_list[i].flags & EF_V_EEP) == 0 &&
				(env_list[i].val.ram != NULL)) {
			val_cnt++;
			size += strlen(env_list[i].val.ram) + 3;
		}
	}
	printf_P(PSTR("%d bytes RAM used for %u names and %u values\n"),
			size, name_cnt, val_cnt);
	return size;
}

int do_env_print(cmd_tbl_t *cmdtp, int flag, int argc,
			char * const argv[])
{
	int i;
	int rcode = 0;

	(void) cmdtp; (void) flag;

	if (argc == 1) {
		/* print all env vars */
		rcode = env_print(NULL);
		if (rcode < 0)
			return 1;
		printf_P(PSTR("\nEnvironment size: %d/%d bytes\n"),
			rcode, ENV_SIZE);
		env_print_ramsize();
		return 0;
	}

	/* print selected env vars */
	for (i = 1; i < argc; ++i) {
		int rc = env_print(argv[i]);
		if (rc < 0) {
			printf_P(PSTR("## Error: \"%s\" not defined\n"), argv[i]);
			++rcode;
		}
	}

	return rcode;
}


/**
 * Set or delete environment variable
 *
 * Set a new environment variable,
 * or replace or delete an existing one.
 *
 * @param flag		(not used)
 * @param argc
 * @param argv[1]	Environment variable to set or delete
 *			if no more args
 * @param argv[2] ...	Value to set it to
 *
 * @return 0 if ok, 1 on error
 */
static int _do_env_set(int flag, int argc, char * const argv[])
{
	int i, len;
	char *name, *value, *s;
	env_item_t e, *ep;

	(void) flag;
	debug("Initial value for argc=%d\n", argc);

	name = argv[1];
	value = argv[2];

	if (strchr(name, '=')) {
		printf_P(PSTR("## Error: illegal character '='"
		       "in variable name \"%s\"\n"), name);
		return 1;
	}
	if (strlen(name) > CONFIG_SYS_ENV_NAMELEN) {
		printf_P(PSTR("## Error: Variable name \"%s\" too long. "
		       "(max %d characters)\n"), name, CONFIG_SYS_ENV_NAMELEN);
		return 1;
	}
/*
	env_id++;
*/
	/* Delete only ? */
	if (argc < 3 || argv[2] == NULL) {
		int rc = envlist_delete(name);
		return rc != 0;
	}

	/*
	 * Insert / replace new value
	 */
	for (i = 2, len = 0; i < argc; ++i)
		len += strlen(argv[i]) + 1;

	value = xmalloc(len);
	if (value == NULL) {
		printf_P(PSTR("## Can't malloc %d bytes\n"), len);
		return 1;
	}
	for (i = 2, s = value; i < argc; ++i) {
		char *v = argv[i];

		while ((*s++ = *v++) != '\0')
			;
		*(s - 1) = ' ';
	}
	if (s != value)
		*--s = '\0';

	e.flags = EF_DIRTY;
	e.name.ram = name;
	e.val.ram = value;
	ep = envlist_enter(&e);
	if (!ep) {
		printf_P(PSTR("## Error inserting \"%s\" variable.\n"),
			name);
		return 1;
	}

	return 0;
}

/**
 * Set an environment variable
 *
 * @param varname	Environment variable to set
 * @param varvalue	Value to set it to
 * @return 0 if ok, 1 on error
 */
int setenv(const char *varname, const char *varvalue)
{
	const char * const argv[3] = { NULL, varname, varvalue };
	int argc = 3;

	if (varvalue == NULL || varvalue[0] == '\0')
		--argc;
		
	return _do_env_set(0, argc, (char * const *)argv);
}

#if 0
/**
 * Set an environment variable to an integer value
 *
 * @param varname	Environment variable to set
 * @param value		Value to set it to
 * @return 0 if ok, 1 on error
 */
int setenv_ulong(const char *varname, unsigned long value)
{
	/* TODO: this should be unsigned */
	char *str = simple_itoa(value);

	return setenv(varname, str);
}
#endif


/**
 * Set an environment variable to an value in hex
 *
 * @param varname	Environment variable to set
 * @param value		Value to set it to
 * @return 0 if ok, 1 on error
 */
int setenv_hex(const char *varname, unsigned long value)
{
	char str[sizeof(unsigned long) *2 + 1];

	sprintf_P(str, PSTR("%lx"), value);
	return setenv(varname, str);
}

/**
 * Get an environment variable as a hex value
 *
 * @param varname	Environment variable to get
 * @param default_val	Return this, if variable does not exist
 * @return hex value of variable or default_val
 */
unsigned long getenv_hex(const char *varname, unsigned long default_val)
{
	const char *s;
	unsigned long value;
	char *endp;

	s = getenv(varname);
	if (s)
		value = strtoul(s, &endp, 16);
	if (!s || endp == s)
		return default_val;

	return value;
}

int do_env_set(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
	(void) cmdtp;

	if (argc < 2)
		return CMD_RET_USAGE;

	return _do_env_set(flag, argc, argv);
}


int do_env_save(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
	(void) cmdtp; (void) flag; (void) argc;	(void) argv;

	printf_P(PSTR("Saving Environment ...\n"));

	return saveenv() ? 1 : 0;
}

#if defined(CONFIG_AUTO_COMPLETE) 
int env_complete(char *var, int maxv, char *cmdv[], int bufsz, char *buf)
{
	ENTRY *match;
	int found, idx;

	idx = 0;
	found = 0;
	cmdv[0] = NULL;

	while ((idx = hmatch_r(var, idx, &match, &env_htab))) {
		int vallen = strlen(match->key) + 1;

		if (found >= maxv - 2 || bufsz < vallen)
			break;

		cmdv[found++] = buf;
		memcpy(buf, match->key, vallen);
		buf += vallen;
		bufsz -= vallen;
	}

	qsort(cmdv, found, sizeof(cmdv[0]), strcmp_compar);

	if (idx)
		cmdv[found++] = "...";

	cmdv[found] = NULL;
	return found;
}
#endif