/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the  "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#include "XercesParserLiaison.hpp"


#include <iostream>


#include <xercesc/dom/DOMImplementation.hpp>
#include <xercesc/framework/URLInputSource.hpp>
#include <xercesc/parsers/XercesDOMParser.hpp>
#include <xercesc/parsers/SAXParser.hpp>
#include <xercesc/sax/SAXParseException.hpp>


#include <xalanc/Include/XalanAutoPtr.hpp>
#include <xalanc/Include/XalanMemMgrAutoPtr.hpp>
#include <xalanc/Include/STLHelper.hpp>


#include <xalanc/PlatformSupport/ExecutionContext.hpp>
#include <xalanc/PlatformSupport/XalanMessageLoader.hpp>
#include <xalanc/PlatformSupport/XalanUnicode.hpp>
#include <xalanc/PlatformSupport/XSLException.hpp>


#include <xalanc/DOMSupport/DOMSupport.hpp>


#if defined(XALAN_BUILD_DEPRECATED_DOM_BRIDGE)
#include <xalanc/XercesParserLiaison/Deprecated/XercesDocumentBridge.hpp>
#endif
#include <xalanc/XercesParserLiaison/XercesDocumentWrapper.hpp>
#include <xalanc/XercesParserLiaison/XercesDOMSupport.hpp>


namespace XALAN_CPP_NAMESPACE {


XercesParserLiaison::XercesParserLiaison(
            XercesDOMSupport&   /* theSupport */,
            MemoryManager&      theManager) :
    m_indent(-1),
    m_useValidation(false),
    m_includeIgnorableWhitespace(true),
    m_doNamespaces(true),
    m_exitOnFirstFatalError(true),
    m_entityResolver(0),
    m_xmlEntityResolver(0),
    m_errorHandler(this),
    m_externalSchemaLocation(theManager),
    m_externalNoNamespaceSchemaLocation(theManager),
    m_documentMap(theManager),
    m_buildWrapper(true),
    m_buildBridge(true),
    m_threadSafe(false),
    m_buildMaps(false),
    m_executionContext(0),
    m_domParser(0)
{
}


XercesParserLiaison::XercesParserLiaison(MemoryManager&     theManager) :
    m_indent(-1),
    m_useValidation(false),
    m_includeIgnorableWhitespace(true),
    m_doNamespaces(true),
    m_exitOnFirstFatalError(true),
    m_entityResolver(0),
    m_xmlEntityResolver(0),
    m_errorHandler(this),
    m_externalSchemaLocation(theManager),
    m_externalNoNamespaceSchemaLocation(theManager),
    m_documentMap(theManager),
    m_buildWrapper(true),
    m_buildBridge(true),
    m_threadSafe(false),
    m_buildMaps(false),
    m_executionContext(0),
    m_domParser(0)
{
}


XercesParserLiaison::~XercesParserLiaison()
{
    reset();

    delete m_domParser;
}


void
XercesParserLiaison::reset()
{
    // Delete any live documents...
    for(DocumentMapType::iterator i = m_documentMap.begin();
        i != m_documentMap.end();
        ++i)
    {
        if ((*i).second.isDeprecated() == false &&
            (*i).second.isOwned() == true)
        {
            delete (*i).second.m_wrapper->getXercesDocument();
        }

        XalanDocument* docToDelete = const_cast<XalanDocument*>((*i).first);

        if(docToDelete != 0)
        {
            docToDelete->~XalanDocument();

            getMemoryManager().deallocate((void*)docToDelete);
        }

    }

    m_documentMap.clear();

    m_executionContext = 0;
}


ExecutionContext*
XercesParserLiaison::getExecutionContext() const
{
    return m_executionContext;
}


void
XercesParserLiaison::setExecutionContext(ExecutionContext&  theContext)
{
    m_executionContext = &theContext;
}


void
XercesParserLiaison::ensureDOMParser()
{
    if (m_domParser == 0)
    {
        m_domParser = createDOMParser();
    }

    m_domParser->setValidationScheme(m_useValidation == true ? DOMParserType::Val_Auto : DOMParserType::Val_Never);

    m_domParser->setIncludeIgnorableWhitespace(m_includeIgnorableWhitespace);

    m_domParser->setDoNamespaces(m_doNamespaces);

    m_domParser->setExitOnFirstFatalError(m_exitOnFirstFatalError);

    if (m_entityResolver != 0)
    {
        m_domParser->setEntityResolver(m_entityResolver);
    }
    else
    {
        m_domParser->setXMLEntityResolver(m_xmlEntityResolver);
    }

    m_domParser->setErrorHandler(m_errorHandler);

    if (m_externalSchemaLocation.length() > 0)
    {
        m_domParser->setExternalSchemaLocation(m_externalSchemaLocation.c_str());
    }

    if (m_externalNoNamespaceSchemaLocation.length() > 0)
    {
        m_domParser->setExternalNoNamespaceSchemaLocation(m_externalNoNamespaceSchemaLocation.c_str());
    }
}


void
XercesParserLiaison::parseXMLStream(
            const InputSource&      inputSource,
            DocumentHandler&        handler,
            const XalanDOMString&   /* identifier */)
{
    XalanAutoPtr<SAXParserType>     theParser(createSAXParser());

    theParser->setExitOnFirstFatalError(m_exitOnFirstFatalError);

    if (m_entityResolver != 0)
    {
        theParser->setEntityResolver(m_entityResolver);
    }
    else
    {
        theParser->setXMLEntityResolver(m_xmlEntityResolver);
    }

    theParser->setErrorHandler(m_errorHandler);

    theParser->setDocumentHandler(&handler);

    theParser->parse(inputSource);
}


XalanDocument*
XercesParserLiaison::parseXMLStream(
            const InputSource&      inputSource,
            const XalanDOMString&   /* identifier */)
{
    ensureDOMParser();

    m_domParser->parse(inputSource);

    DOMDocument_Type* const theXercesDocument =
        m_domParser->getDocument();

    theXercesDocument->normalize();

    XercesDocumentWrapper*  theNewDocument = 0;

    if (theXercesDocument != 0)
    {
        theNewDocument = doCreateDocument(theXercesDocument, m_threadSafe, m_buildWrapper, m_buildMaps, true);

        m_domParser->adoptDocument();
    }

    return theNewDocument;
}


void
XercesParserLiaison::destroyDocument(XalanDocument*     theDocument)
{
    const DocumentMapType::iterator     i =
        m_documentMap.find(theDocument);

    if (i != m_documentMap.end())
    {
        const XalanMemMgrAutoPtr<XalanDocument>     theGuard(
                                                        m_documentMap.getMemoryManager(),
                                                        theDocument);

        m_documentMap.erase(i);
    }
}


int
XercesParserLiaison::getIndent() const
{
    return m_indent;
}


void
XercesParserLiaison::setIndent(int  i)
{
    m_indent = i;
}


bool
XercesParserLiaison::getUseValidation() const
{
    return m_useValidation;
}


void
XercesParserLiaison::setUseValidation(bool  b)
{
    m_useValidation = b;
}


const XalanDOMString&
XercesParserLiaison::getParserDescription(XalanDOMString& theResult) const
{
    theResult.assign("Xerces");

    return theResult;
}


DOMDocument_Type*
XercesParserLiaison::createDOMFactory()
{
    DOMDocument_Type* const     theXercesDocument =
        DOMImplementationType::getImplementation()->createDocument();

    createDocument(theXercesDocument, false, false);
    
    return theXercesDocument;
}


void
XercesParserLiaison::destroyDocument(DOMDocument_Type*  theDocument)
{
    // Delete any live documents...
    for(DocumentMapType::iterator i = m_documentMap.begin();
        i != m_documentMap.end();
        ++i)
    {
        if ((*i).second.isDeprecated() == false &&
            (*i).second.m_wrapper->getXercesDocument() == theDocument)
        {
            destroyDocument((XalanDocument*)(*i).first);
        }
    }
}


bool
XercesParserLiaison::getIncludeIgnorableWhitespace() const
{
    return m_includeIgnorableWhitespace;
}


void
XercesParserLiaison::setIncludeIgnorableWhitespace(bool include)
{
    m_includeIgnorableWhitespace = include;
}


ErrorHandler*
XercesParserLiaison::getErrorHandler() const
{
    return m_errorHandler;
}


void
XercesParserLiaison::setErrorHandler(ErrorHandler*  handler)
{
    if (handler == 0)
    {
        m_errorHandler = this;
    }
    else
    {
        m_errorHandler = handler;
    }
}


bool
XercesParserLiaison::getDoNamespaces() const
{
    return m_doNamespaces;
}


void
XercesParserLiaison::setDoNamespaces(bool   newState)
{
    m_doNamespaces = newState;
}


bool
XercesParserLiaison::getExitOnFirstFatalError() const
{
    return m_exitOnFirstFatalError;
}


void
XercesParserLiaison::setExitOnFirstFatalError(bool  newState)
{
    m_exitOnFirstFatalError = newState;
}


EntityResolver*
XercesParserLiaison::getEntityResolver() const
{
    return m_entityResolver;
}


void
XercesParserLiaison::setEntityResolver(EntityResolver*  resolver)
{
    m_entityResolver = resolver;
}


XMLEntityResolver*
XercesParserLiaison::getXMLEntityResolver() const
{
    return m_xmlEntityResolver;
}


void
XercesParserLiaison::setXMLEntityResolver(XMLEntityResolver*  resolver)
{
    m_xmlEntityResolver = resolver;
}


const XalanDOMChar*
XercesParserLiaison::getExternalSchemaLocation() const
{
    return m_externalSchemaLocation.length() == 0 ? 0 : m_externalSchemaLocation.c_str();
}


void
XercesParserLiaison::setExternalSchemaLocation(const XalanDOMChar*  location)
{
    if (location == 0)
    {
        m_externalSchemaLocation.clear();
    }
    else
    {
        m_externalSchemaLocation = location;
    }
}


const XalanDOMChar*
XercesParserLiaison::getExternalNoNamespaceSchemaLocation() const
{
    return m_externalNoNamespaceSchemaLocation.length() == 0 ? 0 : m_externalNoNamespaceSchemaLocation.c_str();
}


void
XercesParserLiaison::setExternalNoNamespaceSchemaLocation(const XalanDOMChar*   location)
{
    if (location == 0)
    {
        m_externalNoNamespaceSchemaLocation.clear();
    }
    else
    {
        m_externalNoNamespaceSchemaLocation= location;
    }
}


#if defined(XALAN_BUILD_DEPRECATED_DOM_BRIDGE)
XalanDocument*
XercesParserLiaison::createDocument(
            const DOM_Document_Type&    theXercesDocument,
            bool                        threadSafe,
            bool                        buildBridge)
{
    return doCreateDocument(theXercesDocument, threadSafe, buildBridge);
}
#endif


XalanDocument*
XercesParserLiaison::createDocument(
            const DOMDocument_Type*     theXercesDocument,
            bool                        threadSafe,
            bool                        buildWrapper,
            bool                        buildMaps)
{
    // As we did not create the underlying DOMDocument - ensure we don't
    // delete it later.
    return doCreateDocument(theXercesDocument, threadSafe, buildWrapper, buildMaps, false);
}


#if defined(XALAN_BUILD_DEPRECATED_DOM_BRIDGE)
XercesDocumentBridge*
XercesParserLiaison::mapDocument(const XalanDocument*   theDocument) const
{
    const DocumentMapType::const_iterator   i =
        m_documentMap.find(theDocument);

    return i != m_documentMap.end() ? (*i).second.m_isDeprecated == true ? (*i).second.m_bridge : 0 : 0;
}
#endif


XercesDocumentWrapper*
XercesParserLiaison::mapDocumentToWrapper(const XalanDocument*  theDocument) const
{
    const DocumentMapType::const_iterator   i =
        m_documentMap.find(theDocument);

    return i != m_documentMap.end() ? (*i).second.isDeprecated() == false ? (*i).second.m_wrapper : 0 : 0;
}


#if defined(XALAN_BUILD_DEPRECATED_DOM_BRIDGE)
DOM_Document_Type
XercesParserLiaison::mapXercesDocument(const XalanDocument*     theDocument) const
{
    const DocumentMapType::const_iterator   i =
        m_documentMap.find(theDocument);

    return i != m_documentMap.end() ? (*i).second.isDeprecated() == true ? (*i).second.m_bridge->getXercesDocument() : DOM_Document_Type() : DOM_Document_Type();
}
#endif


const DOMDocument_Type*
XercesParserLiaison::mapToXercesDocument(const XalanDocument*   theDocument) const
{
    const DocumentMapType::const_iterator   i =
        m_documentMap.find(theDocument);

    return i != m_documentMap.end() ? (*i).second.isDeprecated() == false ? (*i).second.m_wrapper->getXercesDocument() : 0 : 0;
}


void
XercesParserLiaison::fatalError(const SAXParseExceptionType&    e)
{
    XalanDOMString  theMessage(getMemoryManager());
    
    XalanMessageLoader::getMessage(
        theMessage,
        XalanMessages::FatalError);

    formatErrorMessage(e, theMessage);

    if (m_executionContext != 0)
    {
        // We call warning() because we don't want the execution
        // context to potentially throw an exception.
        m_executionContext->problem(
            ExecutionContext::eXMLParser,
            ExecutionContext::eWarning,
            theMessage,
            0);
    }
    else
    {
        using std::cerr;
        using std::endl;

        cerr << endl << theMessage << endl;
    }

    throw e;
}


void
XercesParserLiaison::error(const SAXParseExceptionType&     e)
{
    XalanDOMString  theMessage(getMemoryManager());

    XalanMessageLoader::getMessage(
        theMessage,
        XalanMessages::Error2);

    formatErrorMessage(e, theMessage);

    if (m_executionContext != 0)
    {
        // We call warn() because we don't want the execution
        // context to potentially throw an exception.
        m_executionContext->problem(
            ExecutionContext::eXMLParser,
            ExecutionContext::eWarning,
            theMessage,
            0);
    }
    else
    {
        using std::cerr;
        using std::endl;

        cerr << endl << theMessage << endl;
    }

    if (m_useValidation == true)
    {
        throw e;
    }
}


void
XercesParserLiaison::warning(const SAXParseExceptionType&   e)
{
    XalanDOMString  theMessage(getMemoryManager());

    XalanMessageLoader::getMessage(
        theMessage,
        XalanMessages::Warning2);

    formatErrorMessage(e, theMessage);

    if (m_executionContext != 0)
    {
        m_executionContext->problem(
            ExecutionContext::eXMLParser,
            ExecutionContext::eWarning,
            theMessage,
            0);
    }
    else
    {
        using std::cerr;
        using std::endl;

        cerr << endl << theMessage << endl;
    }
}


void
XercesParserLiaison::formatErrorMessage(
            const SAXParseExceptionType&    e,
            XalanDOMString&                 theMessage)
{
    XalanDOMString  theErrorBuffer(theMessage.getMemoryManager());

    const XalanDOMChar* const   theExceptionMessage = e.getMessage();
    assert(theExceptionMessage != 0);

    const XalanDOMChar* const   theSystemID = e.getSystemId();

    XSLException::defaultFormat(
        theExceptionMessage,
        length(theExceptionMessage),
        theSystemID,
        theSystemID == 0 ? 0 : length(theSystemID),
        e.getLineNumber(),
        e.getColumnNumber(),
        0,
        0,
        theMessage);
}


void
XercesParserLiaison::resetErrors()
{
}


XercesParserLiaison::DOMParserType*
XercesParserLiaison::createDOMParser()
{
    MemoryManager&  theMemoryManager =
        getMemoryManager();

    DOMParserType* const    theParser =
        new (&theMemoryManager) DOMParserType(0, &theMemoryManager);

#if XERCES_VERSION_MAJOR < 3
    theParser->setExpandEntityReferences(true);
#else
    theParser->setCreateEntityReferenceNodes(false);
#endif

    theParser->setDoNamespaces(m_doNamespaces);

    return theParser;
}


XercesParserLiaison::SAXParserType*
XercesParserLiaison::createSAXParser()
{
    MemoryManager&  theMemoryManager =
        getMemoryManager();

    SAXParserType* const    theParser =
        new (&theMemoryManager) SAXParserType(0, &theMemoryManager);

#if XERCES_VERSION_MAJOR < 3
    theParser->setDoValidation(false);
#else
    theParser->setValidationScheme(SAXParserType::Val_Never);
#endif

    theParser->setDoNamespaces(false);

    return theParser;
}


#if defined(XALAN_BUILD_DEPRECATED_DOM_BRIDGE)
XercesDocumentBridge*
XercesParserLiaison::doCreateDocument(
            const DOM_Document_Type&    theXercesDocument,
            bool                        threadSafe,
            bool                        buildBridge)
{
    XercesDocumentBridge* const     theNewDocument =
        new XercesDocumentBridge(theXercesDocument, threadSafe, buildBridge);

    m_documentMap[theNewDocument] = theNewDocument;

    return theNewDocument;
}
#endif


XercesDocumentWrapper*
XercesParserLiaison::doCreateDocument(
            const DOMDocument_Type*     theXercesDocument,
            bool                        threadSafe,
            bool                        buildWrapper,
            bool                        buildMaps,
            bool                        isOwned)
{
    XercesDocumentWrapper* const        theNewDocument =
        XercesDocumentWrapper::create(getMemoryManager(),theXercesDocument, threadSafe, buildWrapper, buildMaps);

    DocumentEntry&  theEntry = m_documentMap[theNewDocument];
    
    theEntry = theNewDocument;
    theEntry.m_isOwned = isOwned;

    return theNewDocument;
}


}