/*
 * Copyright (c) 1999-2000, Eric Moon.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions, and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions, and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */


// Importer.cpp
// e.moon 28jun99

#include "Importer.h"
#include <stdexcept>

#include <Autolock.h>
#include <Debug.h>

using namespace std;

__USE_CORTEX_NAMESPACE

// -------------------------------------------------------- //
// expat hooks
// -------------------------------------------------------- //

void _oc_handle_start(
        void* pUser,
        const XML_Char* pName,
        const XML_Char** ppAtts) {
        ((Importer*)pUser)->xmlElementStart(pName, ppAtts);     
}

void _oc_handle_end(
        void* pUser,
        const XML_Char* pName) {
        ((Importer*)pUser)->xmlElementEnd(pName);
}

void _oc_handle_pi(
        void* pUser,
        const XML_Char* pTarget,
        const XML_Char* pData) {
        ((Importer*)pUser)->xmlProcessingInstruction(pTarget, pData);
}

void _oc_handle_char(
        void* pUser,
        const XML_Char* pData,
        int length) {
        ((Importer*)pUser)->xmlCharacterData(pData, length);
}

void _oc_handle_default(
        void* pUser,
        const XML_Char* pData,
        int length) {
        ((Importer*)pUser)->xmlDefaultData(pData, length);
}

// -------------------------------------------------------- //
// ctor/dtor
// -------------------------------------------------------- //

Importer::~Importer() {
        // clean up
        freeParser();

        delete m_context;
}


Importer::Importer(
        list<BString>&                                                  errors) :

        m_parser(0),
        m_docType(0),
        m_identify(false),
        m_context(new ImportContext(errors)),
        m_rootObject(0) {
        
        initParser();
}

Importer::Importer(
        ImportContext*                                                  context) :

        m_parser(0),
        m_docType(0),
        m_identify(false),
        m_context(context),
        m_rootObject(0) {
        
        ASSERT(m_context);
        
        initParser();
}

Importer::Importer(
        list<BString>&                                                  errors,
        IPersistent*                                                            rootObject,
        XML::DocumentType*                                      docType) :

        m_parser(0),
        m_docType(docType),
        m_identify(false),
        m_context(new ImportContext(errors)),
        m_rootObject(rootObject) {

        ASSERT(rootObject);
        ASSERT(docType);

        initParser();
}

Importer::Importer(
        ImportContext*                                                  context,
        IPersistent*                                                            rootObject,
        XML::DocumentType*                                      docType) :

        m_parser(0),
        m_docType(docType),
        m_identify(false),
        m_context(context),
        m_rootObject(rootObject) {

        ASSERT(m_context);
        ASSERT(rootObject);
        ASSERT(docType);

        initParser();
}
                
// -------------------------------------------------------- //
// accessors
// -------------------------------------------------------- //

// the import context
const ImportContext& Importer::context() const {
        return *m_context;
}

// matched (or provided) document type
XML::DocumentType* Importer::docType() const {
        return m_docType;
}

// completed object (available if
// context().state() == ImportContext::COMPLETE, or
// if a root object was provided to the ctor)
IPersistent* Importer::target() const {
        return m_rootObject;
}
                
// -------------------------------------------------------- //
// operations
// -------------------------------------------------------- //

// put the importer into 'identify mode'
// (disengaged once the first element is encountered)
void Importer::setIdentifyMode() {
        reset();
        m_docType = 0;
        m_identify = true;
}

void Importer::reset() {
        // doesn't forget document type from identify cycle!
                
        m_identify = false;
        m_context->reset();
        m_rootObject = 0;
}

// handle a buffer; return false if an error occurs
bool Importer::parseBuffer(
        const char* pBuffer,
        uint32 length,
        bool last) {

        ASSERT(m_parser);

        int err = XML_Parse(m_parser, pBuffer, length, last);
                
        if(!err) {
                BString str = "Parse Error: ";
                str << XML_ErrorString(XML_GetErrorCode(m_parser));
                m_context->reportError(str.String());
                return false;

        } else
                return true;
}
        
// -------------------------------------------------------- //
// internal operations
// -------------------------------------------------------- //

// create & initialize parser
void Importer::initParser() {
        ASSERT(!m_parser);
        m_parser = XML_ParserCreate(0);
        m_context->m_pParser = m_parser;
        
        XML_SetElementHandler(
                m_parser,
                &_oc_handle_start,
                &_oc_handle_end);
        
        XML_SetProcessingInstructionHandler(
                m_parser,
                &_oc_handle_pi);

        XML_SetCharacterDataHandler(
                m_parser,
                &_oc_handle_char);
                
        XML_SetDefaultHandlerExpand(
                m_parser,
                &_oc_handle_default);
                
        XML_SetUserData(
                m_parser,
                (void*)this);   
}
        
// clean up the parser
void Importer::freeParser() {
        ASSERT(m_parser);
        XML_ParserFree(m_parser);
        m_parser = 0;
}

// -------------------------------------------------------- //
// XML parser event hooks
// -------------------------------------------------------- //

void Importer::xmlElementStart(
        const char*                     pName,
        const char**            ppAttributes) {

        if(m_context->m_state != ImportContext::PARSING)
                return;

        IPersistent* target = 0;

        if(!m_context->m_elementStack.size()) {
                // this is the first element; identify or verify document type
                
                if(m_rootObject) {
                        // test against expected document type
                        ASSERT(m_docType);
                        if(m_docType->rootElement != pName) {
                                BString err("Unexpected document element (should be <");
                                err << m_docType->rootElement << "/>";
                                m_context->reportError(err.String());
                                return;
                        }
                        
                        // target the provided root object
                        target = m_rootObject;
                }
                else {
                        // look up doc type
                        BAutolock _l(XML::s_docTypeLock);
                        XML::doc_type_map::iterator it = XML::s_docTypeMap.find(
                                BString(pName));
                
                        if(it != XML::s_docTypeMap.end())
                                m_docType = (*it).second;
                        else {
                                // whoops, don't know how to handle this element:
                                BString err("No document type registered for element '");
                                err << pName << "'.";
                                m_context->reportError(err.String());
                                return;
                        }
                                
                        if(m_identify) {
                                // end of identify cycle
                                m_context->m_state = ImportContext::COMPLETE;
                                return;
                        }
                }
        }
        // at this point, there'd better be a valid document type
        ASSERT(m_docType);      
        
        // push element name onto the stack
        m_context->m_elementStack.push_back(pName);

        // try to create an object for this element if necessary
        if(!target)
                target = m_docType->objectFor(pName);   
        
        if(target) {
                // call 'begin import' hook
                m_context->m_objectStack.push_back(
                        make_pair(m_context->element(), target));
                target->xmlImportBegin(*m_context);
                
                // error? bail
                if(m_context->state() != ImportContext::PARSING)
                        return;
        
                // walk attributes
                while(*ppAttributes) {
                        target->xmlImportAttribute(     
                                ppAttributes[0],
                                ppAttributes[1],
                                *m_context);

                        // error? bail
                        if(m_context->state() != ImportContext::PARSING)
                                return;
                        
                        ppAttributes += 2;
                }
        } else {
                // no object directly maps to this element; hand to
                // the current focus object

                ASSERT(m_context->m_objectStack.size());
                IPersistent* curObject = m_context->m_objectStack.back().second;
                ASSERT(curObject);
                
                curObject->xmlImportChildBegin(
                        pName,
                        *m_context);

                // error? bail
                if(m_context->state() != ImportContext::PARSING)
                        return;

                // walk attributes
                while(*ppAttributes) {
                        curObject->xmlImportChildAttribute(     
                                ppAttributes[0],
                                ppAttributes[1],
                                *m_context);

                        // error? bail
                        if(m_context->state() != ImportContext::PARSING)
                                return;
                        
                        ppAttributes += 2;
                }
        }
}
                
void Importer::xmlElementEnd(
        const char*                     pName) {

        if(m_context->m_state != ImportContext::PARSING)
                return;
        ASSERT(m_docType);

//      PRINT(("Importer::xmlElementEnd(): %s\n", pName));

        // compare name to element on top of stack
        if(!m_context->m_elementStack.size() ||
                m_context->m_elementStack.back() != pName) {
                m_context->reportError("Mismatched end tag.");
                return;
        }

        // see if it matches the topmost object
        IPersistent* pObject = 0;
        if(!m_context->m_objectStack.size()) {
                m_context->reportError("No object being constructed.");
                return;
        }
        if(m_context->m_objectStack.back().first == m_context->element()) {
                // matched; pop it
                pObject = m_context->m_objectStack.back().second;
                m_context->m_objectStack.pop_back();
        }

        if(pObject) {
                // notify object that import is complete
                pObject->xmlImportComplete(
                        *m_context);
                
                // error? bail
                if(m_context->state() != ImportContext::PARSING)
                        return;

                if(m_context->m_objectStack.size()) {
                        // hand the newly-constructed child to its parent
                        m_context->m_objectStack.back().second->xmlImportChild(
                                pObject,
                                *m_context);
                } else {
                        // done
                        ASSERT(m_context->m_elementStack.size() == 1);
                        m_context->m_state = ImportContext::COMPLETE;
                        if(m_rootObject) {
                                ASSERT(m_rootObject == pObject);
                        } else
                                m_rootObject = pObject;
                }
        }
        else {
                // notify current topmost object
                ASSERT(m_context->m_objectStack.size());
                IPersistent* curObject = m_context->m_objectStack.back().second;
                ASSERT(curObject);
                
                curObject->xmlImportChildComplete(
                        pName,
                        *m_context);
        }
        
        // remove entry from element stack
        m_context->m_elementStack.pop_back();
        ASSERT(m_context->m_objectStack.size() <= m_context->m_elementStack.size());
}
        
void Importer::xmlProcessingInstruction(
        const char*                     pTarget,
        const char*                     pData) {

        if(m_context->m_state != ImportContext::PARSING)
                return;
//      PRINT(("Importer::xmlProcessingInstruction(): %s, %s\n",
//              pTarget, pData));
        
}

// not 0-terminated
void Importer::xmlCharacterData(
        const char*                     pData,
        int32                                   length) {

        if(m_context->m_state != ImportContext::PARSING)
                return;

        // see if the current element matches the topmost object
        IPersistent* pObject = 0;
        if(!m_context->m_objectStack.size()) {
                m_context->reportError("No object being constructed.");
                return;
        }

        pObject = m_context->m_objectStack.back().second;
        if(m_context->m_objectStack.back().first == m_context->element()) {
                
                pObject->xmlImportContent(
                        pData,
                        length,
                        *m_context);
        }
        else {
                pObject->xmlImportChildContent(
                        pData,
                        length,
                        *m_context);
        }
}
                
// not 0-terminated
void Importer::xmlDefaultData(
        const char*                     pData,
        int32                                   length) {
        
        if(m_context->m_state != ImportContext::PARSING)
                return;
//      PRINT(("Importer::xmlDefaultData()\n"));
}
                
// END -- Importer.cpp --