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


// DormantNodeIO.cpp

#include "DormantNodeIO.h"
#include "ImportContext.h"
#include "ExportContext.h"
#include "StringContent.h"

#include "NodeManager.h"

#include <Debug.h>
#include <MediaAddOn.h>
#include <MediaDefs.h>
#include <MediaRoster.h>
#include <Path.h>

#include <cstdlib>

#include "route_app_io.h"

__USE_CORTEX_NAMESPACE

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

DormantNodeIO::~DormantNodeIO() {}

// initialize for import (to defaults)
DormantNodeIO::DormantNodeIO() :
        m_kinds(0LL),
        m_flavorID(0),
        m_flags(0),
        m_runMode(0),
        m_recordingDelay(0),
        m_cycle(false),
        m_exportValid(false) {}

// initialize for export
DormantNodeIO::DormantNodeIO(
        NodeRef*                                                                ref,
        const char*                                                     nodeKey) :
        m_exportValid(false) {
        
        ASSERT(ref);
        ASSERT(nodeKey);
        status_t err;

        m_nodeKey = nodeKey;

        // * extract dormant-node info  
        dormant_node_info info;
        err = ref->getDormantNodeInfo(&info);
        if(err < B_OK) {
                PRINT(( 
                        "!!! DormantNodeIO(): getDormantNodeInfo() failed:\n"
                        "    %s\n",
                        strerror(err)));
                return;
        }

        dormant_flavor_info flavorInfo;
        err = BMediaRoster::Roster()->GetDormantFlavorInfoFor(
                info, &flavorInfo);
        if(err < B_OK) {
                PRINT(( 
                        "!!! DormantNodeIO(): GetDormantFlavorInfoFor() failed:\n"
                        "    %s\n",
                        strerror(err)));
                return;
        }

        m_dormantName = flavorInfo.name;
        m_flavorID = info.flavor_id;
        m_kinds = flavorInfo.kinds;
        
        m_flags = ref->flags();
        entry_ref file;
        if(ref->getFile(&file) == B_OK)
                m_entry.SetTo(&file);
        
        m_runMode = ref->runMode();
        m_recordingDelay = ref->recordingDelay();
        m_cycle = ref->isCycling();
        
        // done extracting node info; ready for export
        m_exportValid = true;
}

// -------------------------------------------------------- //
// *** document-type setup
// -------------------------------------------------------- //

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

        // map self
        docType->addMapping(new Mapping<DormantNodeIO>(_DORMANT_NODE_ELEMENT));

//      // map simple (content-only) elements
//      // +++++ should these be added at a higher level, since they're
//      //       shared?  no harm is done if one is added more than once,
//      //       since they'll always map to StringContent.
//      // +++++
//      docType->addMapping(new Mapping<StringContent>(_NAME_ELEMENT));
//      docType->addMapping(new Mapping<StringContent>(_KIND_ELEMENT));
//      docType->addMapping(new Mapping<StringContent>(_FLAVOR_ID_ELEMENT));
//      docType->addMapping(new Mapping<StringContent>(_FLAG_ELEMENT));
//      docType->addMapping(new Mapping<StringContent>(_RUN_MODE_ELEMENT));
//      docType->addMapping(new Mapping<StringContent>(_RECORDING_DELAY_ELEMENT));
//      docType->addMapping(new Mapping<StringContent>(_CYCLE_ELEMENT));
//      docType->addMapping(new Mapping<StringContent>(_REF_ELEMENT));
}

// -------------------------------------------------------- //
// *** operations
// -------------------------------------------------------- //

// call when object imported to create the described node

// +++++

status_t DormantNodeIO::instantiate(
        NodeManager*                                            manager,
        NodeRef**                                                               outRef) {

        status_t err;
        BPath p;
        if(m_entry.InitCheck() == B_OK)
                m_entry.GetPath(&p);

//      PRINT((
//              "DormantNodeIO:\n"
//              "  key:       %s\n"
//              "  name:      %s\n"
//              "  flavor:    %ld\n"
//              "  kinds:     %Lx\n"
//              "  flags:     %lx\n"
//              "  runMode:   %ld\n"
//              "  recDelay:  %lld\n"
//              "  cycle:     %s\n"
//              "  entry:     %s\n\n",
//              m_nodeKey.String(),
//              m_dormantName.String(),
//              m_flavorID,
//              m_kinds,
//              m_flags,
//              m_runMode,
//              m_recordingDelay,
//              m_cycle ? "true" : "false",
//              p.Path()));
        
        // find matching dormant node
        dormant_node_info info;
        err = _matchDormantNode(&info);
        if(err < B_OK) {
                PRINT((
                        "!!! _matchDormantNode() failed: %s\n", strerror(err)));
                return err;
        }
        
        // instantiate node
        err = manager->instantiate(
                info,
                outRef,
                B_INFINITE_TIMEOUT,
                m_flags);
        if(err < B_OK) {
                PRINT((
                        "!!! instantiate() failed: %s\n", strerror(err)));
                return err;
        }
        
        entry_ref mediaRef;
        if(m_entry.InitCheck() == B_OK && m_entry.GetRef(&mediaRef) == B_OK) {
                // set ref
                err = (*outRef)->setFile(mediaRef);
                if(err < B_OK) {
                        PRINT((
                                "!!! WARNING: setFile() failed: %s\n", strerror(err)));
                }
        }

        // set run mode
        if(m_runMode)
                (*outRef)->setRunMode(m_runMode, m_recordingDelay);
        
        // set cycle state
        if(m_cycle)
                (*outRef)->setCycling(true);

        return B_OK;
}

status_t DormantNodeIO::_matchDormantNode(
        dormant_node_info*                      outInfo) {

        status_t err;
        
        // fetch all dormant nodes matching the signature
        const int32 bufferSize = 32;
        dormant_node_info       buffer[bufferSize];
        int32 count = bufferSize;
        err = BMediaRoster::Roster()->GetDormantNodes(
                buffer,
                &count,
                0,
                0,
                m_dormantName.String(),
                m_kinds,
                0 /*~m_kinds*/);
        if(err < B_OK)
                return err;
        
        if(!count)
                return B_NAME_NOT_FOUND;
        
        for(int32 n = 0; n < count; ++n) {
                if(buffer[n].flavor_id == m_flavorID) {
                        *outInfo = buffer[n];
                        return B_OK;
                }
        }

        // didn't match flavor id
        return B_BAD_INDEX;
}


// -------------------------------------------------------- //
// *** IPersistent
// -------------------------------------------------------- //

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

//inline void _write_simple(
//      const char* element,
//      const char* value,
//      ExportContext& context) {
//
//      context.beginElement(element);
//      context.beginContent();
//      context.writeString(value);
//      context.endElement();
//}

// -------------------------------------------------------- //

void DormantNodeIO::xmlExportBegin(
        ExportContext&                                          context) const {
        
        if(!m_exportValid) {
                context.reportError(
                        "DormantNodeIO::xmlExportBegin():\n"
                        "*** invalid ***\n");
                return;
        }
        
        context.beginElement(_DORMANT_NODE_ELEMENT);
}
        
void DormantNodeIO::xmlExportAttributes(
        ExportContext&                                          context) const {

        context.writeAttr("key", m_nodeKey);    
}

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

        context.beginContent();
        BString buffer;
        
        // write dormant-node description
        context.beginElement(_NAME_ELEMENT);
        context.beginContent();
        context.writeString(m_dormantName);
        context.endElement();

        if(m_flavorID > 0) {
                buffer = "";
                buffer << m_flavorID;
                context.beginElement(_FLAVOR_ID_ELEMENT);
                context.beginContent();
                context.writeString(buffer);
                context.endElement();
        }       

        _write_node_kinds(m_kinds, context);
//      if(m_kinds & B_BUFFER_PRODUCER)
//              _write_simple(_KIND_ELEMENT, "B_BUFFER_PRODUCER", context);
//      if(m_kinds & B_BUFFER_CONSUMER)
//              _write_simple(_KIND_ELEMENT, "B_BUFFER_CONSUMER", context);
//      if(m_kinds & B_TIME_SOURCE)
//              _write_simple(_KIND_ELEMENT, "B_TIME_SOURCE", context);
//      if(m_kinds & B_CONTROLLABLE)
//              _write_simple(_KIND_ELEMENT, "B_CONTROLLABLE", context);
//      if(m_kinds & B_FILE_INTERFACE)
//              _write_simple(_KIND_ELEMENT, "B_FILE_INTERFACE", context);
//      if(m_kinds & B_ENTITY_INTERFACE)
//              _write_simple(_KIND_ELEMENT, "B_ENTITY_INTERFACE", context);
//      if(m_kinds & B_PHYSICAL_INPUT)
//              _write_simple(_KIND_ELEMENT, "B_PHYSICAL_INPUT", context);
//      if(m_kinds & B_PHYSICAL_OUTPUT)
//              _write_simple(_KIND_ELEMENT, "B_PHYSICAL_OUTPUT", context);
//      if(m_kinds & B_SYSTEM_MIXER)
//              _write_simple(_KIND_ELEMENT, "B_SYSTEM_MIXER", context);
        
        // write NodeRef flags
        if(m_flags & NodeRef::NO_START_STOP)
                _write_simple(_FLAG_ELEMENT, "NO_START_STOP", context);
        if(m_flags & NodeRef::NO_SEEK)
                _write_simple(_FLAG_ELEMENT, "NO_SEEK", context);
        if(m_flags & NodeRef::NO_PREROLL)
                _write_simple(_FLAG_ELEMENT, "NO_PREROLL", context);
        if(m_flags & NodeRef::NO_STOP)
                _write_simple(_FLAG_ELEMENT, "NO_STOP", context);
        if(m_flags & NodeRef::NO_ROSTER_WATCH)
                _write_simple(_FLAG_ELEMENT, "NO_ROSTER_WATCH", context);
        if(m_flags & NodeRef::NO_POSITION_REPORTING)
                _write_simple(_FLAG_ELEMENT, "NO_POSITION_REPORTING", context);
                
        // write transport settings
        if(m_runMode > 0) {
                switch(m_runMode) {
                        case BMediaNode::B_OFFLINE:
                                _write_simple(_RUN_MODE_ELEMENT, "B_OFFLINE", context);
                                break;
                        case BMediaNode::B_DECREASE_PRECISION:
                                _write_simple(_RUN_MODE_ELEMENT, "B_DECREASE_PRECISION", context);
                                break;
                        case BMediaNode::B_INCREASE_LATENCY:
                                _write_simple(_RUN_MODE_ELEMENT, "B_INCREASE_LATENCY", context);
                                break;
                        case BMediaNode::B_DROP_DATA:
                                _write_simple(_RUN_MODE_ELEMENT, "B_DROP_DATA", context);
                                break;
                        case BMediaNode::B_RECORDING:
                                _write_simple(_RUN_MODE_ELEMENT, "B_RECORDING", context);
                                buffer = "";
                                buffer << m_recordingDelay;
                                _write_simple(_RECORDING_DELAY_ELEMENT, buffer.String(), context);
                                break;
                        default:
                                buffer = "";
                                buffer << m_runMode;
                                _write_simple(_RUN_MODE_ELEMENT, buffer.String(), context);
                }
        }

        if(m_cycle) {
                context.beginElement(_CYCLE_ELEMENT);
                context.endElement();
        }

        BPath p;
        if(
                m_entry.InitCheck() == B_OK &&
                m_entry.GetPath(&p) == B_OK)
                _write_simple(_REF_ELEMENT, p.Path(), context);

}

void DormantNodeIO::xmlExportEnd(
        ExportContext&                                          context) const {

        // finish
        context.endElement();
}


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

//inline void _read_node_kind(
//      int64& ioKind,
//      const char* data,
//      ImportContext& context) {
//
//      if(!strcmp(data, "B_BUFFER_PRODUCER"))
//              ioKind |= B_BUFFER_PRODUCER;
//      else if(!strcmp(data, "B_BUFFER_CONSUMER"))
//              ioKind |= B_BUFFER_CONSUMER;
//      else if(!strcmp(data, "B_TIME_SOURCE"))
//              ioKind |= B_TIME_SOURCE;
//      else if(!strcmp(data, "B_CONTROLLABLE"))
//              ioKind |= B_CONTROLLABLE;
//      else if(!strcmp(data, "B_FILE_INTERFACE"))
//              ioKind |= B_FILE_INTERFACE;
//      else if(!strcmp(data, "B_ENTITY_INTERFACE"))
//              ioKind |= B_ENTITY_INTERFACE;
//      else if(!strcmp(data, "B_PHYSICAL_INPUT"))
//              ioKind |= B_PHYSICAL_INPUT;
//      else if(!strcmp(data, "B_PHYSICAL_OUTPUT"))
//              ioKind |= B_PHYSICAL_OUTPUT;
//      else if(!strcmp(data, "B_SYSTEM_MIXER"))
//              ioKind |= B_SYSTEM_MIXER;
//      else {
//              BString err;
//              err << "_read_noderef_kind(): unknown node kind '" << data << "'\n";
//              context.reportWarning(err.String());
//      }
//}

inline void _read_noderef_flag(
        int32& ioFlags,
        const char* data,
        ImportContext& context) {

        if(!strcmp(data, "NO_START_STOP"))
                ioFlags |= NodeRef::NO_START_STOP;
        else if(!strcmp(data, "NO_SEEK"))
                ioFlags |= NodeRef::NO_SEEK;
        else if(!strcmp(data, "NO_PREROLL"))
                ioFlags |= NodeRef::NO_PREROLL;
        else if(!strcmp(data, "NO_STOP"))
                ioFlags |= NodeRef::NO_STOP;
        else if(!strcmp(data, "NO_ROSTER_WATCH"))
                ioFlags |= NodeRef::NO_ROSTER_WATCH;
        else if(!strcmp(data, "NO_POSITION_REPORTING"))
                ioFlags |= NodeRef::NO_POSITION_REPORTING;      
        else {
                BString err;
                err << "_read_noderef_flag(): unknown node flag '" << data << "'\n";
                context.reportWarning(err.String());
        }
}

inline void _read_run_mode(
        int32& runMode,
        const char* data,
        ImportContext& context) {

        if(!strcmp(data, "B_OFFLINE"))
                runMode = BMediaNode::B_OFFLINE;
        else if(!strcmp(data, "B_DECREASE_PRECISION"))
                runMode = BMediaNode::B_DECREASE_PRECISION;
        else if(!strcmp(data, "B_INCREASE_LATENCY"))
                runMode = BMediaNode::B_INCREASE_LATENCY;
        else if(!strcmp(data, "B_DROP_DATA"))
                runMode = BMediaNode::B_DROP_DATA;
        else if(!strcmp(data, "B_RECORDING"))
                runMode = BMediaNode::B_RECORDING;
        else {
                BString err;
                err << "_read_run_mode(): unknown run mode '" << data << "'\n";
                context.reportWarning(err.String());
        }
}

inline void _read_entry(
        BEntry& entry,
        const char* data,
        ImportContext& context) {
        
        entry_ref r;
        status_t err = get_ref_for_path(data, &r);
        if(err < B_OK) {
                BString text;
                text << "_read_entry_ref(): get_ref_for_path('" << data << "') failed:\n"
                        "   " << strerror(err) << "\n";
                context.reportWarning(text.String());
        }
        
        entry.SetTo(&r);
}


void DormantNodeIO::xmlImportBegin(
        ImportContext&                                          context) { TOUCH(context); }

void DormantNodeIO::xmlImportAttribute(
        const char*                                                             key,
        const char*                                                             value,
        ImportContext&                                          context) {

        if(!strcmp(key, "key")) {
                m_nodeKey = value;
        }
        else {
                BString err;
                err << "DormantNodeIO: unknown attribute '" << key << "'\n";
                context.reportError(err.String());              
        }       
}

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

void DormantNodeIO::xmlImportChild(
        IPersistent*                                                    child,
        ImportContext&                                          context) {
        
        StringContent* obj = dynamic_cast<StringContent*>(child);
        if(!obj) {
                BString err;
                err << "DormantNodeIO: unexpected element '" <<
                        context.element() << "'\n";
                context.reportError(err.String());
                return;                 
        }
        
        if(!strcmp(context.element(), _NAME_ELEMENT))
                m_dormantName = obj->content;
        else if(!strcmp(context.element(), _KIND_ELEMENT))
                _read_node_kind(m_kinds, obj->content.String(), context);
        else if(!strcmp(context.element(), _FLAVOR_ID_ELEMENT))
                m_flavorID = atol(obj->content.String());
        else if(!strcmp(context.element(), _FLAG_ELEMENT))
                _read_noderef_flag(m_flags, obj->content.String(), context);
        else if(!strcmp(context.element(), _RUN_MODE_ELEMENT))
                _read_run_mode(m_runMode, obj->content.String(), context);
        else if(!strcmp(context.element(), _RECORDING_DELAY_ELEMENT))
                m_recordingDelay = strtoll(obj->content.String(), 0, 10);
        else if(!strcmp(context.element(), _CYCLE_ELEMENT))
                m_cycle = true;
        else if(!strcmp(context.element(), _REF_ELEMENT))
                _read_entry(m_entry, obj->content.String(), context);
        else {
                BString err;
                err << "DormantNodeIO: unexpected element '" << 
                        context.element() << "'\n";
                context.reportError(err.String());
        }

        delete child;
}
                
void DormantNodeIO::xmlImportComplete(
        ImportContext&                                          context) { TOUCH(context); } //nyi; +++++ final checks?


// END -- DormantNodeIO.cpp --