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

**

** 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 "qmessage.h"

#include "qmessagecontentcontainer_p.h"

#include "qmfhelpers_p.h"

#include "qmessage_p.h"

#include <qmailnamespace.h>

#include <QCoreApplication>

#include <QFileInfo>

#include <QRegExp>

using namespace QTM_PREPEND_NAMESPACE(QmfHelpers);

// This class has friend access to QMailMessage

// and hsould not be within QTM_NAMESPACE

struct QMailStorePrivate

{

    static inline void setUnmodified(QMailMessage *msg)

    {

        msg->setUnmodified();

    }

};

QTM_BEGIN_NAMESPACE

Q_SCOPED_STATIC_DEFINE(QMessagePrivate::StandardFolderMap,QMessagePrivate,standardFolderMap);

QMessageFolderId QMessagePrivate::standardFolderId(QMessage::StandardFolder folder)

{

    StandardFolderMap::const_iterator it = standardFolderMap()->find(folder);

    if (it == standardFolderMap()->end()) {

        const char *path((folder == QMessage::InboxFolder ? "Inbox" : 

                         (folder == QMessage::OutboxFolder ? "Outbox" : 

                         (folder == QMessage::DraftsFolder ? "Drafts" : 

                         (folder == QMessage::SentFolder ? "Sent" : 

                         (folder == QMessage::TrashFolder ? "Trash" : ""))))));

        // Find the ID for this standard folder

        QMessageFolderFilter pathFilter(QMessageFolderFilter::byPath(path));

        QMessageFolderFilter accountFilter(QMessageFolderFilter::byParentAccountId(QMessageAccountId()));

        QMessageFolderId folderId(QMessageManager().queryFolders(pathFilter & accountFilter).first());

        it = standardFolderMap()->insert(folder, folderId);

    }

    return *it;

}

QMessage::StandardFolder QMessagePrivate::standardFolder(QMessageFolderId folderId)

{

    StandardFolderMap::const_iterator it = standardFolderMap()->begin(), end = standardFolderMap()->end();

    for ( ; it != end; ++it) {

        if (it.value() == folderId) {

            return it.key();

        }

    }

    return QMessage::InboxFolder;

}

QMessage QMessagePrivate::convert(const QMailMessage &message)

{

    QMessage result;

    result.d_ptr->_message = message;

    return result;

}

QMailMessage QMessagePrivate::convert(const QMessage &message)

{

    return message.d_ptr->_message;

}

QMailMessage *QMessagePrivate::convert(QMessage *message)

{

    return &message->d_ptr->_message;

}

/*

const QMailMessage *QMessagePrivate::convert(const QMessage *message)

{

    return &message->d_ptr->_message;

}

*/

void QMessagePrivate::setStandardFolder(QMessage& message, QMessage::StandardFolder sf)

{

    QMessageFolderId folderId(standardFolderId(sf));

    message.d_ptr->_message.setParentFolderId(QmfHelpers::convert(folderId));

}

namespace QmfHelpers {

QMessage convert(const QMailMessage &message)

{

    return QMessagePrivate::convert(message);

}

QMailMessage convert(const QMessage &message)

{

    return QMessagePrivate::convert(message);

}

QMailMessage *convert(QMessage *message)

{

    return QMessagePrivate::convert(message);

}

/*

const QMailMessage *convert(const QMessage *message)

{

    return QMessagePrivate::convert(message);

}

*/

}

namespace {

struct TextPartLocator

{

    QMailMessagePart::Location _location;

    bool operator()(const QMailMessagePart &part)

    {

        if (part.contentType().type().toLower() == "text") {

            _location = part.location();

            return false;

        }

        return true;

    }

};

struct PartLocator

{

    QMailMessagePart::Location _location;

    const QMailMessagePart *_part;

    PartLocator(const QMailMessagePart::Location &location) : _location(location), _part(0) {}

    bool operator()(const QMailMessagePart &part)

    {

        if (part.location() == _location) {

            _part = ∂

            return false;

        }

        return true;

    }

};

struct AttachmentLocator

{

    QList<QMailMessagePart::Location> _locations;

    bool _foundText;

    AttachmentLocator() : _foundText(false) {}

    bool operator()(const QMailMessagePart &part)

    {

        if (!_foundText && part.contentType().type().toLower() == "text") {

            _foundText = true;

        } else if (part.multipartType() == QMailMessagePart::MultipartNone) {

            _locations.append(part.location());

        }

        return true;

    }

};

QByteArray charsetFor(const QString &input)

{

    QByteArray result(QMessage::preferredCharsetFor(input));

    if (result.isEmpty()) {

        result = "UTF-8";

    }

    return result;

}

}

QMessage::QMessage()

    : d_ptr(new QMessagePrivate)

{

    setDerivedMessage(this);

    QMailStorePrivate::setUnmodified(&d_ptr->_message);

}

QMessage::QMessage(const QMessageId& id)

    : d_ptr(new QMessagePrivate)

{

    *this = QMessageManager().message(id);

    setDerivedMessage(this);

    QMailStorePrivate::setUnmodified(&d_ptr->_message);

}

QMessage::QMessage(const QMessage &other)

    : QMessageContentContainer(),

      d_ptr(new QMessagePrivate)

{

    this->operator=(other);

    setDerivedMessage(this);

    QMailStorePrivate::setUnmodified(&d_ptr->_message);

}

QMessage& QMessage::operator=(const QMessage& other)

{

    if (&other != this) {

        QMessageContentContainer::operator=(other);

        d_ptr->_message = other.d_ptr->_message;

        setDerivedMessage(this);

    }

    return *this;

}

QMessage::~QMessage()

{

    delete d_ptr;

}

QMessageId QMessage::id() const

{

    return convert(d_ptr->_message.id());

}

QMessage::Type QMessage::type() const

{

    return convert(d_ptr->_message.messageType());

}

void QMessage::setType(Type t)

{

    d_ptr->_message.setMessageType(convert(t));

}

QMessageAccountId QMessage::parentAccountId() const

{

    return convert(d_ptr->_message.parentAccountId());

}

void QMessage::setParentAccountId(const QMessageAccountId &accountId)

{

    d_ptr->_message.setParentAccountId(convert(accountId));    

}

QMessageFolderId QMessage::parentFolderId() const

{

    return convert(d_ptr->_message.parentFolderId());

}

QMessage::StandardFolder QMessage::standardFolder() const

{

    if (!d_ptr->_message.parentFolderId().isValid())

        return QMessage::DraftsFolder;

    return QMessagePrivate::standardFolder(convert(d_ptr->_message.parentFolderId()));

}

QMessageAddress QMessage::from() const

{

    return convert(d_ptr->_message.from());

}

void QMessage::setFrom(const QMessageAddress &address)

{

    d_ptr->_message.setFrom(convert(address));

}

QString QMessage::subject() const

{

    return d_ptr->_message.subject();

}

void QMessage::setSubject(const QString &s)

{

    d_ptr->_message.setSubject(s);

}

QDateTime QMessage::date() const

{

    return d_ptr->_message.date().toLocalTime();

}

void QMessage::setDate(const QDateTime &d)

{

    d_ptr->_message.setDate(QMailTimeStamp(d));

}

QDateTime QMessage::receivedDate() const

{

    return d_ptr->_message.receivedDate().toLocalTime();

}

void QMessage::setReceivedDate(const QDateTime &d)

{

    d_ptr->_message.setReceivedDate(QMailTimeStamp(d));

}

QMessageAddressList QMessage::to() const

{

    return convert(d_ptr->_message.to());

}

void QMessage::setTo(const QMessageAddressList& toList)

{

    d_ptr->_message.setTo(convert(toList));

}

void QMessage::setTo(const QMessageAddress& address)

{

    d_ptr->_message.setTo(convert(address));

}

QMessageAddressList QMessage::cc() const

{

    return convert(d_ptr->_message.cc());

}

void QMessage::setCc(const QMessageAddressList& ccList)

{

    d_ptr->_message.setCc(convert(ccList));

}

QMessageAddressList QMessage::bcc() const

{

    return convert(d_ptr->_message.bcc());

}

void QMessage::setBcc(const QMessageAddressList& bccList)

{

    d_ptr->_message.setBcc(convert(bccList));

}

QMessage::StatusFlags QMessage::status() const

{

    return convert(d_ptr->_message.status());

}

void QMessage::setStatus(QMessage::StatusFlags newStatus)

{

    d_ptr->_message.setStatus(convert(newStatus));

}

void QMessage::setStatus(QMessage::Status flag, bool set)

{

    d_ptr->_message.setStatus(convert(flag), set);

}

QMessage::Priority QMessage::priority() const

{

    quint64 status(d_ptr->_message.status());

    if (status & highPriorityMask()) {

        return QMessage::HighPriority;

    } else if (status & lowPriorityMask()) {

        return QMessage::LowPriority;

    }

    return QMessage::NormalPriority;

}

void QMessage::setPriority(Priority newPriority)

{

    quint64 setMask(0);

    quint64 unsetMask(0);

    if (newPriority == QMessage::HighPriority) {

        setMask = highPriorityMask();

        unsetMask = lowPriorityMask();

    } else if (newPriority == QMessage::LowPriority) {

        unsetMask = highPriorityMask();

        setMask = lowPriorityMask();

    } else {

        unsetMask = (highPriorityMask() | lowPriorityMask());

    }

    if (setMask) {

        d_ptr->_message.setStatus(setMask, true);

    }

    if (unsetMask) {

        d_ptr->_message.setStatus(unsetMask, false);

    }

}

int QMessage::size() const

{

    if ((d_ptr->_message.status() & QMailMessage::LocalOnly) && 

        (d_ptr->_message.dataModified() ||

         d_ptr->_message.contentModified())) {

        // We need to update the size estimate for this message

        d_ptr->_message.setSize(static_cast<int>(d_ptr->_message.indicativeSize()) * 1024);

    }

    return static_cast<int>(d_ptr->_message.size());

}

QMessageContentContainerId QMessage::bodyId() const

{

    if (d_ptr->_message.hasBody()) {

        return QmfHelpers::bodyId(d_ptr->_message.id());

    }

    // Return the first text part

    TextPartLocator locator;

    d_ptr->_message.foreachPart<TextPartLocator&>(locator);

    return convert(locator._location);

}

void QMessage::setBody(const QString &bodyText, const QByteArray &mimeType)

{

    QByteArray mainType("text");

    QByteArray subType("plain");

    QByteArray charset;

    int index = mimeType.indexOf("/");

    if (index != -1) {

        mainType = mimeType.left(index).trimmed();

        subType = mimeType.mid(index + 1).trimmed();

        index = subType.indexOf(";");

        if (index != -1) {

            QString remainder = subType.mid(index + 1);

            subType = subType.left(index).trimmed();

            QRegExp charsetPattern("charset=(\\S+)");

            index = charsetPattern.indexIn(remainder);

            if (index != -1) {

                charset = charsetPattern.cap(1).toLatin1();

            }

        }

    }

    if (charset.isEmpty()) {

        charset = charsetFor(bodyText);

    }

    QMailMessageContentType ct;

    ct.setType(mainType);

    ct.setSubType(subType);

    ct.setCharset(charset);

    QMailMessageBody textBody(QMailMessageBody::fromData(bodyText, ct, QMailMessageBody::Base64));

    if (d_ptr->_message.multipartType() == QMailMessage::MultipartNone) {

        // Replace the body with this data

        d_ptr->_message.setBody(textBody);

    } else {

        // Replace any existing text with this part

        TextPartLocator locator;

        d_ptr->_message.foreachPart<TextPartLocator&>(locator);

        if (locator._location.isValid()) {

            // Update the existing body text part to contain the new text

            QMailMessagePart &bodyPart = d_ptr->_message.partAt(locator._location);

            bodyPart.setBody(textBody);

        } else {

            // Insert the text as the new first part

            QMailMessageContentDisposition cd(QMailMessageContentDisposition::Inline);

            QMailMessagePart part(QMailMessagePart::fromData(bodyText, ct, cd, QMailMessageBody::Base64));

            d_ptr->_message.prependPart(part);

        }

    }

}

void QMessage::setBody(QTextStream &in, const QByteArray &mimeType)

{

    // Note we have to read the data from the stream, in order to determine the relevant charset

    setBody(in.readAll(), mimeType);

}

QMessageContentContainerIdList QMessage::attachmentIds() const

{

    // Return any non-multipart parts excluding the first text part

    AttachmentLocator locator;

    d_ptr->_message.foreachPart<AttachmentLocator&>(locator);

    return convert(locator._locations);

}

void QMessage::appendAttachments(const QStringList &fileNames)

{

    if (d_ptr->_message.multipartType() == QMailMessage::MultipartNone) {

        if (d_ptr->_message.hasBody()) {

            // Move the existing body to become the first part

            QMailMessageContentType ct(d_ptr->_message.contentType());