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


// NodeSyncThread.cpp

#include "NodeSyncThread.h"

#include <cstring>

#include <Debug.h>
#include <MediaRoster.h>

__USE_CORTEX_NAMESPACE

// -------------------------------------------------------- //
// *** dtor/ctors
// -------------------------------------------------------- //

NodeSyncThread::~NodeSyncThread() {
        status_t err;

        // clean up
        if(m_thread) {
                err = kill_thread(m_thread);
                if(err < B_OK)
                        PRINT((
                                "! ~NodeSyncThread(): kill_thread(%" B_PRId32 "):\n"
                                "  %s\n",
                                m_thread,
                                strerror(err)));
                                
                // +++++ is a wait_for_thread() necessary?
        }
        
        if(m_port) {
                err = delete_port(m_port);
                if(err < B_OK)
                        PRINT((
                                "! ~NodeSyncThread(): delete_port(%" B_PRId32 "):\n"
                                "  %s\n",
                                m_port,
                                strerror(err)));
        }
        
        if(m_portBuffer)
                delete [] m_portBuffer;
        if(m_messenger)
                delete m_messenger;
}

NodeSyncThread::NodeSyncThread(
        const media_node&                                               node,
        BMessenger*                                                                     messenger) :
        
        m_node(node),
        m_messenger(messenger),
        m_syncInProgress(false),
        m_thread(0),
        m_port(0),
        m_portBuffer(0),
        m_portBufferSize(sizeof(_sync_op)) {            
        
        ASSERT(m_messenger);

        m_portBuffer = new char[m_portBufferSize];

        m_port = create_port(
                m_portBufferSize * 16,
                "NodeSyncThread___port");
        ASSERT(m_port >= B_OK);

        m_thread = spawn_thread(
                &_Sync,
                "NodeSyncThread",
                B_DISPLAY_PRIORITY,
                this);
        ASSERT(m_thread >= B_OK);
        resume_thread(m_thread);
}       

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

// trigger a sync operation: when 'perfTime' arrives
// for the node, a M_SYNC_COMPLETE message with the given
// position value will be sent,  unless the sync operation
// times out, in which case M_TIMED_OUT will be sent.

status_t NodeSyncThread::sync(
        bigtime_t                                                                               perfTime,
        bigtime_t                                                                               position,
        bigtime_t                                                                               timeout) {

        status_t err;
        
        if(m_syncInProgress)
                return B_NOT_ALLOWED;   

        _sync_op op = {perfTime, position, timeout};
        err = write_port(
                m_port,
                M_TRIGGER,
                &op,
                sizeof(_sync_op));
        
        return err;
}

// -------------------------------------------------------- //
// *** guts
// -------------------------------------------------------- //

/*static*/
status_t NodeSyncThread::_Sync(
        void*                                                                                           cookie) {
        ((NodeSyncThread*)cookie)->_sync();
        return B_OK;
}

// THREAD BODY
//
void NodeSyncThread::_sync() {
        ASSERT(m_port >= B_OK);
        ASSERT(m_messenger);

        bool done = false;
        while(!done) {
        
                // WAIT FOR A REQUEST
                int32 code;
                ssize_t readCount = read_port(  
                        m_port,
                        &code,
                        m_portBuffer,
                        m_portBufferSize);
                        
                if(readCount < B_OK) {
                        PRINT((
                                "! NodeSyncThread::_sync(): read_port():\n"
                                "  %s\n",
                                strerror(readCount)));
                        continue;
                }
                
                if(code != M_TRIGGER) {
                        PRINT((
                                "! NodeSyncThread::sync(): unknown message code %" B_PRId32
                                        "\n", code));
                        continue;
                }
                
                // SERVICE THE REQUEST
                const _sync_op& op = *(_sync_op*)m_portBuffer;
                
                // pre-fill the message
                BMessage m(M_SYNC_COMPLETE);
                m.AddInt32("nodeID", m_node.node);
                m.AddInt64("perfTime", op.targetTime);
                m.AddInt64("position", op.position);

                // sync
                status_t err = BMediaRoster::Roster()->SyncToNode(
                        m_node,
                        op.targetTime,
                        op.timeout);

                // deliver reply
                if(err < B_OK) {
                        m.what = M_SYNC_FAILED;
                        m.AddInt32("error", err);
                }
                
                err = m_messenger->SendMessage(&m);
                if(err < B_OK) {
                        PRINT((
                                "! NodeSyncThread::_sync(): m_messenger->SendMessage():\n"
                                "  %s\n",
                                strerror(err)));
                }
        }
}


// END -- NodeSyncThread.cpp --