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

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

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

#include "qmailaddress.h"

#include "qmailcodec.h"

#include "qmaillog.h"

#include "qmailnamespace.h"

#include "qmailtimestamp.h"

#include "longstring_p.h"

#ifndef QTOPIAMAIL_PARSING_ONLY

#include "qmailaccount.h"

#include "qmailfolder.h"

#include "qmailstore.h"

#endif

#include <qcryptographichash.h>

#include <qdir.h>

#include <qfile.h>

#include <qfileinfo.h>

#include <qregexp.h>

#include <qtextstream.h>

#include <qtextcodec.h>

#include <QTextCodec>

#include <QtDebug>

#include <stdlib.h>

#include <limits.h>

#if defined(Q_OS_WIN) && defined(_WIN32_WCE)

#include <cctype>

#else

#include <ctype.h>

#endif

static const QByteArray internalPrefix()

{

    static const QByteArray prefix("X-qtopiamail-internal-");

    return prefix;

}

template<typename CharType>

inline char toPlainChar(CharType value) { return value; }

template<>

inline char toPlainChar<QChar>(QChar value) { return static_cast<char>(value.unicode() & 0x7f); }

template<typename CharType>

inline bool asciiRepresentable(const CharType& value) { return ((value <= 127) && (value >= 0)); }

template<>

inline bool asciiRepresentable<unsigned char>(const unsigned char& value) { return (value <= 127); }

template<>

inline bool asciiRepresentable<signed char>(const signed char& value) { return (value >= 0); }

// The correct test for char depends on whether the platform defines char as signed or unsigned

// Default to signed char:

template<bool SignedChar>

inline bool asciiRepresentableChar(const char& value) { return asciiRepresentable(static_cast<signed char>(value)); }

template<>

inline bool asciiRepresentableChar<false>(const char& value) { return asciiRepresentable(static_cast<unsigned char>(value)); }

template<>

inline bool asciiRepresentable<char>(const char& value) { return asciiRepresentableChar<(SCHAR_MIN < CHAR_MIN)>(value); }

template<typename StringType>

QByteArray to7BitAscii(const StringType& src)

{

    QByteArray result;

    result.reserve(src.length());

    typename StringType::const_iterator it = src.begin();

    for (const typename StringType::const_iterator end = it + src.length(); it != end; ++it)

        if (asciiRepresentable(*it))

            result.append(toPlainChar(*it));

    return result;

}

// Parsing functions

static int insensitiveIndexOf(const QByteArray& content, const QByteArray& container, int from = 0)

{

    const char* const matchBegin = content.constData();

    const char* const matchEnd = matchBegin + content.length();

    const char* const begin = container.constData();

    const char* const end = begin + container.length() - (content.length() - 1);

    const char* it = begin + from;

    while (it < end)

    {

        if (toupper(*it++) == toupper(*matchBegin))

        {

            const char* restart = it;

            // See if the remainder matches

            const char* searchIt = it;

            const char* matchIt = matchBegin + 1;

            do 

            {

                if (matchIt == matchEnd)

                    return ((it - 1) - begin);

                // We may find the next place to search in our scan

                if ((restart == it) && (*searchIt == *(it - 1)))

                    restart = searchIt;

            }

            while (toupper(*searchIt++) == toupper(*matchIt++));

            // No match

            it = restart;

        }

    }

    return -1;

}

static bool insensitiveEqual(const QByteArray& lhs, const QByteArray& rhs)

{

    if (lhs.isNull() || rhs.isNull())

        return (lhs.isNull() && rhs.isNull());

    if (lhs.length() != rhs.length())

        return false;

    return insensitiveIndexOf(lhs, rhs) == 0;

}

static QByteArray charsetForInput(const QString& input)

{

    // See if this input needs encoding

    bool latin1 = false;

    const QChar* it = input.constData();

    const QChar* const end = it + input.length();

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

    {

        if ((*it).unicode() > 0xff)

        {

            // Multi-byte characters included - we need to use UTF-8

            return QByteArray("UTF-8");

        }

        else if (!latin1 && ((*it).unicode() > 0x7f))

        {

            // We need encoding from latin-1

            latin1 = true;

        }

    }

    return (latin1? QByteArray("ISO-8859-1") : QByteArray());

}

static QTextCodec* codecForName(const QByteArray& charset, bool translateAscii = true)

{

    QByteArray encoding(charset.toLower());

    if (!encoding.isEmpty())

    {

        int index;

        if (translateAscii && encoding.contains("ascii")) 

        {

            // We'll assume the text is plain ASCII, to be extracted to Latin-1

            encoding = "ISO-8859-1";

        }

        else if ((index = encoding.indexOf('*')) != -1)

        {

            // This charset specification includes a trailing language specifier

            encoding = encoding.left(index);

        }

        return QTextCodec::codecForName(encoding);

    }

    return 0;

}

static QByteArray fromUnicode(const QString& input, const QByteArray& charset)

{

    if (!charset.isEmpty() && (insensitiveIndexOf("ascii", charset) == -1))

    {

        // See if we can convert using the nominated charset

        if (QTextCodec* textCodec = codecForName(charset))

            return textCodec->fromUnicode(input);

        qWarning() << "fromUnicode: unable to find codec for charset:" << charset;

    }

    return to7BitAscii(input.toLatin1());

}

static QString toUnicode(const QByteArray& input, const QByteArray& charset)

{

    if (!charset.isEmpty() && (insensitiveIndexOf("ascii", charset) == -1))

    {

        // See if we can convert using the nominated charset

        if (QTextCodec* textCodec = codecForName(charset))

            return textCodec->toUnicode(input);

        qWarning() << "toUnicode: unable to find codec for charset:" << charset;

    }

    return to7BitAscii(QString::fromLatin1(input.constData(), input.length()));

}

static QMailMessageBody::TransferEncoding encodingForName(const QByteArray& name)

{

    QByteArray ciName = name.toLower();

    if (ciName == "7bit")

        return QMailMessageBody::SevenBit;

    if (ciName == "8bit")

        return QMailMessageBody::EightBit;

    if (ciName == "base64")

        return QMailMessageBody::Base64;

    if (ciName == "quoted-printable")

        return QMailMessageBody::QuotedPrintable;

    if (ciName == "binary")

        return QMailMessageBody::Binary;

    return QMailMessageBody::NoEncoding;

}

static const char* nameForEncoding(QMailMessageBody::TransferEncoding te)

{

    switch( te ) 

    {

        case QMailMessageBody::SevenBit:

            return "7bit";

        case QMailMessageBody::EightBit:

            return "8bit";

        case QMailMessageBody::QuotedPrintable:

            return "quoted-printable";

        case QMailMessageBody::Base64:

            return "base64";

        case QMailMessageBody::Binary:

            return "binary";

        case QMailMessageBody::NoEncoding:

            break;

    }

    return 0;

}

static QMailCodec* codecForEncoding(QMailMessageBody::TransferEncoding te, bool textualData)

{

    switch( te ) 

    {

        case QMailMessageBody::NoEncoding:

        case QMailMessageBody::Binary:

            return new QMailPassThroughCodec();

        case QMailMessageBody::SevenBit:

        case QMailMessageBody::EightBit:

            return (textualData ? static_cast<QMailCodec*>(new QMailLineEndingCodec()) : new QMailPassThroughCodec());

        case QMailMessageBody::QuotedPrintable:

            return new QMailQuotedPrintableCodec(textualData ? QMailQuotedPrintableCodec::Text : QMailQuotedPrintableCodec::Binary, QMailQuotedPrintableCodec::Rfc2045);

        case QMailMessageBody::Base64:

            return new QMailBase64Codec(textualData ? QMailBase64Codec::Text : QMailBase64Codec::Binary);

    }

    return 0;

}

static QMailCodec* codecForEncoding(QMailMessageBody::TransferEncoding te, const QMailMessageContentType& content)

{

    return codecForEncoding(te, insensitiveEqual(content.type(), "text"));

}

//  Needs an encoded word of the form =?charset?q?word?=

static QString decodeWord(const QByteArray& encodedWord)

{

    QString result;

    int index[4];

    // Find the parts of the input

    index[0] = encodedWord.indexOf("=?");

    if (index[0] != -1)

    {

        index[1] = encodedWord.indexOf('?', index[0] + 2);

        if (index[1] != -1)

        {

            index[2] = encodedWord.indexOf('?', index[1] + 1);

            index[3] = encodedWord.lastIndexOf("?=");

            if ((index[2] != -1) && (index[3] > index[2]))

            {

                QByteArray charset = QMail::unquoteString(encodedWord.mid(index[0] + 2, (index[1] - index[0] - 2)));

                QByteArray encoding = encodedWord.mid(index[1] + 1, (index[2] - index[1] - 1)).toUpper();

                QByteArray encoded = encodedWord.mid(index[2] + 1, (index[3] - index[2] - 1));

                if (encoding == "Q")

                {

                    QMailQuotedPrintableCodec codec(QMailQuotedPrintableCodec::Text, QMailQuotedPrintableCodec::Rfc2047);

                    result = codec.decode(encoded, charset);

                }

                else if (encoding == "B")

                {

                    QMailBase64Codec codec(QMailBase64Codec::Binary);

                    result = codec.decode(encoded, charset);

                }

            }

        }

    }

    if (result.isEmpty())

        result = encodedWord;

    return result;

}

static QByteArray generateEncodedWord(const QByteArray& codec, char encoding, const QByteArray& text)

{

    QByteArray result("=?");

    result.append(codec);

    result.append('?');

    result.append(encoding);

    result.append('?');

    result.append(text);

    result.append("?=");

    return result;

}

static QByteArray generateEncodedWord(const QByteArray& codec, char encoding, const QList<QByteArray>& list)

{

    QByteArray result;

    foreach (const QByteArray& item, list)

    {

        if (!result.isEmpty())

            result.append(' ');

        result.append(generateEncodedWord(codec, encoding, item));

    }

    return result;

}

static QList<QByteArray> split(const QByteArray& input, const QByteArray& separator)

{

    QList<QByteArray> result;

    int index = -1;

    int lastIndex = -1;

    do

    {

        lastIndex = index;

        index = input.indexOf(separator, lastIndex + 1);

        int offset = (lastIndex == -1 ? 0 : lastIndex + separator.length());

        int length = (index == -1 ? -1 : index - offset);

        result.append(input.mid(offset, length));

    } while (index != -1);

    return result;

}

static QByteArray encodeWord(const QString &text, const QByteArray& cs, bool* encoded)

{

    // Do we need to encode this input?

    QByteArray charset(cs);

    if (charset.isEmpty())

        charset = charsetForInput(text);

    if (encoded)

        *encoded = true;

    // We can't allow more than 75 chars per encoded-word, including the boiler plate...

    int maximumEncoded = 75 - 7 - charset.length();

    // If this is an encodedWord, we need to include any whitespace that we don't want to lose

    if (insensitiveIndexOf("utf-8", charset) == 0)

    {

        QMailBase64Codec codec(QMailBase64Codec::Binary, maximumEncoded);

        QByteArray encoded = codec.encode(text, charset);

        return generateEncodedWord(charset, 'B', split(encoded, QMailMessage::CRLF));

    }

    else if (insensitiveIndexOf("iso-8859-", charset) == 0)

    {

        QMailQuotedPrintableCodec codec(QMailQuotedPrintableCodec::Text, QMailQuotedPrintableCodec::Rfc2047, maximumEncoded);

        QByteArray encoded = codec.encode(text, charset);

        return generateEncodedWord(charset, 'Q', split(encoded, "=\n"));

    }

    if (encoded)

        *encoded = false;

    return to7BitAscii(text);

}

static QString decodeWordSequence(const QByteArray& str)

{

    static const QRegExp whitespace("^\\s+$");

    QString out;

    // Any idea why this isn't matching?

    //QRegExp encodedWord("\\b=\\?\\S+\\?\\S+\\?\\S*\\?=\\b");

    QRegExp encodedWord("=\\?\\S+\\?\\S+\\?\\S*\\?=");

    int pos = 0;

    int lastPos = 0;

    int length = str.length();

    while (pos != -1) {

        pos = encodedWord.indexIn(str, pos);

        if (pos != -1) {

            int endPos = pos + encodedWord.matchedLength();

            if ( ((pos == 0) || (::isspace(str[pos - 1]))) &&

                 ((endPos == length) || (::isspace(str[endPos]))) ) {

                QString preceding(str.mid(lastPos, (pos - lastPos)));

                QString decoded = decodeWord(str.mid(pos, (endPos - pos)));

                // If there is only whitespace between two encoded words, it should not be included

                if (!whitespace.exactMatch(preceding))

                    out.append(preceding);

                out.append(decoded);

                pos = endPos;

                lastPos = pos;

            }

            else

                pos = endPos;

        }

    }

    // Copy anything left

    out.append(str.mid(lastPos));

    return out;

}

enum EncodingTokenType

{

    Whitespace,

    Word,

    Quote

};

typedef QPair<const QChar*, int> TokenRange;

typedef QPair<EncodingTokenType, TokenRange> Token;

static Token makeToken(EncodingTokenType type, const QChar* begin, const QChar* end, bool escaped)

{

    return qMakePair(type, qMakePair(begin, (int)(end - begin) - (escaped ? 1 : 0)));

}

static QList<Token> tokenSequence(const QString& input)

{

    QList<Token> result;

    bool escaped = false;

    const QChar* it = input.constData();

    const QChar* const end = it + input.length();

    if (it != end) 

    {

        const QChar* token = it;

        EncodingTokenType state = ((*it) == '"' ? Quote : ((*it).isSpace() ? Whitespace : Word)); 

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

        {

            if (!escaped && (*it == '\\')) 

            {

                escaped = true;

                continue;

            }

            if (state == Quote)

            {

                // This quotation mark is a token by itself

                result.append(makeToken(state, token, it, escaped));

                state = ((*it) == '"' && !escaped ? Quote : ((*it).isSpace() ? Whitespace : Word)); 

                token = it;

            }

            else if (state == Whitespace)

            {

                if (!(*it).isSpace())

                {

                    // We have passed the end of this whitespace-sequence

                    result.append(makeToken(state, token, it, escaped));