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


// MediaIcon.cpp

#include "MediaIcon.h"
#include "MediaIconBits.h"
#include "AddOnHostProtocol.h"

// Application Kit
#include <Application.h>
#include <Roster.h>
// Media Kit
#include <MediaDefs.h>
#include <MediaNode.h>
#include <MediaRoster.h>
#include <MediaAddOn.h>
// Storage Kit
#include <NodeInfo.h>
// Support Kit
#include <String.h>
// Interface Kit
#include <IconUtils.h>


__USE_CORTEX_NAMESPACE

#include <Debug.h>
#define D_ALLOC(x) //PRINT (x)
#define D_INTERNAL(x) //PRINT (x)

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

MediaIcon::MediaIcon(
        const live_node_info &nodeInfo,
        icon_size size)
        : BBitmap(BRect(0.0, 0.0, size - 1.0, size - 1.0), B_RGBA32),
          m_size(size),
          m_nodeKind(nodeInfo.node.kind) {
        D_ALLOC(("MediaIcon::MediaIcon(live_node_info '%s')\n", nodeInfo.name));

        _findIconFor(nodeInfo);
}

MediaIcon::MediaIcon(
        const dormant_node_info &nodeInfo,
        icon_size size)
        : BBitmap(BRect(0.0, 0.0, size - 1.0, size - 1.0), B_RGBA32),
          m_size(size),
          m_nodeKind(0) {
        D_ALLOC(("MediaIcon::MediaIcon(dormant_node_info '%s')\n", nodeInfo.name));

        _findIconFor(nodeInfo);
}

MediaIcon::~MediaIcon() {
        D_ALLOC(("MediaIcon::~MediaIcon()\n"));

}

// -------------------------------------------------------- //
// *** internal accessors (private)
// -------------------------------------------------------- //

bool MediaIcon::_isPhysicalInput() const {
        D_INTERNAL(("MediaIcon::_isPhysicalInput()\n"));

        return ((m_nodeKind & B_PHYSICAL_INPUT)
             && (m_nodeKind & B_BUFFER_PRODUCER));
}

bool MediaIcon::_isPhysicalOutput() const {
        D_INTERNAL(("MediaIcon::_isPhysicalOutput()\n"));

        return ((m_nodeKind & B_PHYSICAL_OUTPUT)
             && (m_nodeKind & B_BUFFER_CONSUMER));;
}

bool MediaIcon::_isProducer() const {
        D_INTERNAL(("MediaIcon::_isProducer()\n"));

        return (!(m_nodeKind & B_BUFFER_CONSUMER) && 
                         (m_nodeKind & B_BUFFER_PRODUCER) && 
                        !(m_nodeKind & B_PHYSICAL_INPUT)  &&
                        !(m_nodeKind & B_PHYSICAL_OUTPUT));
}

bool MediaIcon::_isFilter() const {
        D_INTERNAL(("MediaIcon::_isFilter()\n"));

        return ( (m_nodeKind & B_BUFFER_CONSUMER) && 
                         (m_nodeKind & B_BUFFER_PRODUCER) && 
                    !(m_nodeKind & B_PHYSICAL_INPUT)  &&
                    !(m_nodeKind & B_PHYSICAL_OUTPUT));
}

bool MediaIcon::_isConsumer() const {
        D_INTERNAL(("MediaIcon::_isConsumer()\n"));

        return ( (m_nodeKind & B_BUFFER_CONSUMER) && 
                    !(m_nodeKind & B_BUFFER_PRODUCER) && 
                    !(m_nodeKind & B_PHYSICAL_INPUT)  &&
                    !(m_nodeKind & B_PHYSICAL_OUTPUT));
}

bool MediaIcon::_isSystemMixer() const {
        D_INTERNAL(("MediaIcon::_isSystemMixer()\n"));

        return (m_nodeKind & B_SYSTEM_MIXER);
}

bool MediaIcon::_isTimeSource() const {
        D_INTERNAL(("MediaIcon::_isTimeSource()\n"));

        return ((m_nodeKind & B_TIME_SOURCE) &&
                   !(m_nodeKind & B_PHYSICAL_INPUT) &&
                   !(m_nodeKind & B_PHYSICAL_OUTPUT));
}

// -------------------------------------------------------- //
// *** internal operations (private)
// -------------------------------------------------------- //

void MediaIcon::_findIconFor(
        const live_node_info &nodeInfo) {
        D_INTERNAL(("MediaIcon::_findIconFor(live_node_info)\n"));

        BMediaRoster *roster = BMediaRoster::CurrentRoster();
        if (m_nodeKind & B_FILE_INTERFACE) {
                entry_ref ref;
                if ((roster && (roster->GetRefFor(nodeInfo.node, &ref) == B_OK))
                 && (BNodeInfo::GetTrackerIcon(&ref, this, m_size) == B_OK)) {
                        return;
                }
        }
        dormant_node_info dormantNodeInfo;
        if  (roster
         && (roster->GetDormantNodeFor(nodeInfo.node, &dormantNodeInfo) == B_OK)) {
                D_INTERNAL((" -> instantiated from dormant node\n"));
                _findIconFor(dormantNodeInfo);
        }
        else {
                D_INTERNAL((" -> application internal node\n"));
                port_info portInfo;
                app_info appInfo;
                if ((get_port_info(nodeInfo.node.port, &portInfo) == B_OK)
                 && (be_roster->GetRunningAppInfo(portInfo.team, &appInfo) == B_OK)) {
                        D_INTERNAL((" -> application info found: %s\n", appInfo.signature));
                        app_info thisAppInfo;
                        if ((be_app->GetAppInfo(&thisAppInfo) != B_OK)
                         || ((strcmp(appInfo.signature, thisAppInfo.signature) != 0)
                         && (strcmp(appInfo.signature, addon_host::g_appSignature) != 0))) {
                                // only use app icon if the node doesn't belong to our team
                                // or the addon-host
                                BNodeInfo::GetTrackerIcon(&appInfo.ref, this, m_size);
                                return;
                        }
                }
                bool audioIn = false, audioOut = false, videoIn = false, videoOut = false;
                _getMediaTypesFor(nodeInfo, &audioIn, &audioOut, &videoIn, &videoOut);
                _findDefaultIconFor(audioIn, audioOut, videoIn, videoOut);
        }
}


void
MediaIcon::_findIconFor(const dormant_node_info &nodeInfo)
{
        D_INTERNAL(("MediaIcon::_findIconFor(dormant_node_info)\n"));

        dormant_flavor_info flavorInfo;
        BMediaRoster *roster = BMediaRoster::CurrentRoster();
        status_t error = roster->GetDormantFlavorInfoFor(nodeInfo, &flavorInfo);
        if (error == B_OK) {
                m_nodeKind = flavorInfo.kinds;
                bool audioIn = false, audioOut = false;
                bool videoIn = false, videoOut = false;
                _getMediaTypesFor(flavorInfo, &audioIn, &audioOut, &videoIn, &videoOut);
                _findDefaultIconFor(audioIn, audioOut, videoIn, videoOut);
        } else if (BString(nodeInfo.name).Compare("System clock") == 0) {
                BIconUtils::GetVectorIcon(M_TIME_SOURCE_ICON,
                        sizeof(M_TIME_SOURCE_ICON), this);
        } else {
                // use generic icon in case we couldn't get any info
                BIconUtils::GetVectorIcon(M_GENERIC_ICON,
                        sizeof(M_GENERIC_ICON), this);
        }
}


void
MediaIcon::_getMediaTypesFor(const live_node_info &nodeInfo, bool *audioIn,
        bool *audioOut, bool *videoIn, bool *videoOut)
{
        D_INTERNAL(("MediaIcon::_getMediaTypeFor(live_node_info)\n"));

        // get the media_types supported by this node
        const int32 numberOfInputs = 4;
        int32 numberOfFreeInputs, numberOfConnectedInputs;
        media_input inputs[numberOfInputs];
        const int32 numberOfOutputs = 4;
        int32 numberOfFreeOutputs, numberOfConnectedOutputs;
        media_output outputs[numberOfOutputs];
        BMediaRoster *roster = BMediaRoster::CurrentRoster();
        if (roster->GetFreeInputsFor(nodeInfo.node, inputs, numberOfInputs,
                        &numberOfFreeInputs) == B_OK) {
                for (int32 i = 0; i < numberOfFreeInputs; i++) {
                        if ((inputs[i].format.type == B_MEDIA_RAW_AUDIO)
                         || (inputs[i].format.type == B_MEDIA_ENCODED_AUDIO)) {
                                *audioIn = true;
                                continue;
                        }
                        if ((inputs[i].format.type == B_MEDIA_RAW_VIDEO)
                         || (inputs[i].format.type == B_MEDIA_ENCODED_VIDEO)) {
                                *videoIn = true;
                        }
                }
        }
        if (roster->GetConnectedInputsFor(nodeInfo.node, inputs, numberOfInputs,
                        &numberOfConnectedInputs) == B_OK) {
                for (int32 i = 0; i < numberOfConnectedInputs; i++) {
                        if ((inputs[i].format.type == B_MEDIA_RAW_AUDIO)
                         || (inputs[i].format.type == B_MEDIA_ENCODED_AUDIO)) {
                                *audioIn = true;
                                continue;
                        }
                        if ((inputs[i].format.type == B_MEDIA_RAW_VIDEO)
                         || (inputs[i].format.type == B_MEDIA_ENCODED_VIDEO)) {
                                *videoIn = true;
                        }
                }
        }
        if (roster->GetFreeOutputsFor(nodeInfo.node, outputs, numberOfOutputs,
                        &numberOfFreeOutputs) == B_OK) {
                for (int32 i = 0; i < numberOfFreeOutputs; i++) {
                        if ((outputs[i].format.type == B_MEDIA_RAW_AUDIO)
                         || (outputs[i].format.type == B_MEDIA_ENCODED_AUDIO)) {
                                *audioOut = true;
                                continue;
                        }
                        if ((outputs[i].format.type == B_MEDIA_RAW_VIDEO)
                         || (outputs[i].format.type == B_MEDIA_ENCODED_VIDEO)) {
                                *videoOut = true;
                        }
                }
        }
        if (roster->GetConnectedOutputsFor(nodeInfo.node, outputs, numberOfOutputs,
                        &numberOfConnectedOutputs) == B_OK) {
                for (int32 i = 0; i < numberOfConnectedOutputs; i++) {
                        if ((outputs[i].format.type == B_MEDIA_RAW_AUDIO)
                         || (outputs[i].format.type == B_MEDIA_ENCODED_AUDIO)) {
                                *audioOut = true;
                                continue;
                        }
                        if ((outputs[i].format.type == B_MEDIA_RAW_VIDEO)
                         || (outputs[i].format.type == B_MEDIA_ENCODED_VIDEO)) {
                                *videoOut = true;
                        }
                }
        }
}

void MediaIcon::_getMediaTypesFor(
        const dormant_flavor_info &flavorInfo,
        bool *audioIn,
        bool *audioOut,
        bool *videoIn,
        bool *videoOut) {
        D_INTERNAL(("MediaIcon::_getMediaTypeFor(dormant_flavor_info)\n"));

        for (int32 i = 0; i < flavorInfo.in_format_count; i++) {
                if ((flavorInfo.in_formats[i].type == B_MEDIA_RAW_AUDIO)
                 || (flavorInfo.in_formats[i].type == B_MEDIA_ENCODED_AUDIO)) {
                        *audioIn = true;
                        continue;
                }
                if ((flavorInfo.in_formats[i].type == B_MEDIA_RAW_VIDEO)
                 || (flavorInfo.in_formats[i].type == B_MEDIA_ENCODED_VIDEO)) {
                        *videoIn = true;
                }
        }
        for (int32 i = 0; i < flavorInfo.out_format_count; i++) {
                if ((flavorInfo.out_formats[i].type == B_MEDIA_RAW_AUDIO)
                 || (flavorInfo.out_formats[i].type == B_MEDIA_ENCODED_AUDIO)) {
                        *audioOut = true;
                        continue;
                }
                if ((flavorInfo.out_formats[i].type == B_MEDIA_RAW_VIDEO)
                 || (flavorInfo.out_formats[i].type == B_MEDIA_ENCODED_VIDEO)) {
                        *videoOut = true;
                }
        }
}

void MediaIcon::_findDefaultIconFor(
        bool audioIn,
        bool audioOut,
        bool videoIn,
        bool videoOut) {
        D_INTERNAL(("MediaIcon::_findDefaultIcon()\n"));

        if (_isTimeSource()) {
                BIconUtils::GetVectorIcon(M_TIME_SOURCE_ICON,
                        sizeof(M_TIME_SOURCE_ICON), this);
                return;
        }

        if (_isSystemMixer()) {
                BIconUtils::GetVectorIcon(M_AUDIO_MIXER_ICON,
                        sizeof(M_AUDIO_MIXER_ICON), this);
                return;
        }

        if (m_nodeKind & B_FILE_INTERFACE) {
                if (_isProducer()) {
                        BIconUtils::GetVectorIcon(M_FILE_READER_ICON,
                                sizeof(M_FILE_READER_ICON), this);
                        return;
                } else {
                        BIconUtils::GetVectorIcon(M_FILE_WRITER_ICON,
                                sizeof(M_FILE_WRITER_ICON), this);
                        return;
                }
        }

        if (_isPhysicalInput()) {
                if (audioIn) {
                        BIconUtils::GetVectorIcon(M_AUDIO_DEVICE_ICON,
                                sizeof(M_AUDIO_DEVICE_ICON), this);
                        return;
                } else if (audioOut) {
                        BIconUtils::GetVectorIcon(M_AUDIO_INPUT_ICON,
                                sizeof(M_AUDIO_INPUT_ICON), this);
                        return;
                } else if (videoOut) {
                        BIconUtils::GetVectorIcon(M_VIDEO_INPUT_ICON,
                                sizeof(M_VIDEO_INPUT_ICON), this);
                        return;
                }
        }
        
        if (_isPhysicalOutput()) {
                if (audioIn) {
                        BIconUtils::GetVectorIcon(M_AUDIO_OUTPUT_ICON,
                                sizeof(M_AUDIO_OUTPUT_ICON), this);
                        return;
                } else if (videoIn) {
                        BIconUtils::GetVectorIcon(M_VIDEO_OUTPUT_ICON,
                                sizeof(M_VIDEO_OUTPUT_ICON), this);
                        return;
                }
        }

        if (_isProducer()) {
                if (audioOut) {
                        BIconUtils::GetVectorIcon(M_AUDIO_PRODUCER_ICON,
                                sizeof(M_AUDIO_PRODUCER_ICON), this);
                        return;
                } else if (videoOut) {
                        BIconUtils::GetVectorIcon(M_VIDEO_PRODUCER_ICON,
                                sizeof(M_VIDEO_PRODUCER_ICON), this);
                        return;
                }
        }

        if (_isFilter()) {
                if (audioIn && audioOut && !videoIn && !videoOut) {
                        BIconUtils::GetVectorIcon(M_AUDIO_FILTER_ICON,
                                sizeof(M_AUDIO_FILTER_ICON), this);
                        return;
                } else if (audioIn && !videoIn && videoOut) {
                        BIconUtils::GetVectorIcon(M_AUDIO_CONSUMER_ICON,
                                sizeof(M_AUDIO_CONSUMER_ICON), this);
                        return;
                } else if (!audioIn && !audioOut && videoIn && videoOut) {
                        BIconUtils::GetVectorIcon(M_VIDEO_FILTER_ICON,
                                sizeof(M_VIDEO_FILTER_ICON), this);
                        return;
                }
        }

        if (_isConsumer()) {
                if (audioIn) {
                        BIconUtils::GetVectorIcon(M_AUDIO_CONSUMER_ICON,
                                sizeof(M_AUDIO_CONSUMER_ICON), this);
                        return;
                } else if (videoIn) {
                        BIconUtils::GetVectorIcon(M_VIDEO_CONSUMER_ICON,
                                sizeof(M_VIDEO_CONSUMER_ICON), this);
                        return;
                }
        }

        // assign a default icon
        BIconUtils::GetVectorIcon(M_GENERIC_ICON, sizeof(M_GENERIC_ICON), this);
}