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

**

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

#include "qmaillog.h"

#include "qmailmessage.h"

#include "qmailnamespace.h"

namespace {

struct CharacterProcessor

{

    virtual ~CharacterProcessor();

    void processCharacters(const QString& input);

    virtual void process(QChar, bool, bool, int) = 0;

    virtual void finished();

};

CharacterProcessor::~CharacterProcessor()

{

}

void CharacterProcessor::processCharacters(const QString& input)

{

    int commentDepth = 0;

    bool quoted = false;

    bool escaped = false;

    const QChar* it = input.constData();

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

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

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

            escaped = true;

            continue;

        }

        bool quoteProcessed = false;

        if ( *it == '(' && !escaped && !quoted ) {

            commentDepth += 1;

        }

        else if ( !quoted && *it == '"' && !escaped ) {

            quoted = true;

            quoteProcessed = true;

        }

        process((*it), quoted, escaped, commentDepth);

        if ( *it == ')' && !escaped && !quoted && ( commentDepth > 0 ) ) {

            commentDepth -= 1;

        }

        else if ( quoted && *it == '"' && !quoteProcessed && !escaped ) {

            quoted = false;

        }

        escaped = false;

    }

    finished();

}

void CharacterProcessor::finished()

{

}

struct Decommentor : public CharacterProcessor

{

    Decommentor(bool (QChar::*classifier)() const, bool accepted);

    QString _result;

    bool (QChar::*_classifier)() const;

    bool _accepted;

    virtual void process(QChar, bool, bool, int);

};

Decommentor::Decommentor(bool (QChar::*classifier)() const, bool accepted)

    : _classifier(classifier),

      _accepted(accepted)

{

}

void Decommentor::process(QChar character, bool quoted, bool escaped, int commentDepth)

{

    if ( commentDepth == 0 ) {

        if ( quoted || ((character.*_classifier)() == _accepted) )

            _result.append( character );

    }

    Q_UNUSED(escaped)

}

static QString removeComments(const QString& input, bool (QChar::*classifier)() const, bool acceptedResult = true)

{

    Decommentor decommentor(classifier, acceptedResult);

    decommentor.processCharacters(input);

    return decommentor._result;

}

struct AddressSeparator : public CharacterProcessor

{

    enum TokenType { Unknown = 0, Address, Name, Suffix, Comment, Group, TypeCount };

    AddressSeparator();

    virtual void process(QChar, bool, bool, int);

    virtual void finished();

    virtual void accept(QChar) = 0;

    virtual QString progress() const = 0;

    virtual void complete(TokenType type, bool) = 0;

private:

    void separator(bool);

    bool _inAddress;

    bool _inGroup;

    bool _tokenStarted;

    bool _tokenCompleted;

    TokenType _type;

};

AddressSeparator::AddressSeparator()

    : _inAddress(false),

      _inGroup(false),

      _tokenStarted(false),

      _tokenCompleted(false),

      _type(Unknown)

{

}

void AddressSeparator::process(QChar character, bool quoted, bool escaped, int commentDepth)

{

    if (_tokenCompleted && (!character.isSpace())) {

        separator(false);

    }

    // RFC 2822 requires comma as the separator, but we'll allow the semi-colon as well.

    if ( ( character == ',' || character == ';' || character.isSpace()) && 

         !_inGroup && !quoted && !escaped && commentDepth == 0 ) {

        if (character.isSpace()) {

            // We'll also attempt to separate on whitespace, but we need to append it to 

            // the token to preserve the input data

            accept(character);

            _tokenCompleted = true;

        } else {

            separator(true);

        }

    }

    else {

        if (commentDepth && _type == Unknown && _tokenStarted == false) {

            // This could be a purely comment element

            _type = Comment;

        }

        else if (quoted && (_type == Unknown || _type == Comment)) {

            // This must be a name element

            _type = Name;

        }

        accept(character);

        _tokenStarted = true;

        if ( character == '<' && !_inAddress && !quoted && !escaped && commentDepth == 0 ) {

            _inAddress = true;

            if (_type == Unknown || _type == Comment)

                _type = Address;

        } else if ( character == '>' && _inAddress && !quoted && !escaped && commentDepth == 0 ) {

            _inAddress = false;

        }

        else if ( character == ':' && !_inGroup && !_inAddress && !quoted && !escaped && commentDepth == 0 ) {

            static const QString collectiveTag;

            // Don't parse as a group if we match the IM format

            // TODO: what if the group name actually matches the tag?

            if (progress() != collectiveTag) {

                _inGroup = true;

                _type = Group;

            }

        }

        else if ( character == ';' && _inGroup && !_inAddress && !quoted && !escaped && commentDepth == 0 ) {

            _inGroup = false;

            // This is a soft separator, because the group construct could have a trailing comment

            separator(false);

        }

    }

}

void AddressSeparator::separator(bool hardSeparator)

{

    complete(_type, hardSeparator);

    _tokenStarted = false;

    _tokenCompleted = false;

    _type = Unknown;

}

void AddressSeparator::finished()

{

    complete(_type, true);

}

struct AddressListGenerator : public AddressSeparator

{

    virtual void accept(QChar);

    virtual QString progress() const;

    virtual void complete(TokenType, bool);

    QStringList result();

private:

    typedef QPair<TokenType, QString> Token;

    int combinableElements();

    void processPending();

    QStringList _result;

    QList<Token> _pending;

    QString _partial;

};

void AddressListGenerator::accept(QChar character)

{

    _partial.append(character);

}

QString AddressListGenerator::progress() const

{

    return _partial;

}

void AddressListGenerator::complete(TokenType type, bool hardSeparator)

{

    if (_partial.trimmed().length()) {

        if (type == Unknown) {

            // We need to know what type of token this is

            // Test whether the token is a suffix

            QRegExp suffixPattern("\\s*/TYPE=.*");

            if (suffixPattern.exactMatch(_partial)) {

                type = Suffix;

            } 

            else {

                // See if the token is a bare email address; otherwise it must be a name element

                QRegExp emailPattern(QMailAddress::emailAddressPattern());

                type = (emailPattern.exactMatch(_partial.trimmed()) ? Address : Name);

            }

        }

        _pending.append(qMakePair(type, _partial));

        _partial.clear();

    }

    if (hardSeparator) {

        // We know that this is a boundary between addresses

        processPending();

    }

}

int AddressListGenerator::combinableElements()

{

    bool used[TypeCount] = { false };

    int combinable = 0;

    int i = _pending.count();

    while (i > 0) {

        int type = _pending.value(i - 1).first;

        // If this type has already appeared in this address, this must be part of the preceding address

        if (used[type])

            return combinable;

        // A suffix can only appear at the end of an address

        if (type == Suffix && (combinable > 0))

            return combinable;

        if (type == Comment) {

            // Comments can be combined with anything else...

        } else {

            // Everything else can be used once at most, and not with groups

            if (used[Group])

                return combinable;

            if (type == Group) {

                // Groups can only be combined with comments

                if (used[Name] || used[Address] || used[Suffix])

                    return combinable;

            }

            used[type] = true;

        }

        // Combine this element

        ++combinable;

        --i;

    }

    return combinable;

}

void AddressListGenerator::processPending()

{

    if (!_pending.isEmpty()) {

        // Compress any consecutive name parts into a single part

        for (int i = 1; i < _pending.count(); ) {

            TokenType type = _pending.value(i).first;

            // Also, a name could precede a group part, since the group name may contain multiple atoms

            if ((_pending.value(i - 1).first == Name) && ((type == Name) || (type == Group))) {

                _pending.replace(i - 1, qMakePair(type, _pending.value(i - 1).second + _pending.value(i).second));

                _pending.removeAt(i);

            } 

            else {

                ++i;

            }

        }

        // Combine the tokens as necessary, proceding in reverse from the known boundary at the end

        QStringList addresses;

        int combinable = 0;

        while ((combinable = combinableElements()) != 0) {

            QString combined;

            while (combinable) {

                combined.prepend(_pending.last().second);

                _pending.removeLast();

                --combinable;

            }

            addresses.append(combined);

        }

        // Add the address to the result set, in the original order

        for (int i = addresses.count(); i > 0; --i)

            _result.append(addresses.value(i - 1));

        _pending.clear();

    }

}

QStringList AddressListGenerator::result()

{

    return _result;

}

static QStringList generateAddressList(const QString& list)

{

    AddressListGenerator generator;

    generator.processCharacters(list);

    return generator.result();

}

static bool containsMultipleFields(const QString& input)

{

    // There is no shortcut; we have to parse the addresses

    AddressListGenerator generator;

    generator.processCharacters(input);

    return (generator.result().count() > 1);

}

struct GroupDetector : public CharacterProcessor

{

    GroupDetector();

    virtual void process(QChar, bool, bool, int);

    bool result() const;

private:

    bool _nameDelimiter;

    bool _listTerminator;

};

GroupDetector::GroupDetector()

    : _nameDelimiter(false),

      _listTerminator(false)

{

}

void GroupDetector::process(QChar character, bool quoted, bool escaped, int commentDepth)

{

    if ( character == ':' && !_nameDelimiter && !quoted && !escaped && commentDepth == 0 )

        _nameDelimiter = true;

    else if ( character == ';' && !_listTerminator && _nameDelimiter && !quoted && !escaped && commentDepth == 0 )

        _listTerminator = true;

}

bool GroupDetector::result() const

{

    return _listTerminator;

}

static bool containsGroupSpecifier(const QString& input)

{

    GroupDetector detector;

    detector.processCharacters(input);

    return detector.result();

}

struct WhitespaceRemover : public CharacterProcessor

{

    virtual void process(QChar, bool, bool, int);

    QString _result;

};

void WhitespaceRemover::process(QChar character, bool quoted, bool escaped, int commentDepth)

{

    if ( !character.isSpace() || quoted || escaped || commentDepth > 0 )

        _result.append(character);

}

static QString removeWhitespace(const QString& input)

{

    WhitespaceRemover remover;

    remover.processCharacters(input);

    return remover._result;

}

QPair<int, int> findDelimiters(const QString& text)

{

    int first = -1;

    int second = -1;

    bool quoted = false;

    bool escaped = false;

    const QChar* const begin = text.constData();

    const QChar* const end = begin + text.length();

    for (const QChar* it = begin; it != end; ++it ) {

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

            escaped = true;

            continue;

        }

        if ( !quoted && *it == '"' && !escaped ) {

            quoted = true;

        }

        else if ( quoted && *it == '"' && !escaped ) {

            quoted = false;

        }

        if ( !quoted ) {

            if ( first == -1 && *it == '<' ) {

                first = (it - begin);

            }

            else if ( second == -1 && *it == '>' ) {

                second = (it - begin);

                break;

            }

        }

        escaped = false;

    }

    return qMakePair(first, second);

}

void parseMailbox(QString& input, QString& name, QString& address, QString& suffix)

{

    // See if there is a trailing suffix

    int pos = input.indexOf("/TYPE=");

    if (pos != -1)

    {

        suffix = input.mid(pos + 6);

        input = input.left(pos);

    }

    // Separate the email address from the name

    QPair<int, int> delimiters = findDelimiters(input);

    if (delimiters.first == -1 && delimiters.second == -1)

    {

        name = address = input.trimmed();

    }

    else 

    {

        if (delimiters.first == -1)

        {

            // Unmatched '>'

            address = input.left( delimiters.second );

        }

        else

        {

            name = input.left( delimiters.first );

            if (delimiters.second == -1)