/*
 * 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.
 */


// MessageIO.cpp

#include "MessageIO.h"

#include <BeBuild.h>
#include <Debug.h>

#include <cstdlib>
#include <cstring>
#include <cctype>

#include <vector>
#include <utility>

using namespace std;

__USE_CORTEX_NAMESPACE

// -------------------------------------------------------- //
// constants
// -------------------------------------------------------- //

const char* const MessageIO::s_element = "BMessage";

const char* _boolEl                     = "bool";
const char* _int8El                     = "int8";
const char* _int16El            = "int16";
const char* _int32El            = "int32";
const char* _int64El            = "int64";
const char* _floatEl            = "float";
const char* _doubleEl           = "double";
const char* _stringEl           = "string";
const char* _pointEl            = "point";
const char* _rectEl                     = "rect";

// -------------------------------------------------------- //
// *** ctor/dtor/accessor
// -------------------------------------------------------- //

MessageIO::~MessageIO() {
        if(m_ownMessage && m_message)
                delete m_message;
}

MessageIO::MessageIO() :
        m_ownMessage(true),
        m_message(0) {}

// When given a message to export, this object does NOT take
// responsibility for deleting it.  It will, however, handle
// deletion of an imported BMessage.  

MessageIO::MessageIO(
        const BMessage*                                         message) :
        m_ownMessage(false),
        m_message(const_cast<BMessage*>(message)) {
        
        ASSERT(m_message);
}

void MessageIO::setMessage(
        BMessage*                                                                       message) {

        if(m_ownMessage && m_message)
                delete m_message;
        m_ownMessage = false;
        m_message = message;

        ASSERT(m_message);
}

// -------------------------------------------------------- //
// *** static setup method
// -------------------------------------------------------- //
// call this method to install hooks for the tags needed by
// MessageIO into the given document type

/*static*/
void MessageIO::AddTo(
        XML::DocumentType*                              docType) {

        docType->addMapping(new Mapping<MessageIO>(s_element));
}

// -------------------------------------------------------- //
// EXPORT:
// -------------------------------------------------------- //

void MessageIO::xmlExportBegin(
        ExportContext&                                          context) const {

        if(!m_message) {
                context.reportError("No message data to export.\n");
                return;
        }
        context.beginElement(s_element);
}
        
void MessageIO::xmlExportAttributes(
        ExportContext&                                          context) const {
        
        if(m_message->what)
                context.writeAttr("what", m_message->what);
        if(m_name.Length())
                context.writeAttr("name", m_name.String());
}

void MessageIO::xmlExportContent(
        ExportContext&                                          context) const {


        ASSERT(m_message);
        status_t err;

        // +++++ the approach:
        // 1) build a list of field names
        // 2) export fields sorted first by index, then name    
        
        typedef vector<BString> field_set;
        field_set fields;
        
#ifdef B_BEOS_VERSION_DANO
        const 
#endif
        char* name;
        type_code type;
        int32 count;
        for(
                int32 n = 0;
                m_message->GetInfo(B_ANY_TYPE, n, &name, &type, &count) == B_OK;
                ++n) {  
                fields.push_back(name); 
        }
        
        if(!fields.size())
                return;
                
        context.beginContent();

        bool done = false;
        for(int32 n = 0; !done; ++n) {
        
                done = true;

                for(
                        uint32 fieldIndex = 0;
                        fieldIndex < fields.size();
                        ++fieldIndex) {
                        
                        if(m_message->GetInfo(
                                fields[fieldIndex].String(),
                                &type,
                                &count) < B_OK || n >= count)
                                continue;

                        // found a field at the current index, so don't give up
                        done = false;
                        
                        err = _exportField(
                                context,
                                m_message,
                                type,
                                fields[fieldIndex].String(),
                                n);
                                
                        if(err < B_OK) {
                                BString errText;
                                errText << "Couldn't export field '" << fields[fieldIndex] <<
                                        "' index " << n << ": " << strerror(err) << "\n";
                                context.reportError(errText.String());
                                return;
                        }
                }
        }
}

void MessageIO::xmlExportEnd(
        ExportContext&                                          context) const {
        context.endElement();
}


// -------------------------------------------------------- //
// IMPORT:
// -------------------------------------------------------- //

void MessageIO::xmlImportBegin(
        ImportContext&                                          context) {

        // create the message
        if(m_message) {
                if(m_ownMessage)
                        delete m_message;
        }
        m_message = new BMessage();
        m_name.SetTo("");
}

void MessageIO::xmlImportAttribute(
        const char*                                                             key,
        const char*                                                             value,
        ImportContext&                                          context) {
        
        ASSERT(m_message);
        
        if(!strcmp(key, "what"))
                m_message->what = atol(value);
        else if(!strcmp(key, "name"))
                m_name.SetTo(value);
}

void MessageIO::xmlImportContent(
        const char*                                                             data,
        uint32                                                                          length,
        ImportContext&                                          context) {}

void MessageIO::xmlImportChild(
        IPersistent*                                                    child,
        ImportContext&                                          context) {
        
        ASSERT(m_message);
        
        if(strcmp(context.element(), s_element) != 0) {
                context.reportError("Unexpected child element.\n");
                return;
        }

        MessageIO* childMessageIO = dynamic_cast<MessageIO*>(child);
        ASSERT(childMessageIO);
        
        m_message->AddMessage(
                childMessageIO->m_name.String(),
                childMessageIO->m_message);
}
                
void MessageIO::xmlImportComplete(
        ImportContext&                                          context) {}
        
void MessageIO::xmlImportChildBegin(
        const char*                                                             name,
        ImportContext&                                          context) {

        // sanity checks
        
        ASSERT(m_message);
        
        if(strcmp(context.parentElement(), s_element) != 0) {
                context.reportError("Unexpected parent element.\n");
                return;
        }
        
        if(!_isValidMessageElement(context.element())) {
                context.reportError("Invalid message field element.\n");
                return;
        }
        
        m_fieldData.SetTo("");
}

void MessageIO::xmlImportChildAttribute(
        const char*                                                             key,
        const char*                                                             value,
        ImportContext&                                          context) {
        
        if(!strcmp(key, "name"))
                m_fieldName.SetTo(value);
        if(!strcmp(key, "value"))
                m_fieldData.SetTo(value);
}

void MessageIO::xmlImportChildContent(
        const char*                                                             data,
        uint32                                                                          length,
        ImportContext&                                          context) {

        m_fieldData.Append(data, length);
}

void MessageIO::xmlImportChildComplete(
        const char*                                                             name,
        ImportContext&                                          context) {

        ASSERT(m_message);
        
        status_t err = _importField(
                m_message,
                name,
                m_fieldName.String(),
                m_fieldData.String());  
        if(err < B_OK) {
                context.reportWarning("Invalid field data.\n");
        }
}

// -------------------------------------------------------- //
// implementation
// -------------------------------------------------------- //

bool MessageIO::_isValidMessageElement(
        const char*                                                             element) const {

        if(!strcmp(element, _boolEl)) return true;
        if(!strcmp(element, _int8El)) return true;
        if(!strcmp(element, _int16El)) return true;
        if(!strcmp(element, _int32El)) return true;
        if(!strcmp(element, _int64El)) return true;
        if(!strcmp(element, _floatEl)) return true;
        if(!strcmp(element, _doubleEl)) return true;
        if(!strcmp(element, _stringEl)) return true;
        if(!strcmp(element, _pointEl)) return true;
        if(!strcmp(element, _rectEl)) return true;

        return false;   
}

status_t MessageIO::_importField(
        BMessage*                                                                       message,
        const char*                                                             element,
        const char*                                                             name,
        const char*                                                             data) {

        // skip leading whitespace
        while(*data && isspace(*data)) ++data;
        
        if(!strcmp(element, _boolEl)) {
                bool v;
                if(!strcmp(data, "true") || !strcmp(data, "1"))
                        v = true;
                else if(!strcmp(data, "false") || !strcmp(data, "0"))
                        v = false;
                else
                        return B_BAD_VALUE;
                return message->AddBool(name, v);
        }
        
        if(!strcmp(element, _int8El)) {
                int8 v = atoi(data);
                return message->AddInt8(name, v);
        }
        if(!strcmp(element, _int16El)) {
                int16 v = atoi(data);
                return message->AddInt16(name, v);
        }
        if(!strcmp(element, _int32El)) {
                int32 v = atol(data);
                return message->AddInt32(name, v);
        }
        if(!strcmp(element, _int64El)) {
//              int64 v = atoll(data);
                int64 v = strtoll(data, 0, 10);
                return message->AddInt64(name, v);
        }
        if(!strcmp(element, _floatEl)) {
                float v = (float)atof(data);
                return message->AddFloat(name, v);
        }
        if(!strcmp(element, _doubleEl)) {
                double v = atof(data);
                return message->AddDouble(name, v);
        }
        
        if(!strcmp(element, _stringEl)) {
                // +++++ chomp leading/trailing whitespace?
                
                return message->AddString(name, data);
        }
        
        if(!strcmp(element, _pointEl)) {
                BPoint p;
                const char* ystart = strchr(data, ',');
                if(!ystart)
                        return B_BAD_VALUE;
                ++ystart;
                if(!*ystart)
                        return B_BAD_VALUE;
                p.x = (float)atof(data);
                p.y = (float)atof(ystart);
                
                return message->AddPoint(name, p);
        }
        
        if(!strcmp(element, _rectEl)) {
                BRect r;
                const char* topstart = strchr(data, ',');
                if(!topstart)
                        return B_BAD_VALUE;
                ++topstart;
                if(!*topstart)
                        return B_BAD_VALUE;
                
                const char* rightstart = strchr(topstart, ',');
                if(!rightstart)
                        return B_BAD_VALUE;
                ++rightstart;
                if(!*rightstart)
                        return B_BAD_VALUE;
                
                const char* bottomstart = strchr(rightstart, ',');
                if(!bottomstart)
                        return B_BAD_VALUE;
                ++bottomstart;
                if(!*bottomstart)
                        return B_BAD_VALUE;
                
                r.left = (float)atof(data);
                r.top = (float)atof(topstart);
                r.right = (float)atof(rightstart);
                r.bottom = (float)atof(bottomstart);
                
                return message->AddRect(name, r);
        }

        return B_BAD_INDEX;
}

status_t MessageIO::_exportField(
        ExportContext&                                          context,
        BMessage*                                                                       message,
        type_code                                                                       type,
        const char*                                                             name,
        int32                                                                                   index) const {
        
        status_t err;
        BString elementName;
        BString content;
        
        switch(type) {
                case B_BOOL_TYPE: {
                        bool v;
                        err = message->FindBool(name, index, &v);
                        if(err < B_OK)
                                return err;
                        elementName = _boolEl;
                        content = (v ? "true" : "false");
                        break;
                }
                
                case B_INT8_TYPE: {
                        int8 v;
                        err = message->FindInt8(name, index, &v);
                        if(err < B_OK)
                                return err;
                        elementName = _int8El;
                        content << (int32)v;
                        break;
                }
                        
                case B_INT16_TYPE: {
                        int16 v;
                        err = message->FindInt16(name, index, &v);
                        if(err < B_OK)
                                return err;
                        elementName = _int16El;
                        content << (int32)v;
                        break;
                }
                        
                case B_INT32_TYPE: {
                        int32 v;
                        err = message->FindInt32(name, index, &v);
                        if(err < B_OK)
                                return err;
                        elementName = _int32El;
                        content << v;
                        break;
                }
                        
                case B_INT64_TYPE: {
                        int64 v;
                        err = message->FindInt64(name, index, &v);
                        if(err < B_OK)
                                return err;
                        elementName = _int64El;
                        content << v;
                        break;
                }
                        
                case B_FLOAT_TYPE: {
                        float v;
                        err = message->FindFloat(name, index, &v);
                        if(err < B_OK)
                                return err;
                        elementName = _floatEl;
                        content << v; // +++++ need adjustable precision!
                        break;
                }
                        
                case B_DOUBLE_TYPE: {
                        double v;
                        err = message->FindDouble(name, index, &v);
                        if(err < B_OK)
                                return err;
                        elementName = _doubleEl;
                        content << (float)v; // +++++ need adjustable precision!
                        break;
                }
                
                case B_STRING_TYPE: {
                        const char* v;
                        err = message->FindString(name, index, &v);
                        if(err < B_OK)
                                return err;
                        elementName = _stringEl;
                        content = v;
                        break;
                }

                case B_POINT_TYPE: {
                        BPoint v;
                        err = message->FindPoint(name, index, &v);
                        if(err < B_OK)
                                return err;
                        elementName = _pointEl;
                        content << v.x << ", " << v.y;
                        break;
                }

                case B_RECT_TYPE: {
                        BRect v;
                        err = message->FindRect(name, index, &v);
                        if(err < B_OK)
                                return err;
                        elementName = _rectEl;
                        content << v.left << ", " << v.top << ", " <<
                                v.right << ", " << v.bottom;
                        break;
                }
                
                case B_MESSAGE_TYPE: {
                        BMessage m;
                        err = message->FindMessage(name, index, &m);
                        if(err < B_OK)
                                return err;
                        
                        // write child message
                        MessageIO io(&m);
                        io.m_name = name;
                        return context.writeObject(&io);
                }

                default:
                        return B_BAD_TYPE;
        }
        
        // spew the element
        context.beginElement(elementName.String());
        context.writeAttr("name", name);
        context.writeAttr("value", content.String());
//      context.beginContent();
//      context.writeString(content);
        context.endElement();
        
        return B_OK;
}
// END -- MessageIO.cpp --