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

**

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

#include "qmaillog.h"

#include <QDataStream>

#include <QFile>

#include <QFileInfo>

#include <QTextStream>

#include <QtDebug>

#ifndef USE_FANCY_MATCH_ALGORITHM

#include <ctype.h>

#endif

// LongString: A string/array class for processing IETF documents such as

// RFC(2)822 messages in a memory efficient method.

// The LongString string/array class implemented in this file provides 2

// primary benefits over the QString/QByteArray string/array classes namely:

//

// 1) Inbuilt support for mmap'ing a file so that a string can parsed without

//    requiring all bytes of that string to be loaded into physical memory.

//

// 2) left, mid and right methods that don't create deep copies of the

//    string data, this is achieved by using ref counting and

//    QByteArray::fromRawData

//

// Normal QByteArray methods can be used on LongStrings by utilizing the

// LongString::toQByteArray method.

//

// Known Limitations:

//

// 1) The internal representation is 8bit ascii, which is fine for 7bit ascii

//    email messages.

//

// 2) The underlying data is treated as read only.

//

// 3) mmap may not be supported on non *nix platforms.

//

// Additionally LongString provides a case insensitive indexOf method, this

// is useful as email fields/tokens (From, Date, Subject etc) are case

// insensitive.

#ifdef USE_FANCY_MATCH_ALGORITHM

#define REHASH(a) \

    if (ol_minus_1 < sizeof(uint) * CHAR_BIT) \

        hashHaystack -= (a) << ol_minus_1; \

    hashHaystack <<= 1

#endif

static int insensitiveIndexOf(const QByteArray& target, const QByteArray &source, int from, int off, int len) 

{

#ifndef USE_FANCY_MATCH_ALGORITHM

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

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

    const char* const begin = source.constData() + off;

    const char* const end = begin + len - (target.length() - 1);

    const char* it = 0;

    if (from >= 0) {

        it = begin + from;

    } else {

        it = begin + len + 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;

#else

    // Based on QByteArray::indexOf, except use strncasecmp for

    // case-insensitive string comparison

    const int ol = target.length();

    if (from > len || ol + from > len)

        return -1;

    if (ol == 0)

        return from;

    const char *needle = target.data();

    const char *haystack = source.data() + off + from;

    const char *end = source.data() + off + (len - ol);

    const uint ol_minus_1 = ol - 1;

    uint hashNeedle = 0, hashHaystack = 0;

    int idx;

    for (idx = 0; idx < ol; ++idx) {

        hashNeedle = ((hashNeedle<<1) + needle[idx]);

        hashHaystack = ((hashHaystack<<1) + haystack[idx]);

    }

    hashHaystack -= *(haystack + ol_minus_1);

    while (haystack <= end) {

        hashHaystack += *(haystack + ol_minus_1);

        if (hashHaystack == hashNeedle  && *needle == *haystack

             && strncasecmp(needle, haystack, ol) == 0)

        {

            return haystack - source.data();

        }

        REHASH(*haystack);

        ++haystack;

    }

    return -1;

#endif

}

class LongStringFileMapping

{

public:

    LongStringFileMapping();

    LongStringFileMapping(const QString& name);

    ~LongStringFileMapping();

    const QString &fileName() const { return filename; }

    int length() const { return len; }

    bool mapped() const { return (buffer != 0); }

    const QByteArray toQByteArray() const;

    template <typename Stream> void serialize(Stream &stream) const;

    template <typename Stream> void deserialize(Stream &stream);

private:

    void init();

    void map() const;

    QString filename;

    mutable const char* buffer;

    int len;

    // We need to keep these in an external map, because QFile is noncopyable

    struct QFileMapping

    {

        QFileMapping() : file(0), mapping(0), refCount(0), mapCount(0), size(0) {}

        QFile* file;

        char* mapping;

        int refCount;

        int mapCount;

        qint64 size;

    };

    static QMap<QString, QFileMapping> fileMap;

};

QMap<QString, LongStringFileMapping::QFileMapping> LongStringFileMapping::fileMap;

template <typename Stream> 

Stream& operator<<(Stream &stream, const LongStringFileMapping& mapping) { mapping.serialize(stream); return stream; }

template <typename Stream> 

Stream& operator>>(Stream &stream, LongStringFileMapping& mapping) { mapping.deserialize(stream); return stream; }

LongStringFileMapping::LongStringFileMapping()

    : buffer(0),

      len(0)

{

}

LongStringFileMapping::LongStringFileMapping(const QString& name)

    : filename(name),

      buffer(0),

      len(0)

{

    init();

}

LongStringFileMapping::~LongStringFileMapping()

{

    if (!filename.isEmpty()) {

        QMap<QString, QFileMapping>::iterator it = fileMap.find(filename);

        if (it == fileMap.end()) {

            qWarning() << "Unable to find mapped file:" << filename;

        } else {

            QFileMapping& fileMapping(it.value());

            if (fileMapping.refCount > 1) {

                fileMapping.refCount -= 1;

                // See if we're the last user with a mapping

                if (mapped() && (fileMapping.mapCount > 0)) {

                    fileMapping.mapCount -= 1;

                    if (fileMapping.mapCount == 0) {

                        // Unmap this file

                        if (fileMapping.file->unmap(reinterpret_cast<uchar*>(fileMapping.mapping))) {

                            fileMapping.mapping = 0;

                        } else {

                            qWarning() << "Unable to unmap file:" << filename;

                        }

                    }

                } 

            } else {

                // We're the last user - delete the file

                delete fileMapping.file;

                fileMap.erase(it);

            }

        }

    }

}

void LongStringFileMapping::init()

{

    if (!filename.isEmpty()) {

        QMap<QString, QFileMapping>::iterator it = fileMap.find(filename);

        if (it == fileMap.end()) {

            // This file is not referenced yet

            QFileInfo fi(filename);

            if (fi.exists() && fi.isFile() && fi.isReadable()) {

                filename = fi.absoluteFilePath();

                if (fi.size() > 0) {

                    QFileMapping fileMapping;

                    fileMapping.file = new QFile(filename);

                    fileMapping.size = fi.size();

                    it = fileMap.insert(filename, fileMapping);

                }

            }

        }

        if (it != fileMap.end()) {

            len = it.value().size;

            it.value().refCount += 1;

        }

    }

}

void LongStringFileMapping::map() const

{

    if ((len > 0) && !filename.isEmpty()) {

        QMap<QString, QFileMapping>::iterator it = fileMap.find(filename);

        if (it != fileMap.end()) {

            QFileMapping &fileMapping(it.value());

            if (fileMapping.mapping == 0) {

                if (fileMapping.file->open(QIODevice::ReadOnly)) {

                    fileMapping.mapping = reinterpret_cast<char*>(fileMapping.file->map(0, fileMapping.size));

                    fileMapping.file->close();

                    if (!fileMapping.mapping) {

                        qWarning() << "Unable to map file:" << filename;

                    }

                } else {

                    qWarning() << "Unable to open file for mapping:" << filename;

                }

            }

            buffer = fileMapping.mapping;

            fileMapping.mapCount += 1;

        }

    }

}

const QByteArray LongStringFileMapping::toQByteArray() const

{

    if (!mapped())

        map();

    // Does not create a copy:

    return QByteArray::fromRawData(buffer, len);

}

template <typename Stream> 

void LongStringFileMapping::serialize(Stream &stream) const

{

    stream << filename;

}

template <typename Stream> 

void LongStringFileMapping::deserialize(Stream &stream)

{

    stream >> filename;

    init();

}

class LongStringPrivate

{

public:

    LongStringPrivate();

    LongStringPrivate(const QByteArray& ba);

    LongStringPrivate(const QString& filename);

    LongStringPrivate(const LongStringPrivate& other);

    ~LongStringPrivate();

    const LongStringPrivate &operator=(const LongStringPrivate &);

    QString fileName() const;

    int length() const;

    bool isEmpty() const;

    int indexOf(const QByteArray &target, int from) const;

    void midAdjust(int i, int len);

    void leftAdjust(int i);

    void rightAdjust(int i);

    const QByteArray toQByteArray() const;

    QDataStream* dataStream() const;

    QTextStream* textStream() const;

    template <typename Stream> void serialize(Stream &stream) const;

    template <typename Stream> void deserialize(Stream &stream);

private:

    mutable LongStringFileMapping* mapping;

    mutable QByteArray data;

    int offset;

    int len;

};

template <typename Stream> 

Stream& operator<<(Stream &stream, const LongStringPrivate& ls) { ls.serialize(stream); return stream; }

template <typename Stream> 

Stream& operator>>(Stream &stream, LongStringPrivate& ls) { ls.deserialize(stream); return stream; }

LongStringPrivate::LongStringPrivate()

    : mapping(0),

      offset(0), 

      len(0) 

{

}

LongStringPrivate::LongStringPrivate(const QByteArray& ba)

    : mapping(0),

      data(ba),

      offset(0), 

      len(data.length()) 

{

}

LongStringPrivate::LongStringPrivate(const QString& filename)

    : mapping(new LongStringFileMapping(filename)),

      offset(0), 

      len(mapping->length())

{

}

LongStringPrivate::LongStringPrivate(const LongStringPrivate &other)

    : mapping(0),

      offset(0),

      len(0)

{

    this->operator=(other);

}

LongStringPrivate::~LongStringPrivate()

{

    delete mapping;

}

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

{

    if (&other != this) {

        delete mapping;

        mapping = (other.mapping ? new LongStringFileMapping(other.mapping->fileName()) : 0);

        data = (other.mapping ? QByteArray() : other.data);

        offset = other.offset;

        len = other.len;

    }

    return *this;

}

QString LongStringPrivate::fileName() const

{

    if (mapping) {

        return mapping->fileName();

    }

    return QString();

}

int LongStringPrivate::length() const

{

    return len;

}

bool LongStringPrivate::isEmpty() const

{

    return (len == 0);

}

int LongStringPrivate::indexOf(const QByteArray &target, int from) const

{

    if (mapping) {

        return insensitiveIndexOf(target, mapping->toQByteArray(), from, offset, len);

    }

    if (!data.isEmpty()) {

        return insensitiveIndexOf(target, data, from, offset, len);

    }

    return -1;

}

void LongStringPrivate::midAdjust(int i, int size)

{

    i = qMax(i, 0);

    if (i > len) {

        len = 0;

    } else {

        int remainder = len - i;

        if (size < 0 || size > remainder)

            size = remainder;

        offset += i;

        len = size;

    }

}

void LongStringPrivate::leftAdjust(int size)

{

    if (size < 0 || size > len)

        size = len;

    len = size;

}

void LongStringPrivate::rightAdjust(int size)

{

    if (size < 0 || size > len)

        size = len;

    offset = (len - size) + offset;

    len = size;

}

const QByteArray LongStringPrivate::toQByteArray() const

{

    if (mapping) {

        // Does not copy:

        return QByteArray::fromRawData(mapping->toQByteArray().constData() + offset, len);

    }

    if (!data.isEmpty()) {

        return QByteArray::fromRawData(data.constData() + offset, len);

    }

    return QByteArray();

}

QDataStream* LongStringPrivate::dataStream() const

{

    // This is safe because QByteArray has shared implementation objects:

    const QByteArray input = toQByteArray();

    return new QDataStream(input);

}

QTextStream* LongStringPrivate::textStream() const

{

    const QByteArray input = toQByteArray();

    return new QTextStream(input);

}

template <typename Stream> 

void LongStringPrivate::serialize(Stream &stream) const

{

    bool usesMapping(mapping != 0);

    stream << usesMapping;

    if (usesMapping) {

        stream << *mapping;

    } else {

        stream << data;