#include "qversitdocument.h"

#include <QTextCodec>

#include <QMutexLocker>

#include <QVariant>

#include <QBuffer>

QTM_USE_NAMESPACE

// Some big enough value for nested versit documents to prevent infinite recursion

/*!

  \class LineReader

  \brief The LineReader class is a wrapper around a QIODevice that allows line-by-line reading.

  This class keeps an internal buffer which it uses to temporarily store data which it has read from

  the device but not returned to the user.

 */

/*!

  Constructs a LineReader that reads from the given \a device using the given \a codec.

  \a chunkSize is the number of bytes to read at a time (it is useful for testing but shouldn't

  otherwise be set).

  */

LineReader::LineReader(QIODevice* device, QTextCodec *codec, int chunkSize)

    : mDevice(device),

    mCodec(codec),

    mChunkSize(chunkSize),

    mCrlfList(*VersitUtils::newlineList(mCodec)),

    mBuffer(VersitCursor(QByteArray())),

    mOdometer(0)

  Attempts to read a line and returns a VersitCursor describing the line.  The cursor returned

  includes the data, as well as the position and selection index bounds.  Data within those bounds

  represents the line.  Data outside those bounds should not be used.

VersitCursor LineReader::readLine()

    mBuffer.position = mBuffer.selection;

    mSearchFrom = mBuffer.position;

    // First, look for a newline in the already-existing buffer.  If found, return the line.

    if (tryReadLine(mBuffer, false)) {

        mBuffer.dropOldData();

        mOdometer += mBuffer.selection - mBuffer.position;

        return mBuffer;

    }

    // Otherwise, keep reading more data until either a CRLF is found, or there's no more to read.

    while (!mDevice->atEnd()) {

        QByteArray temp = mDevice->read(mChunkSize);

        mBuffer.data.append(temp);

        if (tryReadLine(mBuffer, false)) {

            mBuffer.dropOldData();

            mOdometer += mBuffer.selection - mBuffer.position;

            return mBuffer;

        }

    }

    // We've reached the end of the stream.  Find a newline from the buffer (or return what's left).

    tryReadLine(mBuffer, true);

    mBuffer.dropOldData();

    mOdometer += mBuffer.selection - mBuffer.position;

    return mBuffer;

}

/*!

  How many bytes have been returned in the VersitCursor in the lifetime of the LineReader.

 */

int LineReader::odometer()

{

    return mOdometer;

}

/*!

  Returns true if there are no more lines left for readLine() to return.  It is possible for atEnd()

  to return false and for there to be no more data left (eg. if there are trailing newlines at the

  end of the input.  In this case, readLine() will return an empty line (ie. position == selection).

 */

bool LineReader::atEnd()

{

    return mDevice->atEnd() && mBuffer.selection == mBuffer.data.size();

}

/*!

  Returns the codec that the LineReader reads with.

 */

QTextCodec* LineReader::codec()

{

    return mCodec;

 * Get the next line of input from \a device to parse.  Also performs unfolding by removing

 * sequences of newline-space from the retrieved line.  Skips over any newlines at the start of the

 * input.

 *

 * Returns a VersitCursor containing and selecting the line.

bool LineReader::tryReadLine(VersitCursor &cursor, bool atEnd)

    int crlfPos;

    QByteArray space = VersitUtils::encode(' ', mCodec);

    QByteArray tab = VersitUtils::encode('\t', mCodec);

    int spaceLength = space.length();

    forever {

        foreach(const QByteArrayMatcher& crlf, mCrlfList) {

            int crlfLength = crlf.pattern().length();

            crlfPos = crlf.indexIn(cursor.data, mSearchFrom);

            if (crlfPos == cursor.position) {

                // Newline at start of line.  Set position to directly after it.

                cursor.position += crlfLength;

                mSearchFrom = cursor.position;

                break;

            } else if (crlfPos > cursor.position) {

                // Found the CRLF.

                if (QVersitReaderPrivate::containsAt(cursor.data, space, crlfPos + crlfLength)

                    || QVersitReaderPrivate::containsAt(cursor.data, tab, crlfPos + crlfLength)) {

                    // If it's followed by whitespace, collapse it.

                    cursor.data.remove(crlfPos, crlfLength + spaceLength);

                    mSearchFrom = crlfPos;

                    break;

                } else if (!atEnd && crlfPos + crlfLength + spaceLength >= cursor.data.size()) {

                    // If our CRLF is at the end of the current buffer but there's more to read,

                    // it's possible that a space could be hiding on the next read from the device.

                    // Just pretend we didn't see the CRLF and pick it up the next time round.

                    mSearchFrom = crlfPos;

                    return false;

                } else {

                    // Found the CRLF.

                    cursor.selection = crlfPos;

                    return true;

                }

            }

        }

        if (crlfPos == -1) {

            // No CRLF found.

            cursor.selection = cursor.data.size();

            return false;

}

/*! Construct a reader. */

QVersitReaderPrivate::QVersitReaderPrivate()

    : mIoDevice(0),

    mDocumentNestingLevel(0),

    mDefaultCodec(QTextCodec::codecForName("UTF-8")),

    mState(QVersitReader::InactiveState),

    mError(QVersitReader::NoError),

    mIsCanceling(false)

{

}

/*! Destroy a reader. */

QVersitReaderPrivate::~QVersitReaderPrivate()

{

 * Does the actual reading and sets the error and state as appropriate.

 * If \a async, then stateChanged() signals are emitted as the reading happens.

 */

void QVersitReaderPrivate::read()

{

    mMutex.lock();

    mVersitDocuments.clear();

    mMutex.unlock();

    bool canceled = false;

    LineReader lineReader(mIoDevice, mDefaultCodec);

    while(!lineReader.atEnd()) {

        if (isCanceling()) {

            canceled = true;

            break;

        }

        QVersitDocument document;

        int oldPos = lineReader.odometer();

        bool ok = parseVersitDocument(lineReader, document);

        if (ok) {

            if (document.isEmpty())

                break;

            else {

                QMutexLocker locker(&mMutex);

                mVersitDocuments.append(document);

                emit resultsAvailable(mVersitDocuments);

            }

        } else {

            setError(QVersitReader::ParseError);

            if (lineReader.odometer() == oldPos)

                break;

        }

    };

    if (canceled)

        setState(QVersitReader::CanceledState);

    else

        setState(QVersitReader::FinishedState);

}

void QVersitReaderPrivate::setState(QVersitReader::State state)

{

    mMutex.lock();

    mState = state;

    mMutex.unlock();

    emit stateChanged(state);

}

QVersitReader::State QVersitReaderPrivate::state() const

{

    QMutexLocker locker(&mMutex);

    return mState;

}

void QVersitReaderPrivate::setError(QVersitReader::Error error)

{

    QMutexLocker locker(&mMutex);

    mError = error;

}

QVersitReader::Error QVersitReaderPrivate::error() const

{

    QMutexLocker locker(&mMutex);

    return mError;

}

void QVersitReaderPrivate::setCanceling(bool canceling)

{

    QMutexLocker locker(&mMutex);

    mIsCanceling = canceling;

}

bool QVersitReaderPrivate::isCanceling()

{

    QMutexLocker locker(&mMutex);

    return mIsCanceling;

}

/*!

bool QVersitReaderPrivate::parseVersitDocument(LineReader& lineReader, QVersitDocument& document,

                                               bool foundBegin)

    // TODO: Various readers should be made subclasses and eliminate assumptions like this.

    // We don't know what type it is: just assume it's a vCard 3.0

    document.setType(QVersitDocument::VCard30Type);

    QVersitProperty property;

    if (!foundBegin) {

        property = parseNextVersitProperty(document.type(), lineReader);

        if (property.name() == QLatin1String("BEGIN")

            && property.value().trimmed().toUpper() == QLatin1String("VCARD")) {

            foundBegin = true;

        } else if (property.isEmpty()) {

            // A blank document (or end of file) was found.

            document = QVersitDocument();

        } else {

            // Some property other than BEGIN was found.

            parsingOk = false;

        }

    }

    if (foundBegin) {

        do {

            /* Grab it */

            property = parseNextVersitProperty(document.type(), lineReader);

            /* Discard embedded vcard documents - not supported yet.  Discard the entire vCard */

            if (property.name() == QLatin1String("BEGIN") &&

                QString::compare(property.value().trimmed(),

                                 QLatin1String("VCARD"), Qt::CaseInsensitive) == 0) {

                if (!parseVersitDocument(lineReader, nestedDocument, true))

            // See if this is a version property and continue parsing under that version

            if (!setVersionFromProperty(document, property)) {

            /* Nope, something else.. just add it */

            if (property.name() != QLatin1String("VERSION") &&

                property.name() != QLatin1String("END"))

        } while (property.name().length() > 0 && property.name() != QLatin1String("END"));

        if (property.name() != QLatin1String("END"))

            parsingOk = false;

        QVersitDocument::VersitType versitType,

        LineReader& lineReader)

    VersitCursor cursor = lineReader.readLine();

    if (cursor.position >= cursor.selection)

        return QVersitProperty();

    // Otherwise, do stuff.

            extractPropertyGroupsAndName(cursor, lineReader.codec());

    QVersitProperty property;

    if (versitType == QVersitDocument::VCard21Type)

        parseVCard21Property(cursor, property, lineReader);

    else if (versitType == QVersitDocument::VCard30Type)

        parseVCard30Property(cursor, property, lineReader);

void QVersitReaderPrivate::parseVCard21Property(VersitCursor& cursor, QVersitProperty& property,

                                                LineReader& lineReader)

    property.setParameters(extractVCard21PropertyParams(cursor, lineReader.codec()));

    QByteArray value = extractPropertyValue(cursor);

    if (property.name() == QLatin1String("AGENT")) {

        // Hack to handle cases where start of document is on the same or next line as "AGENT:"

        // XXX: Handle non-ASCII charsets in nested AGENT documents.

        bool foundBegin = false;

        if (value == "BEGIN:VCARD") {

            foundBegin = true;

        } else if (value.isEmpty()) {

        } else {

            property = QVersitProperty();

            return;

        }

        QVersitDocument agentDocument;

        if (!parseVersitDocument(lineReader, agentDocument, foundBegin)) {

            property = QVersitProperty();

        } else {

            property.setValue(QVariant::fromValue(agentDocument));

        }

        QTextCodec* codec;

        QVariant valueVariant(decodeCharset(value, property, lineReader.codec(), &codec));

        unencode(valueVariant, cursor, property, codec, lineReader);

        property.setValue(valueVariant);

void QVersitReaderPrivate::parseVCard30Property(VersitCursor& cursor, QVersitProperty& property,

                                                LineReader& lineReader)

    property.setParameters(extractVCard30PropertyParams(cursor, lineReader.codec()));

    QByteArray value = extractPropertyValue(cursor);

    QTextCodec* codec;

    QString valueString(decodeCharset(value, property, lineReader.codec(), &codec));

    VersitUtils::removeBackSlashEscaping(valueString);

    if (property.name() == QLatin1String("AGENT")) {

        // Make a line reader from the value of the property.

        QByteArray agentValue(codec->fromUnicode(valueString));

        QBuffer agentData(&agentValue);

        agentData.open(QIODevice::ReadOnly);

        agentData.seek(0);

        LineReader agentLineReader(&agentData, codec);

        QVersitDocument agentDocument;

        if (!parseVersitDocument(agentLineReader, agentDocument)) {

            property = QVersitProperty();

        } else {

            property.setValue(QVariant::fromValue(agentDocument));

        }

        QVariant valueVariant(valueString);

        unencode(valueVariant, cursor, property, codec, lineReader);

        if (valueVariant.type() == QVariant::ByteArray) {

            // hack: add the charset parameter back in (even if there wasn't one to start with and

            // the default codec was used).  This will help later on if someone calls valueString()

            // on the property.

            property.insertParameter(QLatin1String("CHARSET"), QLatin1String(codec->name()));

        }

        property.setValue(valueVariant);

bool QVersitReaderPrivate::setVersionFromProperty(QVersitDocument& document, const QVersitProperty& property) const

    if (property.name() == QLatin1String("VERSION")) {

        QString value = property.value().trimmed();

        if (property.parameters().contains(QLatin1String("ENCODING"),QLatin1String("BASE64"))

            || property.parameters().contains(QLatin1String("TYPE"),QLatin1String("BASE64")))

            value = QLatin1String(QByteArray::fromBase64(value.toAscii()));

        if (value == QLatin1String("2.1")) {

            document.setType(QVersitDocument::VCard21Type);

        } else if (value == QLatin1String("3.0")) {

            document.setType(QVersitDocument::VCard30Type);

/*!

 * On entry, \a value should hold a QString.  On exit, it may be either a QString or a QByteArray.

 */

void QVersitReaderPrivate::unencode(QVariant& value, VersitCursor& cursor,

                                    QVersitProperty& property, QTextCodec* codec,

                                    LineReader& lineReader) const

{

    Q_ASSERT(value.type() == QVariant::String);

    QString valueString = value.toString();

    if (property.parameters().contains(QLatin1String("ENCODING"), QLatin1String("QUOTED-PRINTABLE"))) {