#include "qmessage_p.h"

#include "qmessagefolder_p.h"

#include "qmessagestore_p.h"

#include "qmessageservice_maemo_p.h"

#include "qmessagecontentcontainer_maemo_p.h"

#include <QtDBus>

#include <QFileSystemWatcher>

#include <QTimer>

#include </usr/include/libmodest-dbus-client-1.0/libmodest-dbus-client/libmodest-dbus-api.h>

#include </usr/include/sys/inotify.h>

#include </usr/include/sys/ioctl.h>

#include </usr/include/sys/fcntl.h>

// Marshall the ModestStringMap data into a D-Bus argument

QDBusArgument &operator<<(QDBusArgument &argument,

                          const QtMobility::ModestStringMap &map)

{

    QtMobility::ModestStringMap::const_iterator iter;

    argument.beginMap (QVariant::String, QVariant::String);

    for (iter = map.constBegin(); iter != map.constEnd(); iter++) {

        argument.beginMapEntry();

        argument << iter.key() << iter.value();

        argument.endMapEntry();

    }

    argument.endMap();

    return argument;

}

// Retrieve the ModestStringMap data from the D-Bus argument

const QDBusArgument &operator>>(const QDBusArgument &argument,

                                QtMobility::ModestStringMap &map)

{

    map.clear();

    argument.beginMap();

    while (!argument.atEnd()) {

        QString key, value;

        argument.beginMapEntry();

        argument >> key >> value;

        argument.endMapEntry();

        map[key] = value;

    }

    argument.endMap();

    return argument;

}

QDBusArgument &operator<<(QDBusArgument &argument,

                          const QtMobility::ModestUnreadMessageDBusStruct &unreadMessage)

{

    argument.beginStructure();

    argument << unreadMessage.timeStamp;

    argument << unreadMessage.subject;

    argument.endStructure();

    return argument;

}

const QDBusArgument &operator>>(const QDBusArgument &argument,

                                QtMobility::ModestUnreadMessageDBusStruct &unreadMessage)

{

    argument.beginStructure();

    argument >> unreadMessage.timeStamp;

    argument >> unreadMessage.subject;

    argument.endStructure();

    return argument;

}

QDBusArgument &operator<<(QDBusArgument &argument,

                          const QtMobility::ModestAccountsUnreadMessagesDBusStruct &unreadMessages)

{

    argument.beginStructure();

    argument << unreadMessages.accountId;

    argument << unreadMessages.accountName;

    argument << unreadMessages.accountProtocol;

    argument << unreadMessages.unreadCount;

    argument << unreadMessages.unreadMessages;

    argument.endStructure();

    return argument;

}

const QDBusArgument &operator>>(const QDBusArgument &argument,

                                QtMobility::ModestAccountsUnreadMessagesDBusStruct &unreadMessages)

{

    argument.beginStructure();

    argument >> unreadMessages.accountId;

    argument >> unreadMessages.accountName;

    argument >> unreadMessages.accountProtocol;

    argument >> unreadMessages.unreadCount;

    argument >> unreadMessages.unreadMessages;

    argument.endStructure();

    return argument;

}

QDBusArgument &operator<<(QDBusArgument &argument, const QtMobility::ModestMessage &message)

{

    argument.beginStructure();

    argument << message.id;

    argument << message.subject;

    argument << message.folder;

    argument << message.sender;

    argument << message.size;

    argument << message.hasAttachment;

    argument << message.isUnread;

    argument << message.timeStamp;

    argument.endStructure();

    return argument;

}

const QDBusArgument &operator>>(const QDBusArgument &argument, QtMobility::ModestMessage &message)

{

    argument.beginStructure();

    argument >> message.id;

    argument >> message.subject;

    argument >> message.folder;

    argument >> message.sender;

    argument >> message.size;

    argument >> message.hasAttachment;

    argument >> message.isUnread;

    argument >> message.timeStamp;

    argument.endStructure();

    return argument;

}

QDBusArgument &operator<<(QDBusArgument &argument, const QtMobility::MessagingModestMimePart &mimePart)

{

    argument.beginStructure();

    argument << mimePart.mimeType;

    argument << mimePart.isAttachment;

    argument << mimePart.fileName;

    argument << mimePart.contentId;

    argument.endStructure();

    return argument;

}

const QDBusArgument &operator>>(const QDBusArgument &argument, QtMobility::MessagingModestMimePart &mimePart)

{

    argument.beginStructure();

    argument >> mimePart.mimeType;

    argument >> mimePart.isAttachment;

    argument >> mimePart.fileName;

    argument >> mimePart.contentId;

    argument.endStructure();

    return argument;

}

#define MODESTENGINE_ACCOUNT_PROTOCOL          "proto"

#define MODESTENGINE_ACCOUNT_USERNAME          "username"

#define MODESTENGINE_ACCOUNT_HOSTNAME          "hostname"

#define MODESTENGINE_ACCOUNT_PORT              "port"

// The modest engine has a new plugin, we need service names for it

#define MODESTENGINE_QTM_PLUGIN_PATH           "/com/nokia/Qtm/Modest/Plugin"

#define MODESTENGINE_QTM_PLUGIN_NAME           "com.nokia.Qtm.Modest.Plugin"

typedef enum {

    MODEST_DBUS_SEARCH_SUBJECT   = (1 << 0),

    MODEST_DBUS_SEARCH_SENDER    = (1 << 1),

    MODEST_DBUS_SEARCH_RECIPIENT = (1 << 2),

    MODEST_DBUS_SEARCH_SIZE      = (1 << 3),

    MODEST_DBUS_SEARCH_BODY      = (1 << 6)

} ModestDBusSearchFlags;

// Specific priority settings to translate to modest priorities

#define MODESTENGINE_HIGH_PRIORITY             2

#define MODESTENGINE_NORMAL_PRIORITY           0

#define MODESTENGINE_LOW_PRIORITY              1

 : m_queryIds(0)

    // Setup DBus Interface for Modest

    m_ModestDBusInterface = new QDBusInterface(MODEST_DBUS_SERVICE,

                                               MODEST_DBUS_OBJECT,

                                               MODEST_DBUS_IFACE,

                                               QDBusConnection::sessionBus(),

                                               this);

    // Get notifications of Incoming Messages

    m_ModestDBusInterface->connection().connect(MODEST_DBUS_SERVICE,

                                                MODEST_DBUS_OBJECT,

                                                MODEST_DBUS_IFACE,

                                                MODEST_DBUS_SIGNAL_FOLDER_UPDATED,

                                                this, SLOT(folderUpdatedSlot(QDBusMessage)));

    // Get notifications of message Read/Unread state changes

    m_ModestDBusInterface->connection().connect(MODEST_DBUS_SERVICE,

                                                MODEST_DBUS_OBJECT,

                                                MODEST_DBUS_IFACE,

                                                MODEST_DBUS_SIGNAL_MSG_READ_CHANGED,

                                               this, SLOT(messageReadChangedSlot(QDBusMessage)));

    // Setup Qt Mobility Modest Plugin based DBus Interface for Modest

    m_QtmPluginDBusInterface = new QDBusInterface(MODESTENGINE_QTM_PLUGIN_NAME,

                                                  MODESTENGINE_QTM_PLUGIN_PATH,

                                                  MODESTENGINE_QTM_PLUGIN_NAME,

                                                  QDBusConnection::sessionBus(),

                                                  this);

    qDBusRegisterMetaType< ModestStringMap >();

    qDBusRegisterMetaType< ModestStringMapList >();

    qRegisterMetaType<INotifyWatcher::FileNotification>();

    qRegisterMetaType<ModestUnreadMessageDBusStruct>();

    qRegisterMetaType<ModestAccountsUnreadMessagesDBusStruct>();

    qDBusRegisterMetaType<ModestMessage>();

    qRegisterMetaType<MessagingModestMimePart>();

    connect(&m_MailFoldersWatcher, SIGNAL(fileChanged(int, QString, uint)),

            this, SLOT(fileChangedSlot(int, QString, uint)));

    watchAllKnownEmailFolders();

    // Get latest messages from each account

    // => This ensures that notifications of all incoming messages will be sent

    int messagesPerAccount = 1;

    QDBusPendingCall pendingCall = m_ModestDBusInterface->asyncCall(MODEST_DBUS_METHOD_GET_UNREAD_MESSAGES,

                                                                    messagesPerAccount);

    QDBusPendingCallWatcher* pendingCallWatcher = new QDBusPendingCallWatcher(pendingCall);

    pendingCallWatcher->setProperty("setOnlyDates", true);

    connect(pendingCallWatcher, SIGNAL(finished(QDBusPendingCallWatcher*)),

            this, SLOT(pendingGetUnreadMessagesFinishedSlot(QDBusPendingCallWatcher*)));

MessagingModestMessage ModestEngine::messageFromModest(const QString& accountId, const QString &folderId, const QString& messageId) const

{

    MessagingModestMessage modestMessage;

    QDBusPendingCall pendingCall = m_QtmPluginDBusInterface->asyncCall("GetMessage",

                                                                       accountId,

                                                                       folderId,

                                                                       messageId);

    QDBusPendingCallWatcher pendingCallWatcher(pendingCall);

    pendingCallWatcher.waitForFinished();

    QDBusMessage msg = pendingCallWatcher.reply();

    if (msg.type() == QDBusMessage::ReplyMessage) {

        modestMessage.id = messageId;

        modestMessage.accountId = accountId;

        modestMessage.folderId = folderId;

        modestMessage.url = msg.arguments()[0].toString();

        modestMessage.mimeType = msg.arguments()[1].toString();

        modestMessage.from = msg.arguments()[2].toString();

        modestMessage.to = msg.arguments()[3].toString();

        modestMessage.cc = msg.arguments()[4].toString();

        modestMessage.bcc = msg.arguments()[5].toString();

        modestMessage.replyTo = msg.arguments()[6].toString();

        modestMessage.subject = msg.arguments()[7].toString();

        modestMessage.dateReceived = msg.arguments()[8].toLongLong();

        modestMessage.dateSent = msg.arguments()[9].toLongLong();

        modestMessage.size = msg.arguments()[10].toLongLong();

        modestMessage.flags = static_cast<MessagingModestMessageFlags>(msg.arguments()[11].toUInt());

        modestMessage.priority = static_cast<MessagingModestMessagePriority>(msg.arguments()[12].toUInt());

        QVariant variant = msg.arguments()[13];

        QDBusArgument argument = variant.value<QDBusArgument>();

        argument >> modestMessage.mimeParts;

    } else {

        modestMessage.dateReceived = 0;

        modestMessage.dateSent = 0;

        modestMessage.size = 0;

        modestMessage.flags = MessagingModestMessageNotDefined;

        modestMessage.priority = MessagingModestMessagePriorityDefined;

    }

    return modestMessage;

}

        gchar *default_account_id = gconf_client_get_string(m_gconfclient, MODESTENGINE_DEFAULT_ACCOUNT, &error);

        const size_t prefix_len = strlen(MODESTENGINE_ACCOUNT_NAMESPACE) + 1;

            const gchar* account_key = (const gchar*)iter->data;

            // account_key = /apps/modest/server_accounts/<account id>

            // => take account id from account_key & unescape account id

            gchar* unescaped_account_id = gconf_unescape_key(account_key+prefix_len, strlen(account_key)-prefix_len);

            if (account_key) {

                gchar* key = g_strconcat(account_key, "/", MODESTENGINE_ACCOUNT_ENABLED, NULL);

                gchar* key = g_strconcat(account_key, "/", MODESTENGINE_ACCOUNT_STORE_ACCOUNT, NULL);

                    gchar* escaped_server_account_name = gconf_escape_key(server_account_name, strlen(server_account_name));

                    g_free(server_account_name);

                    gchar* store_account_key = g_strconcat(MODESTENGINE_SERVER_ACCOUNT_NAMESPACE, "/", escaped_server_account_name, NULL);

                    if (!gconf_client_dir_exists(m_gconfclient, store_account_key, NULL)) {

                    g_free(store_account_key);

                    g_free(escaped_server_account_name);

                gchar* key = g_strconcat(account_key, "/", MODESTENGINE_ACCOUNT_TRANSPORT_ACCOUNT, NULL);

                    gchar* escaped_server_account_name = gconf_escape_key(server_account_name, strlen(server_account_name));

                    g_free(server_account_name);

                    gchar* transport_account_key = g_strconcat(MODESTENGINE_SERVER_ACCOUNT_NAMESPACE, "/", escaped_server_account_name, NULL);

                    if (!gconf_client_dir_exists(m_gconfclient, transport_account_key, NULL)) {

                    g_free(transport_account_key);

                    g_free(escaped_server_account_name);

                gchar* escaped_account_id = gconf_escape_key(unescaped_account_id, strlen(unescaped_account_id));

                QString accountId = "MO_"+QString::fromUtf8(escaped_account_id);

                g_free(escaped_account_id);

                gchar* name_key = g_strconcat(account_key, "/", MODESTENGINE_ACCOUNT_DISPLAY_NAME, NULL);

                gchar* account_name = gconf_client_get_string(m_gconfclient, name_key, NULL);

                QString accountName = QString::fromUtf8(account_name);

                g_free(account_name);

                gchar* email_key = g_strconcat(account_key, "/", MODESTENGINE_ACCOUNT_EMAIL, NULL);

                gchar* email = gconf_client_get_string(m_gconfclient, email_key, NULL);

                QString accountAddress = QString::fromUtf8(email);

                g_free(email);

                // Check if newly added account is default account

                if (!strncmp(default_account_id, unescaped_account_id, strlen(default_account_id))) {

            g_free(unescaped_account_id);

        g_free(default_account_id);

    Q_UNUSED(sortOrder)

    Q_UNUSED(limit)

    Q_UNUSED(offset)