/*
 * Copyright 2017, Andrew Lindesay <apl@lindesay.co.nz>
 * Distributed under the terms of the MIT License.
 */


#include "JsonTextWriter.h"

#include <stdio.h>
#include <stdlib.h>

#include <UnicodeChar.h>


namespace BPrivate {


static bool
b_json_is_7bit_clean(uint8 c)
{
	return c >= 0x20 && c < 0x7f;
}


static bool
b_json_is_illegal(uint8 c)
{
	return c < 0x20 || c == 0x7f;
}


static const char*
b_json_simple_esc_sequence(char c)
{
	switch (c) {
		case '"':
			return "\\\"";
		case '\\':
			return "\\\\";
		case '/':
			return "\\/";
		case '\b':
			return "\\b";
		case '\f':
			return "\\f";
		case '\n':
			return "\\n";
		case '\r':
			return "\\r";
		case '\t':
			return "\\t";
		default:
			return NULL;
	}
}


static size_t
b_json_len_7bit_clean_non_esc(uint8* c, size_t length) {
	size_t result = 0;

	while (result < length
		&& b_json_is_7bit_clean(c[result])
		&& b_json_simple_esc_sequence(c[result]) == NULL) {
		result++;
	}

	return result;
}


/*! The class and sub-classes of it are used as a stack internal to the
    BJsonTextWriter class.  As the JSON is parsed, the stack of these
    internal listeners follows the stack of the JSON parsing in terms of
    containers; arrays and objects.
*/

class BJsonTextWriterStackedEventListener : public BJsonEventListener {
public:
								BJsonTextWriterStackedEventListener(
									BJsonTextWriter* writer,
									BJsonTextWriterStackedEventListener* parent);
								~BJsonTextWriterStackedEventListener();

				bool			Handle(const BJsonEvent& event);
				void			HandleError(status_t status, int32 line,
									const char* message);
				void			Complete();

				status_t		ErrorStatus();

				BJsonTextWriterStackedEventListener*
								Parent();

protected:

			status_t			StreamNumberNode(const BJsonEvent& event);

			status_t			StreamStringVerbatim(const char* string);
			status_t			StreamStringVerbatim(const char* string,
									off_t offset, size_t length);

			status_t			StreamStringEncoded(const char* string);
			status_t			StreamStringEncoded(const char* string,
									off_t offset, size_t length);

			status_t			StreamQuotedEncodedString(const char* string);
			status_t			StreamQuotedEncodedString(const char* string,
									off_t offset, size_t length);

			status_t			StreamChar(char c);

		virtual	bool			WillAdd();
		virtual void			DidAdd();

			void				SetStackedListenerOnWriter(
									BJsonTextWriterStackedEventListener*
									stackedListener);

			BJsonTextWriter*
								fWriter;
			BJsonTextWriterStackedEventListener*
								fParent;
				uint32			fCount;

};


class BJsonTextWriterArrayStackedEventListener
	: public BJsonTextWriterStackedEventListener {
public:
								BJsonTextWriterArrayStackedEventListener(
									BJsonTextWriter* writer,
									BJsonTextWriterStackedEventListener* parent);
								~BJsonTextWriterArrayStackedEventListener();

				bool			Handle(const BJsonEvent& event);

protected:
				bool			WillAdd();
};


class BJsonTextWriterObjectStackedEventListener
	: public BJsonTextWriterStackedEventListener {
public:
								BJsonTextWriterObjectStackedEventListener(
									BJsonTextWriter* writer,
									BJsonTextWriterStackedEventListener* parent);
								~BJsonTextWriterObjectStackedEventListener();

				bool			Handle(const BJsonEvent& event);
};

} // namespace BPrivate


using BPrivate::BJsonTextWriterStackedEventListener;
using BPrivate::BJsonTextWriterArrayStackedEventListener;
using BPrivate::BJsonTextWriterObjectStackedEventListener;


// #pragma mark - BJsonTextWriterStackedEventListener


BJsonTextWriterStackedEventListener::BJsonTextWriterStackedEventListener(
	BJsonTextWriter* writer,
	BJsonTextWriterStackedEventListener* parent)
{
	fWriter = writer;
	fParent = parent;
	fCount = 0;
}


BJsonTextWriterStackedEventListener::~BJsonTextWriterStackedEventListener()
{
}


bool
BJsonTextWriterStackedEventListener::Handle(const BJsonEvent& event)
{
	status_t writeResult = B_OK;

	if (fWriter->ErrorStatus() != B_OK)
		return false;

	switch (event.EventType()) {

		case B_JSON_NUMBER:
		case B_JSON_STRING:
		case B_JSON_TRUE:
		case B_JSON_FALSE:
		case B_JSON_NULL:
		case B_JSON_OBJECT_START:
		case B_JSON_ARRAY_START:
			if (!WillAdd())
				return false;
			break;

		default:
			break;
	}

	switch (event.EventType()) {

		case B_JSON_NUMBER:
			writeResult = StreamNumberNode(event);
			break;

		case B_JSON_STRING:
			writeResult = StreamQuotedEncodedString(event.Content());
			break;

		case B_JSON_TRUE:
			writeResult = StreamStringVerbatim("true", 0, 4);
			break;

		case B_JSON_FALSE:
			writeResult = StreamStringVerbatim("false", 0, 5);
			break;

		case B_JSON_NULL:
			writeResult = StreamStringVerbatim("null", 0, 4);
			break;

		case B_JSON_OBJECT_START:
		{
			writeResult = StreamChar('{');

			if (writeResult == B_OK) {
				SetStackedListenerOnWriter(
					new BJsonTextWriterObjectStackedEventListener(
						fWriter, this));
			}
			break;
		}

		case B_JSON_ARRAY_START:
		{
			writeResult = StreamChar('[');

			if (writeResult == B_OK) {
				SetStackedListenerOnWriter(
					new BJsonTextWriterArrayStackedEventListener(
						fWriter, this));
			}
			break;
		}

		default:
		{
			HandleError(B_NOT_ALLOWED, JSON_EVENT_LISTENER_ANY_LINE,
				"unexpected type of json item to add to container");
			return false;
		}
	}

	if (writeResult == B_OK)
		DidAdd();
	else {
		HandleError(writeResult, JSON_EVENT_LISTENER_ANY_LINE,
			"error writing output");
	}

	return ErrorStatus() == B_OK;
}


void
BJsonTextWriterStackedEventListener::HandleError(status_t status, int32 line,
	const char* message)
{
	fWriter->HandleError(status, line, message);
}


void
BJsonTextWriterStackedEventListener::Complete()
{
		// illegal state.
	HandleError(JSON_EVENT_LISTENER_ANY_LINE, B_NOT_ALLOWED,
		"Complete() called on stacked message listener");
}


status_t
BJsonTextWriterStackedEventListener::ErrorStatus()
{
	return fWriter->ErrorStatus();
}


BJsonTextWriterStackedEventListener*
BJsonTextWriterStackedEventListener::Parent()
{
	return fParent;
}


status_t
BJsonTextWriterStackedEventListener::StreamNumberNode(const BJsonEvent& event)
{
	return fWriter->StreamNumberNode(event);
}


status_t
BJsonTextWriterStackedEventListener::StreamStringVerbatim(const char* string)
{
	return fWriter->StreamStringVerbatim(string);
}


status_t
BJsonTextWriterStackedEventListener::StreamStringVerbatim(const char* string,
	off_t offset, size_t length)
{
	return fWriter->StreamStringVerbatim(string, offset, length);
}


status_t
BJsonTextWriterStackedEventListener::StreamStringEncoded(const char* string)
{
	return fWriter->StreamStringEncoded(string);
}


status_t
BJsonTextWriterStackedEventListener::StreamStringEncoded(const char* string,
	off_t offset, size_t length)
{
	return fWriter->StreamStringEncoded(string, offset, length);
}


status_t
BJsonTextWriterStackedEventListener::StreamQuotedEncodedString(
	const char* string)
{
	return fWriter->StreamQuotedEncodedString(string);
}


status_t
BJsonTextWriterStackedEventListener::StreamQuotedEncodedString(
	const char* string, off_t offset, size_t length)
{
	return fWriter->StreamQuotedEncodedString(string, offset, length);
}


status_t
BJsonTextWriterStackedEventListener::StreamChar(char c)
{
	return fWriter->StreamChar(c);
}


bool
BJsonTextWriterStackedEventListener::WillAdd()
{
	return true; // carry on
}


void
BJsonTextWriterStackedEventListener::DidAdd()
{
	fCount++;
}


void
BJsonTextWriterStackedEventListener::SetStackedListenerOnWriter(
	BJsonTextWriterStackedEventListener* stackedListener)
{
	fWriter->SetStackedListener(stackedListener);
}


// #pragma mark - BJsonTextWriterArrayStackedEventListener


BJsonTextWriterArrayStackedEventListener::BJsonTextWriterArrayStackedEventListener(
	BJsonTextWriter* writer,
	BJsonTextWriterStackedEventListener* parent)
	:
	BJsonTextWriterStackedEventListener(writer, parent)
{
}


BJsonTextWriterArrayStackedEventListener
	::~BJsonTextWriterArrayStackedEventListener()
{
}


bool
BJsonTextWriterArrayStackedEventListener::Handle(const BJsonEvent& event)
{
	status_t writeResult = B_OK;

	if (fWriter->ErrorStatus() != B_OK)
		return false;

	switch (event.EventType()) {
		case B_JSON_ARRAY_END:
		{
			writeResult = StreamChar(']');

			if (writeResult == B_OK) {
				SetStackedListenerOnWriter(fParent);
				delete this;
				return true; // must exit immediately after delete this.
			}
			break;
		}

		default:
			return BJsonTextWriterStackedEventListener::Handle(event);
	}

	if(writeResult != B_OK) {
		HandleError(writeResult, JSON_EVENT_LISTENER_ANY_LINE,
			"error writing output");
	}

	return ErrorStatus() == B_OK;
}


bool
BJsonTextWriterArrayStackedEventListener::WillAdd()
{
	status_t writeResult = B_OK;

	if (writeResult == B_OK && fCount > 0)
		writeResult = StreamChar(',');

	if (writeResult != B_OK) {
		HandleError(B_IO_ERROR, JSON_EVENT_LISTENER_ANY_LINE,
			"error writing data");
		return false;
	}

	return BJsonTextWriterStackedEventListener::WillAdd();
}


// #pragma mark - BJsonTextWriterObjectStackedEventListener


BJsonTextWriterObjectStackedEventListener::BJsonTextWriterObjectStackedEventListener(
	BJsonTextWriter* writer,
	BJsonTextWriterStackedEventListener* parent)
	:
	BJsonTextWriterStackedEventListener(writer, parent)
{
}


BJsonTextWriterObjectStackedEventListener
	::~BJsonTextWriterObjectStackedEventListener()
{
}


bool
BJsonTextWriterObjectStackedEventListener::Handle(const BJsonEvent& event)
{
	status_t writeResult = B_OK;

	if (fWriter->ErrorStatus() != B_OK)
		return false;

	switch (event.EventType()) {
		case B_JSON_OBJECT_END:
		{
			writeResult = StreamChar('}');

			if (writeResult == B_OK) {
				SetStackedListenerOnWriter(fParent);
				delete this;
				return true; // just exit after delete this.
			}
			break;
		}

		case B_JSON_OBJECT_NAME:
		{
			if (writeResult == B_OK && fCount > 0)
				writeResult = StreamChar(',');

			if (writeResult == B_OK)
				writeResult = StreamQuotedEncodedString(event.Content());

			if (writeResult == B_OK)
				writeResult = StreamChar(':');

			break;
		}

		default:
			return BJsonTextWriterStackedEventListener::Handle(event);
	}

	if (writeResult != B_OK) {
		HandleError(writeResult, JSON_EVENT_LISTENER_ANY_LINE,
			"error writing data");
	}

	return ErrorStatus() == B_OK;
}


// #pragma mark - BJsonTextWriter


BJsonTextWriter::BJsonTextWriter(
	BDataIO* dataIO)
	:
	fDataIO(dataIO)
{

		// this is a preparation for this buffer to easily be used later
		// to efficiently output encoded unicode characters.

	fUnicodeAssemblyBuffer[0] = '\\';
	fUnicodeAssemblyBuffer[1] = 'u';

	fStackedListener = new BJsonTextWriterStackedEventListener(this, NULL);
}


BJsonTextWriter::~BJsonTextWriter()
{
	BJsonTextWriterStackedEventListener* listener = fStackedListener;

	while (listener != NULL) {
		BJsonTextWriterStackedEventListener* nextListener = listener->Parent();
		delete listener;
		listener = nextListener;
	}

	fStackedListener = NULL;
}


bool
BJsonTextWriter::Handle(const BJsonEvent& event)
{
	return fStackedListener->Handle(event);
}


void
BJsonTextWriter::Complete()
{
		// upon construction, this object will add one listener to the
		// stack.  On complete, this listener should still be there;
		// otherwise this implies an unterminated structure such as array
		// / object.

	if (fStackedListener->Parent() != NULL) {
		HandleError(B_BAD_DATA, JSON_EVENT_LISTENER_ANY_LINE,
			"unexpected end of input data");
	}
}


void
BJsonTextWriter::SetStackedListener(
	BJsonTextWriterStackedEventListener* stackedListener)
{
	fStackedListener = stackedListener;
}


status_t
BJsonTextWriter::StreamNumberNode(const BJsonEvent& event)
{
	return StreamStringVerbatim(event.Content());
}


status_t
BJsonTextWriter::StreamStringVerbatim(const char* string)
{
	return StreamStringVerbatim(string, 0, strlen(string));
}


status_t
BJsonTextWriter::StreamStringVerbatim(const char* string,
	off_t offset, size_t length)
{
	return fDataIO->WriteExactly(&string[offset], length);
}


status_t
BJsonTextWriter::StreamStringEncoded(const char* string)
{
	return StreamStringEncoded(string, 0, strlen(string));
}


status_t
BJsonTextWriter::StreamStringUnicodeCharacter(uint32 c)
{
	sprintf(&fUnicodeAssemblyBuffer[2], "%04" B_PRIx32, c);
		// note that the buffer's first two bytes are populated with the JSON
		// prefix for a unicode char.
	return StreamStringVerbatim(fUnicodeAssemblyBuffer, 0, 6);
}


/*! Note that this method will expect a UTF-8 encoded string. */

status_t
BJsonTextWriter::StreamStringEncoded(const char* string,
	off_t offset, size_t length)
{
	status_t writeResult = B_OK;
	uint8* string8bit = (uint8*)string;
	size_t i = 0;

	while (i < length && writeResult == B_OK) {
		uint8 c = string8bit[offset + i];
		const char* simpleEsc = b_json_simple_esc_sequence(c);

		if (simpleEsc != NULL) {
			// here the character to emit is something like a tab or a quote
			// in this case the output JSON should escape it so that it looks
			// like \t or \n in the output.
			writeResult = StreamStringVerbatim(simpleEsc, 0, 2);
			i++;
		} else {
			if (b_json_is_7bit_clean(c)) {
				// in this case the first character is a simple one that can be
				// output without any special handling.  Find the sequence of
				// such characters and output them as a sequence so that it's
				// included as one write operation.
				size_t l = 1 + b_json_len_7bit_clean_non_esc(
					&string8bit[offset + i + 1], length - (offset + i + 1));
				writeResult = StreamStringVerbatim(&string[offset + i], 0, l);
				i += static_cast<size_t>(l);
			} else {
				if (b_json_is_illegal(c)) {
					fprintf(stderr, "! string encoding error - illegal "
						"character [%" B_PRIu32 "]\n", static_cast<uint32>(c));
					i++;
				} else {
					// now we have a UTF-8 sequence.  Read the UTF-8 sequence
					// to get the unicode character and then encode that as
					// JSON.
					const char* unicodeStr = &string[offset + i];
					uint32 unicodeCharacter = BUnicodeChar::FromUTF8(
						&unicodeStr);
					writeResult = StreamStringUnicodeCharacter(
						unicodeCharacter);
					i += static_cast<size_t>(unicodeStr - &string[offset + i]);
				}
			}
		}
	}

	return writeResult;
}


status_t
BJsonTextWriter::StreamQuotedEncodedString(const char* string)
{
	return StreamQuotedEncodedString(string, 0, strlen(string));
}


status_t
BJsonTextWriter::StreamQuotedEncodedString(const char* string,
	off_t offset, size_t length)
{
	status_t write_result = B_OK;

	if (write_result == B_OK)
		write_result = StreamChar('\"');

	if (write_result == B_OK)
		write_result = StreamStringEncoded(string, offset, length);

	if (write_result == B_OK)
		write_result = StreamChar('\"');

	return write_result;
}


status_t
BJsonTextWriter::StreamChar(char c)
{
	return fDataIO->WriteExactly(&c, 1);
}