/*
 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
 * All rights reserved.
 * This component and the accompanying materials are made available
 * under the terms of "Eclipse Public License v1.0"
 * which accompanies this distribution, and is available
 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 *
 * Initial Contributors:
 * Nokia Corporation - initial contribution.
 *
 * Contributors:
 *
 * Description: NMail Application Launcher interface used for interfacing between
 *              QT highway and other applications
 *
 */

//  INCLUDES
#include "nmuiheaders.h"

//  CONSTANTS
static const QString emailSendSubjectKey = "subject";
static const QString emailSendToKey = "to";
static const QString emailSendCcKey = "cc";
static const QString emailSendBccKey = "bcc";


/*!
    \class NmStartParamDataHelper
    \brief A helper class for processing the data given to the actual service.
*/
class NmStartParamDataHelper
{
public:

    /*!
        Class constructor.
    */
    inline NmStartParamDataHelper()
    : mSubject(0),
      mToAddresses(0),
      mCcAddresses(0),
      mBccAddresses(0),
      mAttachmentList(0),
      mEditorStartMode(NmUiEditorCreateNew)
    {
    }

    /*!
        Class destructor.
    */
    inline ~NmStartParamDataHelper()
    {
    }

    /*!
        Extracts the data from the given QVariant into the class members.
        \param data QVariant containing the data.
        \return True if success, false otherwise.
    */
    inline bool extractData(const QVariant &data)
    {
        QVariant::Type dataType = data.type();
        bool success = false;

        switch (dataType) {
            case QVariant::String: {
                // The given data contains a single attachment.
                QString attachment = data.toString();
                mAttachmentList = new QStringList(attachment);
                success = true;
                break;
            }
            case QVariant::StringList: {
                // The given data contains a list of attachments.
                QStringList attachmentList = data.toStringList();
                mAttachmentList = new QStringList(attachmentList);
                success = true;
                break;
            }
            case QVariant::Map: {
                // The given data may contain a mail subject and recipient lists.
                QMap<QString, QVariant> map = data.toMap();
                success = processMap(map);
                break;
            }
            default: {
                // Data type not supported!
                NMLOG("NmStartParamDataHelper::extractData(): Data type not supported!");
                break;
            }
        } // switch ()

        // Determine the editor start mode.
        if (mToAddresses || mCcAddresses || mBccAddresses) {
            mEditorStartMode = NmUiEditorMailto;
        }
        else if (mAttachmentList) {
            mEditorStartMode = NmUiEditorCreateNew;
        }

        return success;
    }

    /*!
        Deletes the class members. Must be used if NmUiStartParam does not
        take ownership of the members.
    */
    inline void deleteData()
    {
        delete mSubject;
        mSubject = 0;

        if (mToAddresses) {
            qDeleteAll(*mToAddresses);
            delete mToAddresses;
            mToAddresses = 0;
        }

        if (mCcAddresses) {
            qDeleteAll(*mCcAddresses);
            delete mCcAddresses;
            mCcAddresses = 0;
        }

        if (mBccAddresses) {
            qDeleteAll(*mBccAddresses);
            delete mBccAddresses;
            mBccAddresses = 0;
        }

        delete mAttachmentList;
        mAttachmentList = 0;
    }


private:

    /*!
        Extracts the data from the given map into the class members.
        \param map The map to extract the data from.
        \return True if success, false otherwise.
    */
    inline bool processMap(const QMap<QString, QVariant> &map)
    {
        QMap<QString, QVariant>::const_iterator i = map.constBegin();
        QString key;
        QVariant value;
        
        while (i != map.constEnd()) {
            key = i.key();
            value = i.value();
            
            if (!key.compare(emailSendSubjectKey, Qt::CaseInsensitive) &&
                value.type() == QVariant::String) {
                // Extract the mail subject.
                if (mSubject) {
                    // A subject string has already been extracted! Discard the
                    // old subject.
                    delete mSubject;
                }

                mSubject = new QString(value.toString());
            }
            else if (!key.compare(emailSendToKey, Qt::CaseInsensitive)) {
                // Extract the "to" recipients.
                addAddressesToList(value, &mToAddresses);
            }
            else if (!key.compare(emailSendCcKey, Qt::CaseInsensitive)) {
                // Extract the "cc" recipients.
                addAddressesToList(value, &mCcAddresses);
            }
            else if (!key.compare(emailSendBccKey, Qt::CaseInsensitive)) {
                // Extract the "bcc" recipients.
                addAddressesToList(value, &mBccAddresses);
            }

            ++i;
        }

        // In principle it is ok even if the map does not contain any data e.g.
        // in a case where the editor view needs to be opened without any
        // predefined data. Therefore, we always return true.
        return true;
    }

    /*!
        Appends the given addresses into the given list.
        \param address The addresses to append.
        \param list The list where the addresses are appended to.
    */
    inline void addAddressesToList(const QVariant &addresses,
                                   QList<NmAddress*> **list)
    {
      
        if (!list) {
            // Invalid argument!
            return;
        }

        QVariant::Type dataType = addresses.type();
        QList<NmAddress*> foundAddresses;

        switch (dataType) {
            case QVariant::String: {
                // A single address.
                NmAddress *address = new NmAddress(addresses.toString());
                foundAddresses.append(address);
                break;
            }
            case QVariant::StringList: {
                // A list of addresses.
                QStringList addressList = addresses.toStringList();

                foreach (QString addressAsString, addressList) {
                    NmAddress *address = new NmAddress(addressAsString);
                    foundAddresses.append(address);
                }

                break;
            }
            default: {
                break;
            }
        }

        if (foundAddresses.count()) {
            // Append the found addresses into the given list.
            if (!(*list)) {
                *list = new QList<NmAddress*>();
            }

            (*list)->append(foundAddresses);
        }
    }


public: // Data

    QString *mSubject; // Not owned.
    QList<NmAddress*> *mToAddresses; // Not owned.
    QList<NmAddress*> *mCcAddresses; // Not owned.
    QList<NmAddress*> *mBccAddresses; // Not owned.
    QStringList *mAttachmentList; // Not owned.
    NmUiEditorStartMode mEditorStartMode;
};



/*!
    \class NmSendServiceInterface
    \brief NMail application service interface which provides an email sending
           interface for other application using the Qt Highway. 
*/

/*!
    Class constructor.
*/
NmSendServiceInterface::NmSendServiceInterface(QObject *parent,
                                               NmUiEngine &uiEngine,
                                               NmApplication *application)
#ifndef NM_WINS_ENV
    : XQServiceProvider(QLatin1String("com.nokia.symbian.IMessage.Send"), parent),
#else
    : QObject(parent),
#endif
      mApplication(application),
      mUiEngine(uiEngine),
      mAsyncReqId(0)
{
#ifndef NM_WINS_ENV
    publishAll();
#endif
}


/*!
    Class desctructor.
*/
NmSendServiceInterface::~NmSendServiceInterface()
{
}


/*!
    Queries the user for a mailbox to use.
    \param mailboxId Where the ID of the selected mailbox is set.
    \return True if a mailbox was selected, false otherwise.
*/
bool NmSendServiceInterface::selectMailbox(NmId& mailboxId)
{
	NmMailboxSelectionDialog *dialog =
	    new NmMailboxSelectionDialog(mUiEngine.mailboxListModel());
	bool ok = dialog->exec(mailboxId);
	delete dialog;
	return ok;
}


/*!
    Used for sending email messages from external applications. Used by the
    Share UI. In addition, the interface can be used to send email to a contact
    from another application. The method sets the given data (e.g. recipients,
    attachments) to a mail composer (editor) view and displays it.

    \param data If used by Share UI, will contain the list of filenames to
                attach. Can also contain a map with key value pairs containing
                subject and recipient data. 
*/
void NmSendServiceInterface::send(QVariant data)
{
    NMLOG("NmSendServiceInterface::send()");

#ifndef NM_WINS_ENV
    // Make sure the NMail application is on the foreground.
    XQServiceUtil::toBackground(false);
    HbMainWindow *mainWindow = mApplication->mainWindow();
    HbView *currentView = mainWindow->currentView();

    // Hide the current view.
    if (currentView) {
        currentView->hide();
    }

    // Check the given data.
    NmStartParamDataHelper dataHelper;
    bool validData = dataHelper.extractData(data);

    NmMailboxListModel &mailboxListModel = mUiEngine.mailboxListModel();
    const int count = mailboxListModel.rowCount();
    NmId mailboxId(0);
    bool launchEditor(true);

    if (!validData) {
        // Failed to extract the data!
        NMLOG("NmSendServiceInterface::send(): Failed to process the given data!");
        launchEditor = false;
    }
    else if (count == 0) {
        // No mailboxes.
        HbMessageBox note(hbTrId("txt_mail_dialog_no_mailboxes_defined"),
                          HbMessageBox::MessageTypeInformation);
        note.setTimeout(HbMessageBox::NoTimeout);
        note.exec();
        launchEditor = false;
    }
    else if (count == 1) {
        // A single mailbox exists.
        QModelIndex modelIndex = mailboxListModel.index(0, 0);
        QVariant mailbox(mailboxListModel.data(modelIndex));
        NmMailboxMetaData *mailboxMetaData = mailbox.value<NmMailboxMetaData*>();
        mailboxId = mailboxMetaData->id();
    }
    else if (count > 1 && !selectMailbox(mailboxId)) {
        // More than one mailboxes exist but the user cancelled the mailbox
        // selection dialog.
        launchEditor = false;
    }

    mAsyncReqId = setCurrentRequestAsync();
    
    if (launchEditor) {
        // Make the previous view visible again.
        if (currentView) {
            currentView->show();
        }

        NmUiStartParam *startParam = new NmUiStartParam(
            NmUiViewMessageEditor,
            mailboxId,
            0, // folder id
            0, // message id
            dataHelper.mEditorStartMode, // editor start mode
            dataHelper.mToAddresses, // address list
            dataHelper.mAttachmentList, // attachment list
            true, // start as service
            dataHelper.mSubject, // message subject
            dataHelper.mCcAddresses, // list containing cc recipient addresses
            dataHelper.mBccAddresses // list containing bcc recipient addresses
        );

        mApplication->enterNmUiView(startParam);
        completeRequest(mAsyncReqId, 1);
    } 
    else {
        // Delete the extracted data since the editor was not launched and thus
        // NmUiStartParam did not take the ownership of the data.
        dataHelper.deleteData();

        // If the service was started as embedded, do not hide the app.
		if (!XQServiceUtil::isEmbedded()) {
			XQServiceUtil::toBackground(true);
		}

        completeRequest(mAsyncReqId, 0);

        // If started as service, the application must be closed now.
        if (XQServiceUtil::isService()) {
            connect(this, SIGNAL(returnValueDelivered()),
                    mApplication, SLOT(delayedExitApplication()));
        }
        else {
            // Make the previous view visible again.
            if (currentView) {
                currentView->show();
            }
        }
    }
#endif /* NM_WINS_ENV */
}


// End of file.