/*
 * Copyright 2004-2010, Haiku. All rights reserved.
 * Distributed under the terms of the MIT license.
 *
 * Authors:
 *              Marcus Overhagen
 *              Axel Dörfler
 *              Stephan Aßmus <superstippi@gmx.de>
 */


#include "AddOnManager.h"

#include <stdio.h>
#include <string.h>

#include <Architecture.h>
#include <AutoDeleter.h>
#include <Autolock.h>
#include <Directory.h>
#include <Entry.h>
#include <FindDirectory.h>
#include <image.h>
#include <Path.h>

#include "MediaDebug.h"

#include "FormatManager.h"
#include "MetaFormat.h"


namespace BPrivate {
namespace media {


//      #pragma mark - ImageLoader

/*!     The ImageLoader class is a convenience class to temporarily load
        an image file, and unload it on deconstruction automatically.
*/
class ImageLoader {
public:
        ImageLoader(BPath& path)
        {
                fImage = load_add_on(path.Path());
        }

        ~ImageLoader()
        {
                if (fImage >= B_OK)
                        unload_add_on(fImage);
        }

        status_t InitCheck() const { return fImage >= 0 ? B_OK : fImage; }
        image_id Image() const { return fImage; }

private:
        image_id        fImage;
};


//      #pragma mark -


AddOnManager::AddOnManager()
        :
        fLock("add-on manager"),
        fNextWriterFormatFamilyID(0),
        fNextEncoderCodecInfoID(0)
{
}


AddOnManager::~AddOnManager()
{
}


AddOnManager AddOnManager::sInstance;


/* static */ AddOnManager*
AddOnManager::GetInstance()
{
        return &sInstance;
}


status_t
AddOnManager::GetDecoderForFormat(entry_ref* _decoderRef,
        const media_format& format)
{
        if ((format.type == B_MEDIA_ENCODED_VIDEO
                        || format.type == B_MEDIA_ENCODED_AUDIO
                        || format.type == B_MEDIA_MULTISTREAM)
                && format.Encoding() == 0) {
                return B_MEDIA_BAD_FORMAT;
        }
        if (format.type == B_MEDIA_NO_TYPE || format.type == B_MEDIA_UNKNOWN_TYPE)
                return B_MEDIA_BAD_FORMAT;

        BAutolock locker(fLock);
        RegisterAddOns();

        // Since the list of decoders is unsorted, we need to search for
        // a decoder by add-on directory, in order to maintain the shadowing
        // of system add-ons by user add-ons, in case they offer decoders
        // for the same format.

        char** directories = NULL;
        size_t directoryCount = 0;

        if (find_paths_etc(get_architecture(), B_FIND_PATH_ADD_ONS_DIRECTORY,
                        "media/plugins", B_FIND_PATH_EXISTING_ONLY, &directories,
                        &directoryCount) != B_OK) {
                printf("AddOnManager::GetDecoderForFormat: failed to locate plugins\n");
                return B_ENTRY_NOT_FOUND;
        }

        MemoryDeleter directoriesDeleter(directories);

        BPath path;
        for (uint i = 0; i < directoryCount; i++) {
                path.SetTo(directories[i]);
                if (_FindDecoder(format, path, _decoderRef))
                        return B_OK;
        }

        return B_ENTRY_NOT_FOUND;
}


status_t
AddOnManager::GetEncoderForFormat(entry_ref* _encoderRef,
        const media_format& outputFormat)
{
        if ((outputFormat.type == B_MEDIA_RAW_VIDEO
                        || outputFormat.type == B_MEDIA_RAW_AUDIO)) {
                return B_MEDIA_BAD_FORMAT;
        }

        if (outputFormat.type == B_MEDIA_NO_TYPE
                        || outputFormat.type == B_MEDIA_UNKNOWN_TYPE) {
                return B_MEDIA_BAD_FORMAT;
        }

        BAutolock locker(fLock);
        RegisterAddOns();

        char** directories = NULL;
        size_t directoryCount = 0;

        if (find_paths_etc(get_architecture(), B_FIND_PATH_ADD_ONS_DIRECTORY,
                        "media/plugins", B_FIND_PATH_EXISTING_ONLY, &directories,
                        &directoryCount) != B_OK) {
                printf("AddOnManager::GetDecoderForFormat: failed to locate plugins\n");
                return B_ENTRY_NOT_FOUND;
        }

        MemoryDeleter directoriesDeleter(directories);

        BPath path;
        for (uint i = 0; i < directoryCount; i++) {
                path.SetTo(directories[i]);
                if (_FindEncoder(outputFormat, path, _encoderRef))
                        return B_OK;
        }

        return B_ENTRY_NOT_FOUND;
}


status_t
AddOnManager::GetReaders(entry_ref* outRefs, int32* outCount,
        int32 maxCount)
{
        BAutolock locker(fLock);
        RegisterAddOns();

        *outCount = 0;

        // See GetDecoderForFormat() for why we need to scan the list by path.

        char** directories = NULL;
        size_t directoryCount = 0;

        if (find_paths_etc(get_architecture(), B_FIND_PATH_ADD_ONS_DIRECTORY,
                        "media/plugins", B_FIND_PATH_EXISTING_ONLY, &directories,
                        &directoryCount) != B_OK) {
                printf("AddOnManager::GetReaders: failed to locate plugins\n");
                return B_ENTRY_NOT_FOUND;
        }

        MemoryDeleter directoriesDeleter(directories);

        BPath path;
        for (uint i = 0; i < directoryCount; i++) {
                path.SetTo(directories[i]);
                _GetReaders(path, outRefs, outCount, maxCount);
        }

        return B_OK;
}


status_t
AddOnManager::GetStreamers(entry_ref* outRefs, int32* outCount,
        int32 maxCount)
{
        BAutolock locker(fLock);
        RegisterAddOns();

        int32 count = 0;
        streamer_info* info;
        for (fStreamerList.Rewind(); fStreamerList.GetNext(&info);) {
                        if (count == maxCount)
                                break;

                        *outRefs = info->ref;
                        outRefs++;
                        count++;
        }

        *outCount = count;
        return B_OK;
}


status_t
AddOnManager::GetEncoder(entry_ref* _encoderRef, int32 id)
{
        BAutolock locker(fLock);
        RegisterAddOns();

        encoder_info* info;
        for (fEncoderList.Rewind(); fEncoderList.GetNext(&info);) {
                // check if the encoder matches the supplied format
                if (info->internalID == (uint32)id) {
                        *_encoderRef = info->ref;
                        return B_OK;
                }
        }

        return B_ENTRY_NOT_FOUND;
}


status_t
AddOnManager::GetWriter(entry_ref* _ref, uint32 internalID)
{
        BAutolock locker(fLock);
        RegisterAddOns();

        writer_info* info;
        for (fWriterList.Rewind(); fWriterList.GetNext(&info);) {
                if (info->internalID == internalID) {
                        *_ref = info->ref;
                        return B_OK;
                }
        }

        return B_ERROR;
}


status_t
AddOnManager::GetFileFormat(media_file_format* _fileFormat, int32 cookie)
{
        BAutolock locker(fLock);
        RegisterAddOns();

        media_file_format* fileFormat;
        if (fWriterFileFormats.Get(cookie, &fileFormat)) {
                *_fileFormat = *fileFormat;
                return B_OK;
        }

        return B_BAD_INDEX;
}


status_t
AddOnManager::GetCodecInfo(media_codec_info* _codecInfo,
        media_format_family* _formatFamily,
        media_format* _inputFormat, media_format* _outputFormat, int32 cookie)
{
        BAutolock locker(fLock);
        RegisterAddOns();

        encoder_info* info;
        if (fEncoderList.Get(cookie, &info)) {
                *_codecInfo = info->codecInfo;
                *_formatFamily = info->formatFamily;
                *_inputFormat = info->intputFormat;
                *_outputFormat = info->outputFormat;
                return B_OK;
        }

        return B_BAD_INDEX;
}


// #pragma mark -


void
AddOnManager::RegisterAddOns()
{
        // Check if add-ons are already registered.
        if (!fReaderList.IsEmpty() || !fWriterList.IsEmpty()
                || !fDecoderList.IsEmpty() || !fEncoderList.IsEmpty()) {
                return;
        }

        char** directories = NULL;
        size_t directoryCount = 0;

        if (find_paths_etc(get_architecture(), B_FIND_PATH_ADD_ONS_DIRECTORY,
                        "media/plugins", B_FIND_PATH_EXISTING_ONLY, &directories,
                        &directoryCount) != B_OK) {
                return;
        }

        MemoryDeleter directoriesDeleter(directories);

        BPath path;
        for (uint i = 0; i < directoryCount; i++) {
                BDirectory directory;
                if (directory.SetTo(directories[i]) == B_OK) {
                        entry_ref ref;
                        while(directory.GetNextRef(&ref) == B_OK)
                                _RegisterAddOn(ref);
                }
        }
}


status_t
AddOnManager::_RegisterAddOn(const entry_ref& ref)
{
        BPath path(&ref);

        ImageLoader loader(path);
        status_t status = loader.InitCheck();
        if (status != B_OK)
                return status;

        MediaPlugin* (*instantiate_plugin_func)();

        if (get_image_symbol(loader.Image(), "instantiate_plugin",
                        B_SYMBOL_TYPE_TEXT, (void**)&instantiate_plugin_func) < B_OK) {
                printf("AddOnManager::_RegisterAddOn(): can't find instantiate_plugin "
                        "in \"%s\"\n", path.Path());
                return B_BAD_TYPE;
        }

        MediaPlugin* plugin = (*instantiate_plugin_func)();
        if (plugin == NULL) {
                printf("AddOnManager::_RegisterAddOn(): instantiate_plugin in \"%s\" "
                        "returned NULL\n", path.Path());
                return B_ERROR;
        }

        ReaderPlugin* reader = dynamic_cast<ReaderPlugin*>(plugin);
        if (reader != NULL)
                _RegisterReader(reader, ref);

        DecoderPlugin* decoder = dynamic_cast<DecoderPlugin*>(plugin);
        if (decoder != NULL)
                _RegisterDecoder(decoder, ref);

        WriterPlugin* writer = dynamic_cast<WriterPlugin*>(plugin);
        if (writer != NULL)
                _RegisterWriter(writer, ref);

        EncoderPlugin* encoder = dynamic_cast<EncoderPlugin*>(plugin);
        if (encoder != NULL)
                _RegisterEncoder(encoder, ref);

        StreamerPlugin* streamer = dynamic_cast<StreamerPlugin*>(plugin);
        if (streamer != NULL)
                _RegisterStreamer(streamer, ref);

        delete plugin;

        return B_OK;
}


status_t
AddOnManager::_UnregisterAddOn(const entry_ref& ref)
{
        BAutolock locker(fLock);

        // Remove any Readers exported by this add-on
        reader_info* readerInfo;
        for (fReaderList.Rewind(); fReaderList.GetNext(&readerInfo);) {
                if (readerInfo->ref == ref) {
                        fReaderList.RemoveCurrent();
                        break;
                }
        }

        // Remove any Decoders exported by this add-on
        decoder_info* decoderInfo;
        for (fDecoderList.Rewind(); fDecoderList.GetNext(&decoderInfo);) {
                if (decoderInfo->ref == ref) {
                        media_format* format;
                        for (decoderInfo->formats.Rewind();
                                        decoderInfo->formats.GetNext(&format);) {
                                FormatManager::GetInstance()->RemoveFormat(*format);
                        }
                        fDecoderList.RemoveCurrent();
                        break;
                }
        }

        // Remove any Writers exported by this add-on
        writer_info* writerInfo;
        for (fWriterList.Rewind(); fWriterList.GetNext(&writerInfo);) {
                if (writerInfo->ref == ref) {
                        // Remove any formats from this writer
                        media_file_format* writerFormat;
                        for (fWriterFileFormats.Rewind();
                                fWriterFileFormats.GetNext(&writerFormat);) {
                                if (writerFormat->id.internal_id == writerInfo->internalID)
                                        fWriterFileFormats.RemoveCurrent();
                        }
                        fWriterList.RemoveCurrent();
                        break;
                }
        }

        encoder_info* encoderInfo;
        for (fEncoderList.Rewind(); fEncoderList.GetNext(&encoderInfo);) {
                if (encoderInfo->ref == ref) {
                        fEncoderList.RemoveCurrent();
                        // Keep going, since we add multiple encoder infos per add-on.
                }
        }

        return B_OK;
}


void
AddOnManager::_RegisterReader(ReaderPlugin* reader, const entry_ref& ref)
{
        BAutolock locker(fLock);

        reader_info* pinfo;
        for (fReaderList.Rewind(); fReaderList.GetNext(&pinfo);) {
                if (!strcmp(pinfo->ref.name, ref.name)) {
                        // we already know this reader
                        return;
                }
        }

        reader_info info;
        info.ref = ref;

        fReaderList.Insert(info);
}


void
AddOnManager::_RegisterDecoder(DecoderPlugin* plugin, const entry_ref& ref)
{
        BAutolock locker(fLock);

        decoder_info* pinfo;
        for (fDecoderList.Rewind(); fDecoderList.GetNext(&pinfo);) {
                if (!strcmp(pinfo->ref.name, ref.name)) {
                        // we already know this decoder
                        return;
                }
        }

        decoder_info info;
        info.ref = ref;

        media_format* formats = 0;
        size_t count = 0;
        if (plugin->GetSupportedFormats(&formats, &count) != B_OK) {
                printf("AddOnManager::_RegisterDecoder(): plugin->GetSupportedFormats"
                        "(...) failed!\n");
                return;
        }
        for (uint i = 0 ; i < count ; i++)
                info.formats.Insert(formats[i]);

        fDecoderList.Insert(info);
}


void
AddOnManager::_RegisterWriter(WriterPlugin* writer, const entry_ref& ref)
{
        BAutolock locker(fLock);

        writer_info* pinfo;
        for (fWriterList.Rewind(); fWriterList.GetNext(&pinfo);) {
                if (!strcmp(pinfo->ref.name, ref.name)) {
                        // we already know this writer
                        return;
                }
        }

        writer_info info;
        info.ref = ref;
        info.internalID = fNextWriterFormatFamilyID++;

        // Get list of support media_file_formats...
        const media_file_format* fileFormats = NULL;
        size_t count = 0;
        if (writer->GetSupportedFileFormats(&fileFormats, &count) != B_OK) {
                printf("AddOnManager::_RegisterWriter(): "
                        "plugin->GetSupportedFileFormats(...) failed!\n");
                return;
        }
        for (uint i = 0 ; i < count ; i++) {
                // Generate a proper ID before inserting this format, this encodes
                // the specific plugin in the media_file_format.
                media_file_format fileFormat = fileFormats[i];
                fileFormat.id.node = ref.directory;
                fileFormat.id.device = ref.device;
                fileFormat.id.internal_id = info.internalID;

                fWriterFileFormats.Insert(fileFormat);
        }

        fWriterList.Insert(info);
}


void
AddOnManager::_RegisterEncoder(EncoderPlugin* plugin, const entry_ref& ref)
{
        BAutolock locker(fLock);

        encoder_info* pinfo;
        for (fEncoderList.Rewind(); fEncoderList.GetNext(&pinfo);) {
                if (!strcmp(pinfo->ref.name, ref.name)) {
                        // We already know this encoder. When we reject encoders with
                        // the same name, we allow the user to overwrite system encoders
                        // in her home folder.
                        return;
                }
        }

        // Get list of supported encoders...

        encoder_info info;
        info.ref = ref;
        info.internalID = fNextEncoderCodecInfoID++;

        int32 cookie = 0;

        while (true) {
                memset(&info.codecInfo, 0, sizeof(media_codec_info));
                info.intputFormat.Clear();
                info.outputFormat.Clear();
                if (plugin->RegisterNextEncoder(&cookie,
                        &info.codecInfo, &info.formatFamily, &info.intputFormat,
                        &info.outputFormat) != B_OK) {
                        break;
                }
                info.codecInfo.id = info.internalID;
                // NOTE: info.codecInfo.sub_id is for private use by the Encoder,
                // we don't touch it, but it is maintained and passed back to the
                // EncoderPlugin in NewEncoder(media_codec_info).

                if (!fEncoderList.Insert(info))
                        break;
        }
}


void
AddOnManager::_RegisterStreamer(StreamerPlugin* streamer, const entry_ref& ref)
{
        BAutolock locker(fLock);

        streamer_info* pInfo;
        for (fStreamerList.Rewind(); fStreamerList.GetNext(&pInfo);) {
                if (!strcmp(pInfo->ref.name, ref.name)) {
                        // We already know this streamer
                        return;
                }
        }

        streamer_info info;
        info.ref = ref;
        fStreamerList.Insert(info);
}


bool
AddOnManager::_FindDecoder(const media_format& format, const BPath& path,
        entry_ref* _decoderRef)
{
        node_ref nref;
        BDirectory directory;
        if (directory.SetTo(path.Path()) != B_OK
                || directory.GetNodeRef(&nref) != B_OK) {
                return false;
        }

        decoder_info* info;
        for (fDecoderList.Rewind(); fDecoderList.GetNext(&info);) {
                if (info->ref.directory != nref.node)
                        continue;

                media_format* decoderFormat;
                for (info->formats.Rewind(); info->formats.GetNext(&decoderFormat);) {
                        // check if the decoder matches the supplied format
                        if (!decoderFormat->Matches(&format))
                                continue;

                        *_decoderRef = info->ref;
                        return true;
                }
        }
        return false;
}


bool
AddOnManager::_FindEncoder(const media_format& format, const BPath& path,
        entry_ref* _encoderRef)
{
        node_ref nref;
        BDirectory directory;
        if (directory.SetTo(path.Path()) != B_OK
                || directory.GetNodeRef(&nref) != B_OK) {
                return false;
        }

        encoder_info* info;
        for (fEncoderList.Rewind(); fEncoderList.GetNext(&info);) {
                if (info->ref.directory != nref.node)
                        continue;

                // check if the encoder matches the supplied format
                if (info->outputFormat.Matches(&format)) {
                        *_encoderRef = info->ref;
                        return true;
                }
                continue;
        }
        return false;
}


void
AddOnManager::_GetReaders(const BPath& path, entry_ref* outRefs,
        int32* outCount, int32 maxCount)
{
        node_ref nref;
        BDirectory directory;
        if (directory.SetTo(path.Path()) != B_OK
                || directory.GetNodeRef(&nref) != B_OK) {
                return;
        }

        reader_info* info;
        for (fReaderList.Rewind(); fReaderList.GetNext(&info)
                && *outCount < maxCount;) {
                if (info->ref.directory != nref.node)
                        continue;

                outRefs[*outCount] = info->ref;
                (*outCount)++;
        }
}


} // namespace media
} // namespace BPrivate