#include <stdio.h>
#include <xercesc/parsers/XercesDOMParser.hpp>
#include <xercesc/dom/DOM.hpp>
#include <xercesc/dom/DOMNode.hpp>
#include <xercesc/util/XMLString.hpp>
#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/sax/HandlerBase.hpp>
#include <xercesc/framework/LocalFileFormatTarget.hpp>

#include "DOMPrintFilter.hpp"

XERCES_CPP_NAMESPACE_USE

//-----------------------------------------------------------------
void traceNode(DOMElement& root,int depth);
int saveXML(DOMNode* node,char* filename);
//-----------------------------------------------------------------
/** XMLCh to char **/
class Char2X{
    XMLCh* fUnicodeForm;
public:
    Char2X(const char* const toTranscode){ fUnicodeForm = XMLString::transcode(toTranscode); }
    ~Char2X(){ delete [] fUnicodeForm; }
    const XMLCh* unicodeForm() const{ return fUnicodeForm; }
};

/** char to XMLCh **/
class X2Char{
    char* fcharForm;
public:
    X2Char(const XMLCh* const toTranscode){ fcharForm = XMLString::transcode(toTranscode); }
    ~X2Char(){ delete [] fcharForm; }
    const char* charForm() const{ return fcharForm; }
};

#define C2X(str) Char2X(str).unicodeForm()
#define X2C(str) X2Char(str).charForm()
//-----------------------------------------------------------------
class SimpleErrorHandler : public DOMErrorHandler
{
public:
    bool handleError(const DOMError& domError)
    {
        printf("%s, line %s, char %s: %s\n",
               X2C(domError.getLocation()->getURI()),
               (char*)domError.getLocation()->getLineNumber(),
               (char*)domError.getLocation()->getColumnNumber(),
               X2C(domError.getMessage()));
        return domError.getSeverity() != DOMError::DOM_SEVERITY_FATAL_ERROR;
    }
};
//-----------------------------------------------------------------

int main(int argc,char* args[])
{
    try {
        XMLPlatformUtils::Initialize();
    }
    catch(const XMLException& e) {
        char* message = XMLString::transcode(e.getMessage());
        fprintf(stderr,"Error during initialization! : %s\n",message);
        XMLString::release(&message);
        return 1;
    }

    XercesDOMParser* parser = new XercesDOMParser();
    parser->setValidationScheme(XercesDOMParser::Val_Always); // optional
    parser->setDoNamespaces(true); // optional
    
    ErrorHandler* errHandler = (ErrorHandler*) new HandlerBase();
    parser->setErrorHandler(errHandler);
    
    char* xmlFile = "input.xml";

    try {
        parser->parse(xmlFile);
        
        DOMDocument* doc = parser->getDocument();
        DOMElement* root = doc->getDocumentElement();
        
        // trace and show node
        traceNode(*root,0);
        // copy node    
        saveXML((DOMNode*)root,"output.xml");
        
    } catch(const XMLException& e) {
        char* message = XMLString::transcode(e.getMessage());
        fprintf(stderr,"Exception message is: %s\n",message);
        XMLString::release(&message);
        return -1;
    } catch(const DOMException& e) {
        char* message = XMLString::transcode(e.msg);
        fprintf(stderr,"Exception message is: %s\n",message);
        XMLString::release(&message);
        return -1;
    } catch(...) {
        fprintf(stderr,"Unexpected Exception\n");
        return -1;
    }

    delete parser;
    delete errHandler;

    XMLPlatformUtils::Terminate();
    
    return 0;
}

// trace and show node
void traceNode(DOMElement& root,int depth){
    DOMNodeList* n1 = root.getChildNodes();
    if(depth == 0){
        DOMNode* r = (DOMNode*)&root;
        char *name = XMLString::transcode(r->getNodeName());
        printf("**%s\n",name);
        XMLString::release(&name);
    }
    for(int i=0;i<(signed)n1->getLength();i++){
        DOMElement* c1 = (DOMElement*)n1->item(i);
        if(((DOMNode*)c1)->getNodeType() == c1->ELEMENT_NODE){
            traceNode(*c1,depth+1);
        } else if(((DOMNode*)c1)->getNodeType() == c1->TEXT_NODE){
            DOMNode* r = c1->getParentNode();
            char *snode = XMLString::transcode(r->getNodeName());
            char *value = XMLString::transcode(c1->getTextContent());
            if(value[0] != '\n'){
                printf("%d> %s:\t%s\n",depth,snode,value);
            }
            XMLString::release(&snode);
            XMLString::release(&value);
        }
    }
}

// from xml.apache.org/xerces-c: dom serialize
int saveXML(DOMNode* node,char* filename)
{
    XMLCh tempStr[100];
    XMLString::transcode("LS",tempStr,99);
    DOMImplementation *impl = DOMImplementationRegistry::getDOMImplementation(tempStr);
    DOMWriter* theSerializer = ((DOMImplementationLS*)impl)->createDOMWriter();

    // optionally you can set some features on this serializer
    if(theSerializer->canSetFeature(XMLUni::fgDOMWRTDiscardDefaultContent,true))
        theSerializer->setFeature(XMLUni::fgDOMWRTDiscardDefaultContent,true);

    if(theSerializer->canSetFeature(XMLUni::fgDOMWRTFormatPrettyPrint,true))
        theSerializer->setFeature(XMLUni::fgDOMWRTFormatPrettyPrint,true);

    // writer filter
    DOMWriterFilter* myFilter = new DOMPrintFilter();
    theSerializer->setFilter(myFilter);
    
    // error handler
    DOMErrorHandler* errHandler = new SimpleErrorHandler();
    theSerializer->setErrorHandler(errHandler);
    
    // StdOutFormatTarget prints the resultant XML stream
    // to stdout once it receives any thing from the serializer.
    XMLFormatTarget* myFormatTarget = new LocalFileFormatTarget(filename);

    try { // serialization
        theSerializer->writeNode(myFormatTarget,*node);
    } catch(const XMLException& e) {
        char* message = XMLString::transcode(e.getMessage());
        fprintf(stderr,"Exception message is: %s\n",message);
        XMLString::release(&message);
        return -1;
    } catch(const DOMException& toCatch) {
        char* message = XMLString::transcode(toCatch.msg);
        fprintf(stderr,"Exception message is: %s\n",message);
        XMLString::release(&message);
        return -1;
    } catch(...) {
        fprintf(stderr,"Unexpected Exception\n");
        return -1;
    }
    
    theSerializer->release();
    delete errHandler;
    delete myFilter;
    delete myFormatTarget;
    return 0;
}