/*
 * Copyright 2002-2014, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Tyler Dauwalder
 *              Rene Gollent, rene@gollent.com.
 *              Michael Lotz, mmlr@mlotz.ch
 *              Jonas Sundström, jonas@kirilla.com
 *              Ingo Weinhold, ingo_weinhold@gmx.de
 */


#include <mime/MimeInfoUpdater.h>

#include <stdlib.h>

#include <AppFileInfo.h>
#include <Bitmap.h>
#include <File.h>
#include <fs_attr.h>
#include <MimeType.h>
#include <String.h>

#include <AutoLocker.h>
#include <mime/Database.h>
#include <mime/database_support.h>


static const char *kAppFlagsAttribute = "BEOS:APP_FLAGS";


static status_t
update_icon(BAppFileInfo &appFileInfoRead, BAppFileInfo &appFileInfoWrite,
        const char *type, BBitmap &icon, icon_size iconSize)
{
        status_t err = appFileInfoRead.GetIconForType(type, &icon, iconSize);
        if (err == B_OK)
                err = appFileInfoWrite.SetIconForType(type, &icon, iconSize, false);
        else if (err == B_ENTRY_NOT_FOUND)
                err = appFileInfoWrite.SetIconForType(type, NULL, iconSize, false);
        return err;
}


static status_t
update_icon(BAppFileInfo &appFileInfoRead, BAppFileInfo &appFileInfoWrite,
        const char *type)
{
        uint8* data = NULL;
        size_t size = 0;

        status_t err = appFileInfoRead.GetIconForType(type, &data, &size);
        if (err == B_OK)
                err = appFileInfoWrite.SetIconForType(type, data, size, false);
        else if (err == B_ENTRY_NOT_FOUND)
                err = appFileInfoWrite.SetIconForType(type, NULL, size, false);

        free(data);

        return err;
}


static bool
is_shared_object_mime_type(const BString &type)
{
        return type.ICompare(B_APP_MIME_TYPE) == 0;
}


namespace BPrivate {
namespace Storage {
namespace Mime {


MimeInfoUpdater::MimeInfoUpdater(Database* database,
        DatabaseLocker* databaseLocker, int32 force)
        :
        MimeEntryProcessor(database, databaseLocker, force)
{
}


MimeInfoUpdater::~MimeInfoUpdater()
{
}


status_t
MimeInfoUpdater::Do(const entry_ref& entry, bool* _entryIsDir)
{
        bool updateType = false;
        bool updateAppInfo = false;
        BNode node;

        status_t err = node.SetTo(&entry);
        if (!err && _entryIsDir)
                *_entryIsDir = node.IsDirectory();
        if (!err) {
                // If not forced, only update if the entry has no file type attribute
                attr_info info;
                if (fForce == B_UPDATE_MIME_INFO_FORCE_UPDATE_ALL
                        || node.GetAttrInfo(kFileTypeAttr, &info) == B_ENTRY_NOT_FOUND) {
                        updateType = true;
                }
                updateAppInfo = (updateType
                        || fForce == B_UPDATE_MIME_INFO_FORCE_KEEP_TYPE);
        }

        // guess the MIME type
        BString type;
        if (!err && (updateType || updateAppInfo)) {
                AutoLocker<DatabaseLocker> databaseLocker(fDatabaseLocker);
                err = fDatabase->GuessMimeType(&entry, &type);
        }

        // update the MIME type
        if (!err && updateType) {
                ssize_t len = type.Length() + 1;
                ssize_t bytes = node.WriteAttr(kFileTypeAttr, kFileTypeType, 0, type,
                        len);
                if (bytes < B_OK)
                        err = bytes;
                else
                        err = (bytes != len ? (status_t)B_FILE_ERROR : (status_t)B_OK);
        }

        // update the app file info attributes, if this is a shared object
        BFile file;
        BAppFileInfo appFileInfoRead;
        BAppFileInfo appFileInfoWrite;
        if (!err && updateAppInfo && node.IsFile()
                && is_shared_object_mime_type(type)
                && (err = file.SetTo(&entry, B_READ_WRITE)) == B_OK
                && (err = appFileInfoRead.SetTo(&file)) == B_OK
                && (err = appFileInfoWrite.SetTo(&file)) == B_OK) {

                // we read from resources and write to attributes
                appFileInfoRead.SetInfoLocation(B_USE_RESOURCES);
                appFileInfoWrite.SetInfoLocation(B_USE_ATTRIBUTES);

                // signature
                char signature[B_MIME_TYPE_LENGTH];
                err = appFileInfoRead.GetSignature(signature);
                if (err == B_OK)
                        err = appFileInfoWrite.SetSignature(signature);
                else if (err == B_ENTRY_NOT_FOUND)
                        err = appFileInfoWrite.SetSignature(NULL);
                if (err != B_OK)
                        return err;

                // catalog entry
                char catalogEntry[B_MIME_TYPE_LENGTH * 3];
                err = appFileInfoRead.GetCatalogEntry(catalogEntry);
                if (err == B_OK)
                        err = appFileInfoWrite.SetCatalogEntry(catalogEntry);
                else if (err == B_ENTRY_NOT_FOUND)
                        err = appFileInfoWrite.SetCatalogEntry(NULL);
                if (err != B_OK)
                        return err;

                // app flags
                uint32 appFlags;
                err = appFileInfoRead.GetAppFlags(&appFlags);
                if (err == B_OK) {
                        err = appFileInfoWrite.SetAppFlags(appFlags);
                } else if (err == B_ENTRY_NOT_FOUND) {
                        file.RemoveAttr(kAppFlagsAttribute);
                        err = B_OK;
                }
                if (err != B_OK)
                        return err;

                // supported types
                BMessage supportedTypes;
                bool hasSupportedTypes = false;
                err = appFileInfoRead.GetSupportedTypes(&supportedTypes);
                if (err == B_OK) {
                        err = appFileInfoWrite.SetSupportedTypes(&supportedTypes, false,
                                false);
                        hasSupportedTypes = true;
                } else if (err == B_ENTRY_NOT_FOUND)
                        err = appFileInfoWrite.SetSupportedTypes(NULL, false, false);
                if (err != B_OK)
                        return err;

                // vector icon
                err = update_icon(appFileInfoRead, appFileInfoWrite, NULL);
                if (err != B_OK)
                        return err;

                // small icon
                BBitmap smallIcon(BRect(0, 0, 15, 15), B_BITMAP_NO_SERVER_LINK,
                        B_CMAP8);
                if (smallIcon.InitCheck() != B_OK)
                        return smallIcon.InitCheck();
                err = update_icon(appFileInfoRead, appFileInfoWrite, NULL, smallIcon,
                        B_MINI_ICON);
                if (err != B_OK)
                        return err;

                // large icon
                BBitmap largeIcon(BRect(0, 0, 31, 31), B_BITMAP_NO_SERVER_LINK,
                        B_CMAP8);
                if (largeIcon.InitCheck() != B_OK)
                        return largeIcon.InitCheck();
                err = update_icon(appFileInfoRead, appFileInfoWrite, NULL, largeIcon,
                        B_LARGE_ICON);
                if (err != B_OK)
                        return err;

                // version infos
                const version_kind versionKinds[]
                        = {B_APP_VERSION_KIND, B_SYSTEM_VERSION_KIND};
                for (int i = 0; i < 2; i++) {
                        version_kind kind = versionKinds[i];
                        version_info versionInfo;
                        err = appFileInfoRead.GetVersionInfo(&versionInfo, kind);
                        if (err == B_OK)
                                err = appFileInfoWrite.SetVersionInfo(&versionInfo, kind);
                        else if (err == B_ENTRY_NOT_FOUND)
                                err = appFileInfoWrite.SetVersionInfo(NULL, kind);
                        if (err != B_OK)
                                return err;
                }

                // icons for supported types
                if (hasSupportedTypes) {
                        const char *supportedType;
                        for (int32 i = 0;
                                 supportedTypes.FindString("types", i, &supportedType) == B_OK;
                                 i++) {
                                // vector icon
                                err = update_icon(appFileInfoRead, appFileInfoWrite,
                                        supportedType);
                                if (err != B_OK)
                                        return err;

                                // small icon
                                err = update_icon(appFileInfoRead, appFileInfoWrite,
                                        supportedType, smallIcon, B_MINI_ICON);
                                if (err != B_OK)
                                        return err;

                                // large icon
                                err = update_icon(appFileInfoRead, appFileInfoWrite,
                                        supportedType, largeIcon, B_LARGE_ICON);
                                if (err != B_OK)
                                        return err;
                        }
                }
        }

        return err;
}


} // namespace Mime
} // namespace Storage
} // namespace BPrivate