# usage:
# 	@include "json.awk"
# 	BEGIN {
# 		src["hello"] = "world"
# 		json_save("test.json", src)
# 		json_load("test.json", dst)
# 		print dst["hello"]
# 	}
#
# value:
# 	object: { string : value, .. }
# 	array:  [ value, .. ]
# 	string: "char .."
# 	number: (builtin)
# 	true
# 	false
# 	null
# 
# chars:
# 	any-Unicode-character-except-"-or-\-or-control-character
# 	\"
# 	\\
# 	\/
# 	\b
# 	\f
# 	\n
# 	\r
# 	\t
# 	\u four-hex-digits

# Helpers
function json_gettype(value,   key, sort, n, i)
{
	if (isarray(value)) { 
		for (key in value)
			if (isarray(key))
				return "error"
		n = asorti(value, sort)
		for (i = 0; i < n; i++)
			if (sort[i+1] != i)
				return "object"
		return "array"
	} else {
		if (value == 0 && value == "")
			return "null"
		if (value == value + 0)
			return "number"
		if (value == value "")
			return "string"
		return "error"
	}
}

function json_join(array, sep,   i, str)
{
	str = array[0]
	for (i = 1; i < length(array); i++)
		str = str sep array[i]
	return str
}

function json_copy(dst, to, src,   key)
{
	if (isarray(src)) {
		delete dst[to]
		for (key in src) {
			dst[to][key]
			json_copy(dst[to], key, src[key])
		}
	} else {
		dst[to] = src
	}
}


# Write functions
function json_write_value(value, pad)
{
	switch (json_gettype(value)) {
		case "object": return json_write_object(value, pad)
		case "array":  return json_write_array(value, pad)
		case "number": return json_write_number(value)
		case "string": return json_write_string(value)
		case "null":   return "null"
		default:       return "error"
	}
}

function json_write_object(object, pad,   n, i, sort, key, val, data, len, max)
{
	n = asorti(object, sort)
	for (i = 0; i < n; i++) {
		key = json_write_string(sort[i+1])
		if (length(key) > max)
			max = length(key)
	}
	for (i = 0; i < n; i++) {
		key = json_write_string(sort[i+1])
		val = json_write_value(object[sort[i+1]],
			sprintf("%s  %"max"s  ", pad, ""))
		data[i] = sprintf("%-"(max+1)"s %s", key":", val)
	}
	return "{ " json_join(data, ",\n  " pad) " }"
}

function json_write_array(array, pad,   i, data)
{
	for (i = 0; i < length(array); i++)
		data[i] = json_write_value(array[i], pad "  ")
	return "[ " json_join(data, ",\n  " pad) " ]"
}

function json_write_number(number)
{
	return "" number ""
}

function json_write_string(string)
{
	gsub(/\\/, "\\\\", string)
	gsub(/"/,  "\\\"", string)
	gsub(/\b/, "\\b",  string)
	gsub(/\f/, "\\f",  string)
	gsub(/\n/, "\\n",  string)
	gsub(/\r/, "\\r",  string)
	gsub(/\t/, "\\t",  string)

	return "\"" string "\""
}


# Read functions
function json_tokenize(str, tokens,   i, line, items, table, type, found)
{
	table["term"]  = "^[\\[\\]{}:,]"
	table["str"]   = "^\"([^\\\\\"]|\\\\.)*\""
	table["num"]   = "^[+-]?[0-9]+(.[0-9]+)?"
	table["var"]   = "^(true|false|null)"
	table["space"] = "^[ \\t]+"
	table["line"]  = "^\n"
	i = 0;
	line = 1;
	while (length(str) > 0) {
		found = 0
		for (type in table) {
			#print "match: str=["str"] type="type" regex=/"table[type]"/"
			if (match(str, table[type], items) > 0) {
				#print "       len="RLENGTH" item=["items[0]"]"
				if (type == "line")
					line++;
				if (type == "term")
					type = items[0]
				if (type != "space" && type != "line") {
					tokens[i]["line"] = line
					tokens[i]["type"] = type
					tokens[i]["text"] = items[0]
					i++
				}
				str = substr(str, RLENGTH+1)
				found = 1
				break
			}
		}
		if (!found) {
			debug("line " line ": error tokenizing")
			return 0
		}
	}

	#for (i = 0; i < length(tokens); i++)
	#	printf "%-3s %-5s [%s]\n", i":",
	#		tokens[i]["type"], tokens[i]["text"]

	return i
}

function json_parse_value(tokens, i, value, key,   line, type, text)
{
	if (!i    ) i = 0;
	if (!depth) depth = 0
	depth++
	line = tokens[i]["line"]
	type = tokens[i]["type"]
	text = tokens[i]["text"]
	#printf "parse %d: i=%-2d type=%-3s text=%s\n", depth, i, type, text
	switch (type) {
		case "{":   i = json_parse_object(tokens, i, value, key); break
		case "[":   i = json_parse_array(tokens,  i, value, key); break
		case "str": i = json_parse_string(tokens, i, value, key); break
		case "num": i = json_parse_number(tokens, i, value, key); break
		case "var": i = json_parse_var(tokens,    i, value, key); break
		default:    debug("line "line": error type="type" text="text); return 0
	}
	depth--
	return i
}

function json_parse_object(tokens, i, value, key,   object, k, v)
{
	if (tokens[i++]["text"] != "{")
		return 0;

	if (tokens[i]["text"] != "}") {
		do {
			delete k
			delete v
			if (!(i=json_parse_value(tokens, i, k, 0)))
				return 0
			if (tokens[i++]["text"] != ":")
				return 0
			if (!(i=json_parse_value(tokens, i, v, 0)))
				return 0
			json_copy(object, k[0], v[0]) 
		} while (tokens[i++]["text"] == ",")
		i--
	}

	if (tokens[i++]["text"] != "}")
		return 0;

	json_copy(value, key, object)
	return i
}

function json_parse_array(tokens, i, value, key,   array, k, v)
{
	if (tokens[i++]["text"] != "[")
		return 0;

	if (tokens[i]["text"] != "]") {
		do {
			delete v
			if (!(i=json_parse_value(tokens, i, v, 0)))
				return 0
			json_copy(array, k++, v[0]) 
		} while (tokens[i++]["text"] == ",")
		i--
	}

	if (tokens[i++]["text"] != "]")
		return 0;

	json_copy(value, key, array)
	return i
}

function json_parse_number(tokens, i, value, key,   text)
{
	text = tokens[i++]["text"]
	json_copy(value, key, text + 0)
	#print "parse_number: " (text + 0)
	return i
}

function json_parse_string(tokens, i, value, key,   text)
{
	text = tokens[i++]["text"]
	len  = length(text);
	text = len == 2 ? "" : substr(text, 2, len-2)

	gsub(/\\\\/, "\\", text)
	gsub(/\\"/,  "\"", text)
	gsub(/\\b/,  "\b", text)
	gsub(/\\f/,  "\f", text)
	gsub(/\\n/,  "\n", text)
	gsub(/\\r/,  "\r", text)
	gsub(/\\t/,  "\t", text)

	json_copy(value, key, text)
	#print "parse_string: [" text "]"
	return i
}

function json_parse_var(tokens, i, value, key,   text, null)
{
	switch (tokens[i++]["text"]) {
		case "true":  json_copy(value, key, 1==1); break;
		case "false": json_copy(value, key, 1==2); break;
		case "null":  json_copy(value, key, null); break;
	}
	#print "parse_var: " text " -> " text == "true"
	return i
}


# String API
function json_decode(string, var,   tokens, data, key)
{
	if (!json_tokenize(string, tokens))
		return ""
	if (!json_parse_value(tokens, 0, data, 0))
		return ""
	if (!isarray(data[0]))
		return data[0]
	for (key in data[0])
		json_copy(var, key, data[0][key])
	return 1
}

function json_encode(var, pad)
{
	return json_write_value(var, pad)
}

# File API
function json_load(file, var,   line, string)
{
	delete var
	while ((getline line < file) > 0)
		string = string line "\n"
	return json_decode(string, var)
}

function json_save(file, var,   cmd, tmp)
{
	cmd = "mktemp " file ".XXX"
	cmd | getline tmp
	close(cmd)
	print json_encode(var) > tmp
	close(tmp)
	system("mv " tmp " " file)
}


# Test functions
function json_test_write()
{
	print "Testing JSON Write:"
	num      = 42
	str      = "hello, world"
	arr[0]   = "zero"
	arr[1]   = "one"
	arr[2]   = "two"
	obj["A"] = "a!"
	obj["B"] = "b!"
	obj["C"] = "c!"
	json_copy(mix, "number", num);
	json_copy(mix, "str",    str);
	json_copy(mix, "arr",    arr);
	json_copy(mix, "obj",    obj);
	json_copy(dub, "first",  mix);
	json_copy(dub, "second", mix);
	print json_encode(num)
	print json_encode(str)
	print json_encode(arr)
	print json_encode(obj)
	print json_encode(mix)
	print json_encode(dub)
}

function json_test_read()
{
	print "Testing JSON Read:"

	json_decode("[8, \"abc\", 9]", array);
	print json_encode(array)

	json_decode("{\"abc\": 1, \"def\": 2}", array)
	print json_encode(array)

	json = "{ \"first\":  { \"arr\":    [ \"\",             \n" \
	       "                              -1,               \n" \
	       "                              1.2,              \n" \
	       "                              true,             \n" \
	       "                              false,            \n" \
	       "                              null    ],        \n" \
	       "                \"number\": 42,                 \n" \
	       "                \"eobj\":   [ ],                \n" \
	       "                \"earr\":   { },                \n" \
	       "                \"obj\":    { \"A\": \"a!\",    \n" \
	       "                              \"B\": \"b!\",    \n" \
	       "                              \"C\": \"c!\" },  \n" \
	       "                \"str\":    \"hello, world\" }, \n" \
	       "  \"second\": { \"arr\":    [ \"zero\",         \n" \
	       "                              \"one\",          \n" \
	       "                              \"two\",          \n" \
	       "                              \"\\\"\t\r\b\" ], \n" \
	       "                \"number\": 42,                 \n" \
	       "                \"obj\":    { \"A\": \"a!\",    \n" \
	       "                              \"B\": \"b!\",    \n" \
	       "                              \"C\": \"c!\" },  \n" \
	       "                \"str\":    \"hello, world\" } }\n"

	json_decode(json, array)
	print json_encode(array)
}

function json_test_files()
{
	print "Testing JSON Files:"
	print "load: [" json_load("email.txt", mail) "]"
	print "mail: "  json_encode(mail, "      ")
	mail["andy753421"] = "andy753421@gmail.com"
	mail["andy"]       = "andy@gmail.com"
	mail["somebody"]   = "foo@example.com"
	print "mail: "  json_encode(mail, "      ")
	print "save: [" json_save("email.txt", mail) "]"
}

# Main
BEGIN {
	#json_test_write()
	#json_test_read()
	#json_test_files()
}