/*
 * JSON output formatting functions.
 *
 * No copyright is claimed.  This code is in the public domain; do with
 * it what you wish.
 *
 * Written by Karel Zak <kzak@redhat.com>
 */
#include <stdio.h>
#include <inttypes.h>
#include <ctype.h>
#include <cctype.h>

#include "c.h"
#include "jsonwrt.h"

/*
 * Requirements enumerated via testing (V8, Firefox, IE11):
 *
 * var charsToEscape = [];
 * for (var i = 0; i < 65535; i += 1) {
 *	try {
 *		JSON.parse('{"sample": "' + String.fromCodePoint(i) + '"}');
 *	} catch (e) {
 *		charsToEscape.push(i);
 *	}
 * }
 */
static void fputs_quoted_case_json(const char *data, FILE *out, int dir, size_t size)
{
	const char *p;

	fputc('"', out);
	for (p = data; p && *p && (!size || p < data + size); p++) {

		const unsigned int c = (unsigned int) *p;

		/* From http://www.json.org
		 *
		 * The double-quote and backslashes would break out a string or
		 * init an escape sequence if not escaped.
		 *
		 * Note that single-quotes and forward slashes, while they're
		 * in the JSON spec, don't break double-quoted strings.
		 */
		if (c == '"' || c == '\\') {
			fputc('\\', out);
			fputc(c, out);
			continue;
		}

		/* All non-control characters OK; do the case swap as required. */
		if (c >= 0x20) {
			/*
			 * Don't use locale sensitive ctype.h functions for regular
			 * ASCII chars, because for example with Turkish locale
			 * (aka LANG=tr_TR.UTF-8) toupper('I') returns 'I'.
			 */
			if (c <= 127)
				fputc(dir ==  1 ? c_toupper(c) :
				      dir == -1 ? c_tolower(c) : *p, out);
			else
				fputc(dir ==  1 ? toupper(c) :
				      dir == -1 ? tolower(c) : *p, out);
			continue;
		}

		/* In addition, all chars under ' ' break Node's/V8/Chrome's, and
		 * Firefox's JSON.parse function
		 */
		switch (c) {
			/* Handle short-hand cases to reduce output size.  C
			 * has most of the same stuff here, so if there's an
			 * "Escape for C" function somewhere in the STL, we
			 * should probably be using it.
			 */
			case '\b':
				fputs("\\b", out);
				break;
			case '\t':
				fputs("\\t", out);
				break;
			case '\n':
				fputs("\\n", out);
				break;
			case '\f':
				fputs("\\f", out);
				break;
			case '\r':
				fputs("\\r", out);
				break;
			default:
				/* Other assorted control characters */
				fprintf(out, "\\u00%02x", c);
				break;
		}
	}
	fputc('"', out);
}

#define fputs_quoted_json(_d, _o)       fputs_quoted_case_json(_d, _o, 0, 0)
#define fputs_quoted_json_upper(_d, _o) fputs_quoted_case_json(_d, _o, 1, 0)
#define fputs_quoted_json_lower(_d, _o) fputs_quoted_case_json(_d, _o, -1, 0)

void ul_jsonwrt_init(struct ul_jsonwrt *fmt, FILE *out, int indent, enum ul_json_format json_format)
{
	fmt->out = out;
	fmt->indent = indent;
	fmt->json_format = json_format;
	fmt->after_close = 0;
}

int ul_jsonwrt_is_ready(struct ul_jsonwrt *fmt)
{
	return fmt->out == NULL ? 0 : 1;
}

void ul_jsonwrt_indent(struct ul_jsonwrt *fmt)
{
	int i;

	for (i = 0; i < fmt->indent; i++)
		fputs("   ", fmt->out);
}

static void print_name(struct ul_jsonwrt *fmt, const char *name)
{
	if (fmt->after_close) {
		if (fmt->json_format == UL_JSON_LINE)
			fputs(fmt->indent == 0 ? "\n" : ",", fmt->out);
		else if (fmt->json_format == UL_JSON_COMPACT)
			fputs(",", fmt->out);
		else
			fputs(name ? ",\n" : ",", fmt->out);
	}

	switch (fmt->json_format) {
	case UL_JSON_LINE:
	case UL_JSON_COMPACT:
		break;
	case UL_JSON_PRETTY:
	default:
		if (name || !fmt->after_close)
			ul_jsonwrt_indent(fmt);
		break;
	}
	if (name)
		fputs_quoted_json_lower(name, fmt->out);
}

void ul_jsonwrt_open(struct ul_jsonwrt *fmt, const char *name, int type)
{
	const char *s = "";

	print_name(fmt, name);

	switch (type) {
	case UL_JSON_OBJECT:
		if (fmt->json_format == UL_JSON_LINE)
			s = "{";
		else if (fmt->json_format == UL_JSON_COMPACT) {
			/* At nesting depth 2, put the object opens on a new line
			 * for readability; otherwise keep fully compact (no newline). */
			if (fmt->indent == 2)
				s = name ? ":{" : "\n{";
			else
				s = "{";
		} else
			s = name ? ": {\n" : "{\n";
		fmt->indent++;
		break;
	case UL_JSON_ARRAY:
		if (fmt->json_format == UL_JSON_LINE)
			s = "[";
		else if (fmt->json_format == UL_JSON_COMPACT)
			s = name ? ":[" : "[";
		else
			s = name ? ": [\n" : "[\n";
		fmt->indent++;
		break;
	case UL_JSON_VALUE:
		if (fmt->json_format == UL_JSON_LINE)
			s = name ? ":" : "";
		else if (fmt->json_format == UL_JSON_COMPACT)
			s = name ? ":" : "";
		else
			s = name ? ": " : " ";
		break;
	}
	fputs(s, fmt->out);
	fmt->after_close = 0;
}

void ul_jsonwrt_empty(struct ul_jsonwrt *fmt, const char *name, int type)
{
	const char *s = "";

	print_name(fmt, name);

	switch (type) {
	case UL_JSON_OBJECT:
		if (fmt->json_format == UL_JSON_PRETTY)
			s = name ? ": {}" : "{}";
		else
			s = name ? ":{}" : "{}";
		break;
	case UL_JSON_ARRAY:
		if (fmt->json_format == UL_JSON_PRETTY)
			s = name ? ": []" : "[]";
		else
			s = name ? ":[]" : "[]";
		break;
	case UL_JSON_VALUE:
		if (fmt->json_format == UL_JSON_PRETTY)
			s = name ? ": null" : "null";
		else
			s = name ? ":null" : "null";
		break;
	}
	fputs(s, fmt->out);
	fmt->after_close = 1;
}

void ul_jsonwrt_close(struct ul_jsonwrt *fmt, int type)
{
	char endchr;

	assert(fmt->indent > 0);

	switch (type) {
	case UL_JSON_OBJECT:
		fmt->indent--;
		endchr = '}';
		break;
	case UL_JSON_ARRAY:
		fmt->indent--;
		endchr = ']';
		break;
	case UL_JSON_VALUE:
		fmt->after_close = 1;
		return;
	default:
		fmt->after_close = 1;
		return;
	}

	/* In COMPACT, when closing a direct child of root (indent==1),
	 * insert a newline so the closing bracket starts on its own line. */
	if (fmt->json_format == UL_JSON_COMPACT && fmt->indent == 1)
		fputc('\n', fmt->out);

	switch (fmt->json_format) {
	case UL_JSON_LINE:
	case UL_JSON_COMPACT:
		break;
	case UL_JSON_PRETTY:
	default:
		fputs("\n", fmt->out);
		ul_jsonwrt_indent(fmt);
		break;
	}

	fputc(endchr, fmt->out);

	switch (fmt->json_format) {
	case UL_JSON_LINE:
		break;
	case UL_JSON_COMPACT:
	case UL_JSON_PRETTY:
	default:
		if (fmt->indent == 0)
			fputc('\n', fmt->out);
		break;
	}
	fmt->after_close = 1;
}


void ul_jsonwrt_flush(struct ul_jsonwrt *fmt)
{
	fflush(fmt->out);
}

void ul_jsonwrt_value_raw(struct ul_jsonwrt *fmt,
			const char *name, const char *data)
{
	ul_jsonwrt_value_open(fmt, name);
	if (data && *data)
		fputs(data, fmt->out);
	else
		fputs("null", fmt->out);
	ul_jsonwrt_value_close(fmt);
}

void ul_jsonwrt_value_s(struct ul_jsonwrt *fmt,
			const char *name, const char *data)
{
	ul_jsonwrt_value_open(fmt, name);
	if (data && *data)
		fputs_quoted_json(data, fmt->out);
	else
		fputs("null", fmt->out);
	ul_jsonwrt_value_close(fmt);
}

void ul_jsonwrt_value_s_sized(struct ul_jsonwrt *fmt,
			      const char *name, const char *data, size_t size)
{
	ul_jsonwrt_value_open(fmt, name);
	if (data && *data)
		fputs_quoted_case_json(data, fmt->out, 0, size);
	else
		fputs("null", fmt->out);
	ul_jsonwrt_value_close(fmt);
}

void ul_jsonwrt_value_u64(struct ul_jsonwrt *fmt,
			const char *name, uint64_t data)
{
	ul_jsonwrt_value_open(fmt, name);
	fprintf(fmt->out, "%"PRIu64, data);
	ul_jsonwrt_value_close(fmt);
}

void ul_jsonwrt_value_double(struct ul_jsonwrt *fmt,
			const char *name, long double data)
{
	ul_jsonwrt_value_open(fmt, name);
	fprintf(fmt->out, "%Lg", data);
	ul_jsonwrt_value_close(fmt);
}

void ul_jsonwrt_value_boolean(struct ul_jsonwrt *fmt,
			const char *name, int data)
{
	ul_jsonwrt_value_open(fmt, name);
	fputs(data ? "true" : "false", fmt->out);
	ul_jsonwrt_value_close(fmt);
}