/*
 * Copyright 2004-2010, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 */


#include "RTF.h"

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

#include <DataIO.h>


//#define TRACE_RTF
#ifdef TRACE_RTF
#	define TRACE(x...) printf(x)
#else
#	define TRACE(x...) ;
#endif


static const char *kDestinationControlWords[] = {
	"aftncn", "aftnsep", "aftnsepc", "annotation", "atnauthor", "atndate",
	"atnicn", "atnid", "atnparent", "atnref", "atntime", "atrfend",
	"atrfstart", "author", "background", "bkmkend", "buptim", "colortbl",
	"comment", "creatim", "do", "doccomm", "docvar", "fonttbl", "footer",
	"footerf", "footerl", "footerr", "footnote", "ftncn", "ftnsep",
	"ftnsepc", "header", "headerf", "headerl", "headerr", "info",
	"keywords", "operator", "pict", "printim", "private1", "revtim",
	"rxe", "stylesheet", "subject", "tc", "title", "txe", "xe",
};

static char read_char(BDataIO &stream, bool endOfFileAllowed = false);
static int32 parse_integer(char first, BDataIO &stream, char &_last, int32 base = 10);


using namespace RTF;


static char
read_char(BDataIO &stream, bool endOfFileAllowed)
{
	char c;
	ssize_t bytesRead = stream.Read(&c, 1);

	if (bytesRead < B_OK)
		throw (status_t)bytesRead;

	if (bytesRead == 0 && !endOfFileAllowed)
		throw (status_t)B_ERROR;

	return c;
}


static int32
parse_integer(char first, BDataIO &stream, char &_last, int32 base)
{
	const char *kDigits = "0123456789abcdef";
	int32 integer = 0;
	int32 count = 0;

	char digit = first;

	if (digit == '\0')
		digit = read_char(stream);

	while (true) {
		int32 pos = 0;
		for (; pos < base; pos++) {
			if (kDigits[pos] == tolower(digit)) {
				integer = integer * base + pos;
				count++;
				break;
			}
		}
		if (pos == base) {
			_last = digit;
			goto out;
		}

		digit = read_char(stream);
	}

out:
	if (count == 0)
		throw (status_t)B_BAD_TYPE;

	return integer;
}


static int
string_array_compare(const char *key, const char **array)
{
	return strcmp(key, array[0]);
}


static void
dump(Element &element, int32 level = 0)
{
	printf("%03" B_PRId32 " (%p):", level, &element);
	for (int32 i = 0; i < level; i++)
		printf("  ");

	if (RTF::Header *header = dynamic_cast<RTF::Header *>(&element)) {
		printf("<RTF header, major version %" B_PRId32 ">\n", header->Version());
	} else if (RTF::Command *command = dynamic_cast<RTF::Command *>(&element)) {
		printf("<Command: %s", command->Name());
		if (command->HasOption())
			printf(", Option %" B_PRId32, command->Option());
		puts(">");
	} else if (RTF::Text *text = dynamic_cast<RTF::Text *>(&element)) {
		printf("<Text>");
		puts(text->String());
	} else if (RTF::Group *group = dynamic_cast<RTF::Group *>(&element))
		printf("<Group \"%s\">\n", group->Name());

	if (RTF::Group *group = dynamic_cast<RTF::Group *>(&element)) {
		for (uint32 i = 0; i < group->CountElements(); i++)
			dump(*group->ElementAt(i), level + 1);
	}
}


//	#pragma mark -


Parser::Parser(BPositionIO &stream)
	:
	fStream(&stream, 65536, false),
	fIdentified(false)
{
}


status_t
Parser::Identify()
{
	char header[5];
	if (fStream.Read(header, sizeof(header)) < (ssize_t)sizeof(header))
		return B_IO_ERROR;

	if (strncmp(header, "{\\rtf", 5))
		return B_BAD_TYPE;

	fIdentified = true;
	return B_OK;
}


status_t
Parser::Parse(Header &header)
{
	if (!fIdentified && Identify() != B_OK)
		return B_BAD_TYPE;

	try {
		int32 openBrackets = 1;

		// since we already preparsed parts of the RTF header, the header
		// is handled here directly
		char last;
		header.Parse('\0', fStream, last);

		Group *parent = &header;
		char c = last;

		while (true) {
			Element *element = NULL;

			// we'll just ignore the end of the stream
			if (parent == NULL)
				return B_OK;

			switch (c) {
				case '{':
					openBrackets++;
					parent->AddElement(element = new Group());
					parent = static_cast<Group *>(element);
					break;

				case '\\':
					parent->AddElement(element = new Command());
					break;

				case '}':
					openBrackets--;
					parent->DetermineDestination();
					parent = parent->Parent();
					// supposed to fall through
				case '\n':
				case '\r':
				{
					ssize_t bytesRead = fStream.Read(&c, 1);
					if (bytesRead < B_OK)
						throw (status_t)bytesRead;
					else if (bytesRead != 1) {
						// this is the only valid exit status
						if (openBrackets == 0)
							return B_OK;

						throw (status_t)B_ERROR;
					}
					continue;
				}

				default:
					parent->AddElement(element = new Text());
					break;
			}

			if (element == NULL)
				throw (status_t)B_ERROR;

			element->Parse(c, fStream, last);
			c = last;
		}
	} catch (status_t status) {
		return status;
	}

	return B_OK;
}


//	#pragma mark -


Element::Element()
	:
	fParent(NULL)
{
}


Element::~Element()
{
}


void
Element::SetParent(Group *parent)
{
	fParent = parent;
}


Group *
Element::Parent() const
{
	return fParent;
}


bool
Element::IsDefinitionDelimiter()
{
	return false;
}


void
Element::PrintToStream(int32 level)
{
	dump(*this, level);
}


//	#pragma mark -


Group::Group()
	:
	fDestination(TEXT_DESTINATION)
{
}


Group::~Group()
{
	Element *element;
	while ((element = (Element *)fElements.RemoveItem((int32)0)) != NULL) {
		delete element;
	}
}


void
Group::Parse(char first, BDataIO &stream, char &last)
{
	if (first == '\0')
		first = read_char(stream);

	if (first != '{')
		throw (status_t)B_BAD_TYPE;

	last = read_char(stream);
}


status_t
Group::AddElement(Element *element)
{
	if (element == NULL)
		return B_BAD_VALUE;

	if (fElements.AddItem(element)) {
		element->SetParent(this);
		return B_OK;
	}

	return B_NO_MEMORY;
}


uint32
Group::CountElements() const
{
	return (uint32)fElements.CountItems();
}


Element *
Group::ElementAt(uint32 index) const
{
	return static_cast<Element *>(fElements.ItemAt(index));
}


Element *
Group::FindDefinitionStart(int32 index, int32 *_startIndex) const
{
	if (index < 0)
		return NULL;

	Element *element;
	int32 number = 0;
	for (uint32 i = 0; (element = ElementAt(i)) != NULL; i++) {
		if (number == index) {
			if (_startIndex)
				*_startIndex = i;
			return element;
		}

		if (element->IsDefinitionDelimiter())
			number++;
	}

	return NULL;
}


Command *
Group::FindDefinition(const char *name, int32 index) const
{
	int32 startIndex;
	Element *element = FindDefinitionStart(index, &startIndex);
	if (element == NULL)
		return NULL;

	for (uint32 i = startIndex; (element = ElementAt(i)) != NULL; i++) {
		if (element->IsDefinitionDelimiter())
			break;

		if (Command *command = dynamic_cast<Command *>(element)) {
			if (command != NULL && !strcmp(name, command->Name()))
				return command;
		}
	}

	return NULL;
}


Group *
Group::FindGroup(const char *name) const
{
	Element *element;
	for (uint32 i = 0; (element = ElementAt(i)) != NULL; i++) {
		Group *group = dynamic_cast<Group *>(element);
		if (group == NULL)
			continue;

		Command *command = dynamic_cast<Command *>(group->ElementAt(0));
		if (command != NULL && !strcmp(name, command->Name()))
			return group;
	}

	return NULL;
}


const char *
Group::Name() const
{
	Command *command = dynamic_cast<Command *>(ElementAt(0));
	if (command != NULL)
		return command->Name();

	return NULL;
}


void
Group::DetermineDestination()
{
	const char *name = Name();
	if (name == NULL)
		return;

	if (!strcmp(name, "*")) {
		fDestination = COMMENT_DESTINATION;
		return;
	}

	// binary search for destination control words

	if (bsearch(name, kDestinationControlWords,
			sizeof(kDestinationControlWords) / sizeof(kDestinationControlWords[0]),
			sizeof(kDestinationControlWords[0]),
			(int (*)(const void *, const void *))string_array_compare) != NULL)
		fDestination = OTHER_DESTINATION;
}


group_destination
Group::Destination() const
{
	return fDestination;
}


//	#pragma mark -


Header::Header()
	:
	fVersion(0)
{
}


Header::~Header()
{
}


void
Header::Parse(char first, BDataIO &stream, char &last)
{
	// The stream has been peeked into by the parser already, and
	// only the version follows in the stream -- let's pick it up

	fVersion = parse_integer(first, stream, last);

	// recreate "rtf" command to name this group

	Command *command = new Command();
	command->SetName("rtf");
	command->SetOption(fVersion);

	AddElement(command);
}


int32
Header::Version() const
{
	return fVersion;
}


const char *
Header::Charset() const
{
	Command *command = dynamic_cast<Command *>(ElementAt(1));
	if (command == NULL)
		return NULL;

	return command->Name();
}


rgb_color
Header::Color(int32 index)
{
	rgb_color color = {0, 0, 0, 255};

	Group *colorTable = FindGroup("colortbl");

	if (colorTable != NULL) {
		if (Command *gun = colorTable->FindDefinition("red", index))
			color.red = gun->Option();
		if (Command *gun = colorTable->FindDefinition("green", index))
			color.green = gun->Option();
		if (Command *gun = colorTable->FindDefinition("blue", index))
			color.blue = gun->Option();
	}

	return color;
}


//	#pragma mark -


Text::Text()
{
}


Text::~Text()
{
	SetTo(NULL);
}


bool
Text::IsDefinitionDelimiter()
{
	return fText == ";";
}


void
Text::Parse(char first, BDataIO &stream, char &last)
{
	char c = first;
	if (c == '\0')
		c = read_char(stream);

	if (c == ';') {
		// definition delimiter
		fText.SetTo(";");
		last = read_char(stream);
		return;
	}

	const size_t kBufferSteps = 1;
	size_t maxSize = kBufferSteps;
	char *text = fText.LockBuffer(maxSize);
	if (text == NULL)
		throw (status_t)B_NO_MEMORY;

	size_t position = 0;

	while (true) {
		if (c == '\\' || c == '}' || c == '{' || c == ';' || c == '\n' || c == '\r')
			break;

		if (position >= maxSize) {
			fText.UnlockBuffer(position);
			text = fText.LockBuffer(maxSize += kBufferSteps);
			if (text == NULL)
				throw (status_t)B_NO_MEMORY;
		}

		text[position++] = c;

		c = read_char(stream);
	}
	fText.UnlockBuffer(position);

	// ToDo: add support for different charsets - right now, only ASCII is supported!
	//	To achieve this, we should just translate everything into UTF-8 here

	last = c;
}


status_t
Text::SetTo(const char *text)
{
	return fText.SetTo(text) != NULL ? B_OK : B_NO_MEMORY;
}


const char *
Text::String() const
{
	return fText.String();
}


uint32
Text::Length() const
{
	return fText.Length();
}


//	#pragma mark -


Command::Command()
	:
	fName(NULL),
	fHasOption(false),
	fOption(-1)
{
}


Command::~Command()
{
}


void
Command::Parse(char first, BDataIO &stream, char &last)
{
	if (first == '\0')
		first = read_char(stream);

	if (first != '\\')
		throw (status_t)B_BAD_TYPE;

	// get name
	char name[kCommandLength];
	size_t length = 0;
	char c;
	while (isalpha(c = read_char(stream))) {
		name[length++] = c;
		if (length >= kCommandLength - 1)
			throw (status_t)B_BAD_TYPE;
	}

	if (length == 0) {
		if (c == '\n' || c == '\r') {
			// we're a hard return
			fName.SetTo("par");
		} else
			fName.SetTo(c, 1);

		// read over character
		c = read_char(stream);
	} else
		fName.SetTo(name, length);

	TRACE("command: %s\n", fName.String());

	// parse numeric option

	if (c == '-')
		c = read_char(stream);

	last = c;

	if (fName == "'") {
		// hexadecimal
		char bytes[2];
		bytes[0] = read_char(stream);
		bytes[1] = '\0';
		BMemoryIO memory(bytes, 2);

		SetOption(parse_integer(c, memory, last, 16));
		last = read_char(stream);
	} else {
		// decimal
		if (isdigit(c))
			SetOption(parse_integer(c, stream, last));

		// a space delimiter is eaten up by the command
		if (isspace(last))
			last = read_char(stream);
	}

	if (HasOption())
		TRACE("  option: %ld\n", fOption);
}


status_t
Command::SetName(const char *name)
{
	return fName.SetTo(name) != NULL ? B_OK : B_NO_MEMORY;
}


const char *
Command::Name()
{
	return fName.String();
}


void
Command::UnsetOption()
{
	fHasOption = false;
	fOption = -1;
}


void
Command::SetOption(int32 option)
{
	fOption = option;
	fHasOption = true;
}


bool
Command::HasOption() const
{
	return fHasOption;
}


int32
Command::Option() const
{
	return fOption;
}


//	#pragma mark -


Iterator::Iterator(Element &start, group_destination destination)
{
	SetTo(start, destination);
}


void
Iterator::SetTo(Element &start, group_destination destination)
{
	fStart = &start;
	fDestination = destination;

	Rewind();
}


void
Iterator::Rewind()
{
	fStack.MakeEmpty();
	fStack.Push(fStart);
}


bool
Iterator::HasNext() const
{
	return !fStack.IsEmpty();
}


Element *
Iterator::Next()
{
	Element *element;

	if (!fStack.Pop(&element))
		return NULL;

	Group *group = dynamic_cast<Group *>(element);
	if (group != NULL
		&& (fDestination == ALL_DESTINATIONS
			|| fDestination == group->Destination())) {
		// put this group's children on the stack in
		// reverse order, so that we iterate over
		// the tree in in-order

		for (int32 i = group->CountElements(); i-- > 0;) {
			fStack.Push(group->ElementAt(i));
		}
	}

	return element;
}


//	#pragma mark -


Worker::Worker(RTF::Header &start)
	:
	fStart(start)
{
}


Worker::~Worker()
{
}


void
Worker::Dispatch(Element *element)
{
	if (RTF::Group *group = dynamic_cast<RTF::Group *>(element)) {
		fSkip = false;
		Group(group);

		if (fSkip)
			return;

		for (int32 i = 0; (element = group->ElementAt(i)) != NULL; i++)
			Dispatch(element);

		GroupEnd(group);
	} else if (RTF::Command *command = dynamic_cast<RTF::Command *>(element)) {
		Command(command);
	} else if (RTF::Text *text = dynamic_cast<RTF::Text *>(element)) {
		Text(text);
	}
}


void
Worker::Work()
{
	Dispatch(&fStart);
}


void
Worker::Group(RTF::Group *group)
{
}


void
Worker::GroupEnd(RTF::Group *group)
{
}


void
Worker::Command(RTF::Command *command)
{
}


void
Worker::Text(RTF::Text *text)
{
}


RTF::Header &
Worker::Start()
{
	return fStart;
}


void
Worker::Skip()
{
	fSkip = true;
}


void
Worker::Abort(status_t status)
{
	throw status;
}