/****************************************************************************

**

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Mobility Components.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "modestengine_maemo_p.h"

#include "maemohelpers_p.h"

#include "qmessage_p.h"

#include "qmessageaccount.h"

#include "qmessageaccount_p.h"

#include "qmessageaccountfilter.h"

#include "qmessageaccountfilter_p.h"

#include "qmessagefolder_p.h"

#include "qmessagestore_p.h"

#include "qmessageservice_maemo_p.h"

#include "qmessagecontentcontainer_maemo_p.h"

#include <QUrl>

#include <QtDBus>

#include <QFileSystemWatcher>

#include <QTimer>

#include <dbus/dbus.h>

#include <QDebug>

#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;

}

QTM_BEGIN_NAMESPACE

/* configuration key definitions for modest */

#define MODESTENGINE_ACCOUNT_NAMESPACE         "/apps/modest/accounts"

#define MODESTENGINE_SERVER_ACCOUNT_NAMESPACE  "/apps/modest/server_accounts"

#define MODESTENGINE_DEFAULT_ACCOUNT           "/apps/modest/default_account"

#define MODESTENGINE_ACCOUNT_ENABLED           "enabled"

#define MODESTENGINE_ACCOUNT_DISPLAY_NAME      "display_name"

#define MODESTENGINE_ACCOUNT_FULLNAME          "fullname"

#define MODESTENGINE_ACCOUNT_EMAIL             "email"

#define MODESTENGINE_ACCOUNT_STORE_ACCOUNT     "store_account"

#define MODESTENGINE_ACCOUNT_TRANSPORT_ACCOUNT "transport_account"

#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

Q_GLOBAL_STATIC(ModestEngine,modestEngine);

ModestEngine::ModestEngine()

 : m_queryIds(0)

{

    qWarning() << "ModestEngine::ModestEngine Starting to initialize";

    g_type_init();

    m_gconfclient = gconf_client_get_default();

    if (!m_gconfclient) {

        qWarning("qtmessaging: could not get gconf client");

    } else {

        updateEmailAccounts();

    }

    qWarning() << "ModestEngine::ModestEngine Connecting to Modest DBus Interface";

    // Setup DBus Interface for Modest

    m_ModestDBusInterface = new QDBusInterface(MODEST_DBUS_SERVICE,

                                               MODEST_DBUS_OBJECT,

                                               MODEST_DBUS_IFACE,

                                               QDBusConnection::sessionBus(),

                                               this);

    if (m_ModestDBusInterface->isValid()) {

        qWarning() << "ModestEngine::ModestEngine Connected to Modest DBus Interface";

    } else {

        qWarning() << "ModestEngine::ModestEngine Unable to connect to Modest DBus Interface";

    }

    // 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)));

    qWarning() << "ModestEngine::ModestEngine Connecting to Qt Mobility Modest Plugin DBus Interface";

    // 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);

    if (m_QtmPluginDBusInterface->isValid()) {

        qWarning() << "ModestEngine::ModestEngine Connected to Qt Mobility Modest Plugin DBus Interface";

    } else {

        qWarning() << "ModestEngine::ModestEngine Unable to connect to Qt Mobility Modest Plugin DBus Interface";

    }

    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*)));

    qWarning() << "ModestEngine::ModestEngine Initialized successfully";

}

ModestEngine::~ModestEngine()

{

    g_object_unref(m_gconfclient);

    m_gconfclient=NULL;

}

ModestEngine* ModestEngine::instance()

{

    return modestEngine();

}

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

{

    MessagingModestMessage modestMessage;

    if (!m_QtmPluginDBusInterface->isValid() || iAccounts.isEmpty()) {

        return 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 = MessagingModestMessagePriorityNotDefined;

    }

    return modestMessage;

}

void ModestEngine::updateEmailAccounts() const

{

    iDefaultEmailAccountId = QMessageAccountId();

    iAccounts.clear();

    GSList *accounts;

    GError *error = NULL;

    accounts = gconf_client_all_dirs(m_gconfclient, MODESTENGINE_ACCOUNT_NAMESPACE, &error);

    if (error) {

#ifdef MESSAGING_DEBUG

        qDebug("qtmessaging: failed to list '%s': '%s'", MODESTENGINE_ACCOUNT_NAMESPACE, error->message);

#endif

        g_error_free(error);

    } else {

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

        if (error) {

            qWarning("qtmessaging: failed to get '%s': %s", MODESTENGINE_DEFAULT_ACCOUNT, error->message);

            g_error_free(error);

        }

        const size_t prefix_len = strlen(MODESTENGINE_ACCOUNT_NAMESPACE) + 1;

        GSList *iter = accounts;

        while (iter) {

            if (!(iter->data)) {

                iter = iter->next;

                continue;

            }

            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);

            gboolean account_ok = FALSE;

            // Check if account is enabled

            if (account_key) {

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

                account_ok = gconf_client_get_bool(m_gconfclient, key, NULL);

                g_free(key);

            }

            // Check if account store is defined

            if (account_ok) {

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

                gchar* server_account_name = gconf_client_get_string(m_gconfclient, key, NULL);

                if (server_account_name) {

                    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)) {

                        account_ok = FALSE;

                    }

                    g_free(store_account_key);

                    g_free(escaped_server_account_name);

                }

                g_free(key);

            }

            // Check if account transport is defined

            if (account_ok) {

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

                gchar* server_account_name = gconf_client_get_string(m_gconfclient, key, NULL);

                if (server_account_name) {

                    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)) {

                        account_ok = FALSE;

                    }

                    g_free(transport_account_key);

                    g_free(escaped_server_account_name);

                }

                g_free(key);

            }

            if (account_ok) {

                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);

                g_free(name_key);

                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);

                g_free(email_key);

                QMessageAccount account = QMessageAccountPrivate::from(QMessageAccountId(accountId),

                                                                       accountName,

                                                                       QMessageAddress(QMessageAddress::Email, accountAddress),

                                                                       QMessage::Email);

                iAccounts.insert(accountId, account);

                // Check if newly added account is default account

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

                    iDefaultEmailAccountId = accountId;

                }

            }

            g_free(unescaped_account_id);

            g_free(iter->data);

            iter->data = NULL;

            iter = g_slist_next(iter);

        }

        // strings were freed in while loop

        // => it's enough to just free accounts list

        g_slist_free(accounts);

        g_free(default_account_id);

    }

}

QMessageAccountIdList ModestEngine::queryAccounts(const QMessageAccountFilter &filter, const QMessageAccountSortOrder &sortOrder,

                                                  uint limit, uint offset, bool &isFiltered, bool &isSorted) const

{

    Q_UNUSED(sortOrder)

    Q_UNUSED(limit)

    Q_UNUSED(offset)