/*
 * Oreka -- A media capture and retrieval platform
 * 
 * Copyright (C) 2005, orecx LLC
 *
 * http://www.orecx.com
 *
 * This program is free software, distributed under the terms of
 * the GNU General Public License.
 * Please refer to http://www.gnu.org/copyleft/gpl.html
 *
 */

#include "xercesc/util/XMLString.hpp"
#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/dom/DOM.hpp>
#include <xercesc/dom/DOMElement.hpp>
#include <xercesc/dom/DOMImplementation.hpp>
#include <xercesc/dom/DOMImplementationLS.hpp>
#include <xercesc/dom/DOMWriter.hpp>
#include <xercesc/framework/MemBufFormatTarget.hpp>

#include "DomSerializer.h"

void DomSerializer::ObjectValue(const char* key, Object& value, bool required)
{
	if (m_deSerialize == true)
	{
		GetObject(key, value, required);
	}
	else
	{
		AddObject(key, value);
	}
}

void DomSerializer::GetString(const char* key, CStdString& value, bool required)
{
	// Find the right node
	DOMNode* stringNode = FindElementByName(m_node, CStdString(key));

	if(stringNode)
	{
		// Now, the string associated to element should be the first child (text element)
		DOMNode* textNode = stringNode->getFirstChild();
		if (textNode && textNode->getNodeType() == DOMNode::TEXT_NODE)
		{
			value = XMLStringToLocal(textNode->getNodeValue());
		}
	}
	else if (required)
	{
		throw(CStdString("DomSerializer::GetString: required parameter missing:") + key);
	}
}

void DomSerializer::GetObject(const char* key, Object& value, bool required)
{
	// Find the node corresponding to the object wanting to be populated
	DOMNode* objectNode = FindElementByName(m_node, CStdString(key));

	// Create a new serializer and affect it to this object
	if (objectNode)
	{
		DomSerializer serializer(&value);
		serializer.DeSerialize(objectNode);
	}
	else if (required)
	{
		throw(CStdString("DomSerializer::GetObject: required node missing:") + key);
	}
}

void DomSerializer::AddObject(const char* key, Object& value)
{
	;
}

void DomSerializer::AddString(const char* key, CStdString& value)
{
	DOMElement*  newElem = m_document->createElement(XStr(key).unicodeForm());
	m_node->appendChild(newElem);

	DOMText*    newText = m_document->createTextNode(XStr((PCSTR)value).unicodeForm());
	newElem->appendChild(newText);
}

void DomSerializer::Serialize(XERCES_CPP_NAMESPACE::DOMDocument* doc)
{
	if(doc)
	{
		m_document = doc;
		m_node = m_document->getDocumentElement();
		m_deSerialize = false;		// Set Serialize mode
		m_object->Define(this);
	}
	else
	{
		throw(CStdString("DomSerializer::Serialize: input DOM document is NULL"));
	}
}

void DomSerializer::DeSerialize(DOMNode* node)
{
	m_node = node;
	m_deSerialize = true;		// Set DeSerialize mode
	m_object->Define(this);
	m_object->Validate();
}

CStdString DomSerializer::XMLStringToLocal(const XMLCh* const toTranscode)
{
	char* szResult = XMLString::transcode(toTranscode);
	CStdString result = szResult;
	XMLString::release(&szResult);
	return result;
}

DOMNode* DomSerializer::FindElementByName(DOMNode *node, CStdString name)
{
	DOMNode *child = node->getFirstChild();
	while(child)
	{
		if (XMLStringToLocal(child->getNodeName()) == name && child->getNodeType() == DOMNode::ELEMENT_NODE)
		{
			return child;
		}
		child = child->getNextSibling();
	}
	return NULL;
}

CStdString DomSerializer::DomNodeToString(DOMNode* node)
{
	CStdString output;

    DOMImplementation *impl          = DOMImplementationRegistry::getDOMImplementation(XStr("LS").unicodeForm());
    DOMWriter         *theSerializer = ((DOMImplementationLS*)impl)->createDOMWriter();
    // set user specified output encoding
    //theSerializer->setEncoding(gOutputEncoding);
	theSerializer->setFeature(XStr("format-pretty-print").unicodeForm(), true); 

    XMLFormatTarget *myFormTarget;
	myFormTarget = new MemBufFormatTarget ();
    theSerializer->writeNode(myFormTarget, *node);

	output = (char *)((MemBufFormatTarget*)myFormTarget)->getRawBuffer();

	// Clean up
    delete theSerializer;
    //
    // Filter, formatTarget and error handler
    // are NOT owned by the serializer.
    delete myFormTarget;

	return output;
}