/*
 * Copyright 2002-2013, Haiku Inc.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Ingo Weinhold (bonefish@users.sf.net)
 *              Tyler Dauwalder
 */


#include "MIMEManager.h"

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

#include <Bitmap.h>
#include <Message.h>
#include <Messenger.h>
#include <Path.h>
#include <RegistrarDefs.h>
#include <String.h>
#include <TypeConstants.h>

#include <mime/AppMetaMimeCreator.h>
#include <mime/database_support.h>
#include <mime/MimeSnifferAddonManager.h>
#include <mime/TextSnifferAddon.h>

#include "CreateAppMetaMimeThread.h"
#include "MessageDeliverer.h"
#include "UpdateMimeInfoThread.h"


using namespace std;
using namespace BPrivate;
using BPrivate::Storage::Mime::MimeSnifferAddonManager;
using BPrivate::Storage::Mime::TextSnifferAddon;


/*!     \class MIMEManager
        \brief MIMEManager handles communication between BMimeType and the system-wide
        MimeDatabase object for BMimeType's write and non-atomic read functions.

*/


static MimeSnifferAddonManager*
init_mime_sniffer_add_on_manager()
{
        if (MimeSnifferAddonManager::CreateDefault() != B_OK)
                return NULL;

        MimeSnifferAddonManager* manager = MimeSnifferAddonManager::Default();
        manager->AddMimeSnifferAddon(new(nothrow) TextSnifferAddon(
                BPrivate::Storage::Mime::default_database_location()));
        return manager;
}


class MIMEManager::DatabaseLocker
        : public BPrivate::Storage::Mime::MimeEntryProcessor::DatabaseLocker {
public:
        DatabaseLocker(MIMEManager* manager)
                :
                fManager(manager)
        {
        }

        virtual bool Lock()
        {
                return fManager->Lock();
        }

        virtual void Unlock()
        {
                fManager->Unlock();
        }

private:
        MIMEManager*    fManager;
};


/*!     \brief Creates and initializes a MIMEManager.
*/
MIMEManager::MIMEManager()
        :
        BLooper("main_mime"),
        fDatabase(BPrivate::Storage::Mime::default_database_location(),
                init_mime_sniffer_add_on_manager(), this),
        fDatabaseLocker(new(std::nothrow) DatabaseLocker(this)),
        fThreadManager()
{
        AddHandler(&fThreadManager);
}


/*!     \brief Frees all resources associate with this object.
*/
MIMEManager::~MIMEManager()
{
}


/*!     \brief Overrides the super class version to handle the MIME specific
                   messages.
        \param message The message to be handled
*/
void
MIMEManager::MessageReceived(BMessage *message)
{
        BMessage reply;
        status_t err;

        switch (message->what) {
                case B_REG_MIME_SET_PARAM:
                        HandleSetParam(message);
                        break;

                case B_REG_MIME_DELETE_PARAM:
                        HandleDeleteParam(message);
                        break;

                case B_REG_MIME_START_WATCHING:
                case B_REG_MIME_STOP_WATCHING:
                {
                        BMessenger messenger;
                        err = message->FindMessenger("target", &messenger);
                        if (!err) {
                                err = message->what == B_REG_MIME_START_WATCHING
                                        ? fDatabase.StartWatching(messenger)
                                        : fDatabase.StopWatching(messenger);
                        }

                        reply.what = B_REG_RESULT;
                        reply.AddInt32("result", err);
                        message->SendReply(&reply, this);
                        break;
                }

                case B_REG_MIME_INSTALL:
                case B_REG_MIME_DELETE:
                {
                        const char *type;
                        err = message->FindString("type", &type);
                        if (!err)
                                err = message->what == B_REG_MIME_INSTALL
                                        ? fDatabase.Install(type) : fDatabase.Delete(type);

                        reply.what = B_REG_RESULT;
                        reply.AddInt32("result", err);
                        message->SendReply(&reply, this);
                        break;
                }

                case B_REG_MIME_GET_INSTALLED_TYPES:
                {
                        const char *supertype;
                        err = message->FindString("supertype", &supertype);
                        if (err == B_NAME_NOT_FOUND)
                                err = fDatabase.GetInstalledTypes(&reply);
                        else if (!err)
                                err = fDatabase.GetInstalledTypes(supertype, &reply);

                        reply.what = B_REG_RESULT;
                        reply.AddInt32("result", err);
                        message->SendReply(&reply, this);
                        break;
                }

                case B_REG_MIME_GET_INSTALLED_SUPERTYPES:
                {
                        err = fDatabase.GetInstalledSupertypes(&reply);

                        reply.what = B_REG_RESULT;
                        reply.AddInt32("result", err);
                        message->SendReply(&reply, this);
                        break;
                }

                case B_REG_MIME_GET_SUPPORTING_APPS:
                {
                        const char *type;
                        err = message->FindString("type", &type);
                        if (!err)
                                err = fDatabase.GetSupportingApps(type, &reply);

                        reply.what = B_REG_RESULT;
                        reply.AddInt32("result", err);
                        message->SendReply(&reply, this);
                        break;
                }

                case B_REG_MIME_GET_ASSOCIATED_TYPES:
                {
                        const char *extension;
                        err = message->FindString("extension", &extension);
                        if (!err)
                                err = fDatabase.GetAssociatedTypes(extension, &reply);

                        reply.what = B_REG_RESULT;
                        reply.AddInt32("result", err);
                        message->SendReply(&reply, this);
                        break;
                }

                case B_REG_MIME_SNIFF:
                {
                        BString str;
                        entry_ref ref;
                        const char *filename;
                        err = message->FindString("filename", &filename);
                        if (!err)
                                err = fDatabase.GuessMimeType(filename, &str);
                        else if (err == B_NAME_NOT_FOUND) {
                                err = message->FindRef("file ref", &ref);
                                if (!err)
                                        err = fDatabase.GuessMimeType(&ref, &str);
                                else if (err == B_NAME_NOT_FOUND) {
                                        const void *data;
                                        ssize_t dataSize;
                                        err = message->FindData("data", B_RAW_TYPE, &data,
                                                &dataSize);
                                        if (!err)
                                                err = fDatabase.GuessMimeType(data, dataSize, &str);
                                }
                        }
                        if (!err)
                                err = reply.AddString("mime type", str);

                        reply.what = B_REG_RESULT;
                        reply.AddInt32("result", err);
                        message->SendReply(&reply, this);
                        break;
                }

                case B_REG_MIME_CREATE_APP_META_MIME:
                case B_REG_MIME_UPDATE_MIME_INFO:
                {
                        using BPrivate::Storage::Mime::MimeUpdateThread;
                        using BPrivate::Storage::Mime::CreateAppMetaMimeThread;
                        using BPrivate::Storage::Mime::UpdateMimeInfoThread;

                        entry_ref root;
                        bool recursive;
                        bool synchronous = false;
                        int32 force;

                        MimeUpdateThread *thread = NULL;

                        status_t threadStatus = B_NO_INIT;
                        bool messageIsDetached = false;
                        bool stillOwnsThread = true;

                        // Gather our arguments
                        err = message->FindRef("entry", &root);
                        if (!err)
                                err = message->FindBool("recursive", &recursive);
                        if (!err)
                                err = message->FindBool("synchronous", &synchronous);
                        if (!err)
                                err = message->FindInt32("force", &force);

                        // Detach the message for synchronous calls
                        if (!err && synchronous) {
                                DetachCurrentMessage();
                                messageIsDetached = true;
                        }

                        // Create the appropriate flavor of mime update thread
                        if (!err) {
                                switch (message->what) {
                                        case B_REG_MIME_CREATE_APP_META_MIME:
                                                thread = new(nothrow) CreateAppMetaMimeThread(
                                                        synchronous ? "create_app_meta_mime (s)"
                                                                : "create_app_meta_mime (a)",
                                                        B_NORMAL_PRIORITY + 1, &fDatabase, fDatabaseLocker,
                                                        BMessenger(&fThreadManager), &root, recursive,
                                                        force, synchronous ? message : NULL);
                                                break;

                                        case B_REG_MIME_UPDATE_MIME_INFO:
                                                thread = new(nothrow) UpdateMimeInfoThread(synchronous
                                                                ? "update_mime_info (s)"
                                                                : "update_mime_info (a)",
                                                        B_NORMAL_PRIORITY + 1, &fDatabase, fDatabaseLocker,
                                                        BMessenger(&fThreadManager), &root, recursive,
                                                        force, synchronous ? message : NULL);
                                                break;

                                        default:
                                                err = B_BAD_VALUE;
                                                break;
                                }
                        }
                        if (!err)
                                err = thread ? B_OK : B_NO_MEMORY;
                        if (!err)
                                err = threadStatus = thread->InitCheck();

                        // Launch the thread
                        if (!err) {
                                err = fThreadManager.LaunchThread(thread);
                                if (!err) {
                                        stillOwnsThread = false;
                                }
                        }

                        // If something went wrong, we need to notify the sender regardless. However,
                        // if this is a synchronous call, we've already detached the message, and must
                        // be careful that it gets deleted once and only once. Thus, if the MimeUpdateThread
                        // object was created successfully, we don't need to delete the message, as that
                        // object has assumed control of it. Otherwise, we are still responsible.
                        if (err || !synchronous) {
                                // Send the reply
                                reply.what = B_REG_RESULT;
                                reply.AddInt32("result", err);
                                message->SendReply(&reply, this);
                        }
                        // Delete the message if necessary
                        if (messageIsDetached && threadStatus != B_OK)
                                delete message;
                        // Delete the thread if necessary
                        if (stillOwnsThread)
                                delete thread;
                        break;
                }

                default:
                        printf("MIMEMan: msg->what == %" B_PRIx32 " (%.4s)\n",
                                message->what, (char*)&(message->what));
                        BLooper::MessageReceived(message);
                        break;
        }
}


status_t
MIMEManager::Notify(BMessage* message, const BMessenger& target)
{
        return MessageDeliverer::Default()->DeliverMessage(message, target);
}


//! Handles all B_REG_MIME_SET_PARAM messages
void
MIMEManager::HandleSetParam(BMessage *message)
{
        status_t err;
        int32 which;
        const char *type;

        err = message->FindString("type", &type);
        if (!err)
                err = message->FindInt32("which", &which);
        if (!err) {
                switch (which) {
                        case B_REG_MIME_APP_HINT:
                        {
                                entry_ref ref;
                                err = message->FindRef("app hint", &ref);
                                if (!err)
                                        err = fDatabase.SetAppHint(type, &ref);
                                break;
                        }

                        case B_REG_MIME_ATTR_INFO:
                        {
                                BMessage info;
                                err = message->FindMessage("attr info", &info);
                                if (!err)
                                        err = fDatabase.SetAttrInfo(type, &info);
                                break;
                        }

                        case B_REG_MIME_DESCRIPTION:
                        {
                                bool isLong;
                                const char *description;
                                err = message->FindBool("long", &isLong);
                                if (!err)
                                        err = message->FindString("description", &description);
                                if (!err) {
                                        err = isLong
                                                ? fDatabase.SetLongDescription(type, description)
                                                : fDatabase.SetShortDescription(type, description);
                                }
                                break;
                        }

                        case B_REG_MIME_FILE_EXTENSIONS:
                        {
                                BMessage extensions;
                                err = message->FindMessage("extensions", &extensions);
                                if (!err)
                                        err = fDatabase.SetFileExtensions(type, &extensions);
                                break;
                        }

                        case B_REG_MIME_ICON:
                        case B_REG_MIME_ICON_FOR_TYPE:
                        {
                                const void *data;
                                ssize_t dataSize;
                                int32 size;
                                err = message->FindData("icon data", B_RAW_TYPE, &data,
                                        &dataSize);
                                if (!err)
                                        err = message->FindInt32("icon size", &size);
                                if (which == B_REG_MIME_ICON_FOR_TYPE) {
                                        const char *fileType;
                                        if (!err)
                                                err = message->FindString("file type", &fileType);
                                        if (!err) {
                                                err = size == -1
                                                        ? fDatabase.SetIconForType(type, fileType, data,
                                                                dataSize)
                                                        : fDatabase.SetIconForType(type, fileType, data,
                                                                dataSize, (icon_size)size);
                                        }
                                } else {
                                        if (!err) {
                                                err = size == -1
                                                        ? fDatabase.SetIcon(type, data, dataSize)
                                                        : fDatabase.SetIcon(type, data, dataSize,
                                                                (icon_size)size);
                                        }
                                }
                                break;
                                // End temporary fix code
                        }

                        case B_REG_MIME_PREFERRED_APP:
                        {
                                const char *signature;
                                int32 verb;
                                err = message->FindString("signature", &signature);
                                if (!err)
                                        err = message->FindInt32("app verb", &verb);
                                if (!err) {
                                        err = fDatabase.SetPreferredApp(type, signature,
                                                (app_verb)verb);
                                }
                                break;
                        }

                        case B_REG_MIME_SNIFFER_RULE:
                        {
                                const char *rule;
                                err = message->FindString("sniffer rule", &rule);
                                if (!err)
                                        err = fDatabase.SetSnifferRule(type, rule);
                                break;
                        }

                        case B_REG_MIME_SUPPORTED_TYPES:
                        {
                                BMessage types;
                                bool fullSync = true;
                                err = message->FindMessage("types", &types);
                                if (!err)
                                        err = message->FindBool("full sync", &fullSync);
                                if (!err)
                                        err = fDatabase.SetSupportedTypes(type, &types, fullSync);
                                break;
                        }

                        default:
                                err = B_BAD_VALUE;
                                break;
                }
        }

        BMessage reply(B_REG_RESULT);
        reply.AddInt32("result", err);
        message->SendReply(&reply, this);
}


//! Handles all B_REG_MIME_SET_PARAM messages
void
MIMEManager::HandleDeleteParam(BMessage *message)
{
        status_t err;
        int32 which;
        const char *type;

        err = message->FindString("type", &type);
        if (!err)
                err = message->FindInt32("which", &which);
        if (!err) {
                switch (which) {
                        case B_REG_MIME_APP_HINT:
                                err = fDatabase.DeleteAppHint(type);
                                break;

                        case B_REG_MIME_ATTR_INFO:
                                err = fDatabase.DeleteAttrInfo(type);
                                break;

                        case B_REG_MIME_DESCRIPTION:
                        {
                                bool isLong;
                                err = message->FindBool("long", &isLong);
                                if (!err) {
                                        err = isLong
                                                ? fDatabase.DeleteLongDescription(type)
                                                : fDatabase.DeleteShortDescription(type);
                                }
                                break;
                        }

                        case B_REG_MIME_FILE_EXTENSIONS:
                                err = fDatabase.DeleteFileExtensions(type);
                                break;

                        case B_REG_MIME_ICON:
                        case B_REG_MIME_ICON_FOR_TYPE:
                        {
                                int32 size;
                                err = message->FindInt32("icon size", &size);
                                if (which == B_REG_MIME_ICON_FOR_TYPE) {
                                        const char *fileType;
                                        if (!err)
                                                err = message->FindString("file type", &fileType);
                                        if (!err) {
                                                err = size == -1
                                                        ? fDatabase.DeleteIconForType(type, fileType)
                                                        : fDatabase.DeleteIconForType(type, fileType,
                                                                (icon_size)size);
                                        }
                                } else {
                                        if (!err) {
                                                err = size == -1
                                                        ? fDatabase.DeleteIcon(type)
                                                        : fDatabase.DeleteIcon(type, (icon_size)size);
                                        }
                                }
                                break;
                        }

                        case B_REG_MIME_PREFERRED_APP:
                        {
                                int32 verb;
                                err = message->FindInt32("app verb", &verb);
                                if (!err)
                                        err = fDatabase.DeletePreferredApp(type, (app_verb)verb);
                                break;
                        }

                        case B_REG_MIME_SNIFFER_RULE:
                                err = fDatabase.DeleteSnifferRule(type);
                                break;

                        case B_REG_MIME_SUPPORTED_TYPES:
                        {
                                bool fullSync;
                                err = message->FindBool("full sync", &fullSync);
                                if (!err)
                                        err = fDatabase.DeleteSupportedTypes(type, fullSync);
                                break;
                        }

                        default:
                                err = B_BAD_VALUE;
                                break;
                }
        }

        BMessage reply(B_REG_RESULT);
        reply.AddInt32("result", err);
        message->SendReply(&reply, this);
}