/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

#include "nmuiheaders.h"

static const char *NMUI_NET_REPLY_CONTENT_ID = "cid";

/*!

    \class NmViewerViewNetReply

    \brief Mail viewer network reply class

*/

/*!

    Constructor

*/

NmViewerViewNetReply::NmViewerViewNetReply(QVariant data, NmUiEngine &uiEngine)

    : QNetworkReply(),

      mDataArray(data.toByteArray()),

      mUiEngine(uiEngine),

      mOperation(NULL),

      mReadIndex(0)

{

    NM_FUNCTION;

    open(ReadWrite);

    setReadBufferSize(mDataArray.length());

    // QNetworkAccessManager starts listening the signals only

    // after the construction, so we cannot signal reply to be

    // ready instantly. We need to emit the signals after the

    // construction.

    QMetaObject::invokeMethod(this, "signalReady", Qt::QueuedConnection);

}

/*!

*/

NmViewerViewNetReply::NmViewerViewNetReply(QVariant data, NmUiEngine &uiEngine, 

        const NmId &mailboxId, const NmId &folderId, const NmId &messageId, 

        const NmId &messagePartId)

    : QNetworkReply(),

      mDataArray(data.toByteArray()),

      mUiEngine(uiEngine),

      mMailboxId(mailboxId),

      mFolderId(folderId),

      mMessageId(messageId),

      mMessagePartId(messagePartId),

      mOperation(NULL),

      mReadIndex(0)

{

    mOperation = uiEngine.fetchMessagePart(mMailboxId, mFolderId, mMessageId, mMessagePartId);

    if (mOperation) {

        connect(mOperation, SIGNAL(operationCompleted(int)),

            this, SLOT(fetchCompleted(int)));

        connect(mOperation, SIGNAL(operationCancelled()),

            this, SLOT(fetchCancelled()));

    }

    else {

        open(ReadWrite);

        setReadBufferSize(mDataArray.length());

        QMetaObject::invokeMethod(this, "signalReady", Qt::QueuedConnection);

    }

}

/*!

    Destructor

*/

NmViewerViewNetReply::~NmViewerViewNetReply()

{

    NM_FUNCTION;

}

/*!

    signalReady

*/

void NmViewerViewNetReply::signalReady()

{

    NM_FUNCTION;

    // Insert embedded images into cache manually

    if(manager()) {

        if(manager()->cache() && request().url().scheme() == NMUI_NET_REPLY_CONTENT_ID) {

            // Store url to use for reply in access manager finished emitting. 

            setUrl(request().url());

            // Metadata required for inserted data

            QNetworkCacheMetaData metaData;

            metaData.setUrl(request().url());

            metaData.setSaveToDisk(true);

            // Insert data into cache

            QIODevice *device = manager()->cache()->prepare(metaData);

            if(device) {

                device->write(mDataArray);

                manager()->cache()->insert(device);

            }

        }

    }

    // Emit these signals to properly emulate downloading from URL

    emit readyRead();

    emit finished();

}

/*!

    Slot. Called when fetch operation completes

*/

void NmViewerViewNetReply::fetchCompleted(int result)

{

    NM_FUNCTION;

    Q_UNUSED(result);

    NmMessage *message = mUiEngine.message(

                        mMailboxId, mFolderId, mMessageId);

    if (message) {

        QList<NmMessagePart*> partList;

        message->attachmentList(partList);

        NmMessagePart *part(NULL);

        for (int i = 0; !part && i < partList.count(); i++) {

            if (partList[i]->partId() == mMessagePartId) {

                part = partList[i];

                break;

            }

        }

        if (part) {

            int error = mUiEngine.contentToMessagePart(mMailboxId, mFolderId, mMessageId, *part);

            if (error == NmNoError) {

                mDataArray = part->binaryContent();

            }

        }

    }

    delete message;

    message = NULL;

    open(ReadWrite);

    setReadBufferSize(mDataArray.length());

    QMetaObject::invokeMethod(this, "signalReady", Qt::QueuedConnection);

}

/*!

    Slot. Called if fetch operation is cancelled

*/

void NmViewerViewNetReply::fetchCancelled()

{

    NM_FUNCTION;

    // just call fetch completed

    fetchCompleted(NmCancelError);

}

/*!

    setOriginalRequest. This function is created to provide access to call

    base class' protected function setRequest

*/

void NmViewerViewNetReply::setOriginalRequest(const QNetworkRequest &request)

{

    NM_FUNCTION;

    setRequest(request);

}

/*!

    readData

*/

qint64 NmViewerViewNetReply::readData(char *data, qint64 maxlen)

{

    NM_FUNCTION;

    qint64 i = 0;

    const qint64 dataLength(mDataArray.length());

    if (0 >= dataLength || !data) {

        return -1;

    }

    for (i = 0; i < maxlen && mReadIndex < dataLength; i++, mReadIndex++) {

        data[i] = mDataArray.at(mReadIndex);

    }

    return i;

}

/*!

    readBufferSize. Returns the size of the read buffer, in bytes.

*/

qint64 NmViewerViewNetReply::readBufferSize() const

{

    NM_FUNCTION;

    return mDataArray.length();

}

/*!

    bytesAvailable. Returns the number of bytes that are available for reading.

    This function is commonly used with sequential devices to determine the number of bytes to

    allocate in a buffer before reading. Base implementation is called in order to

    include the size of QIODevices' buffer.

*/

qint64 NmViewerViewNetReply::bytesAvailable() const

{

    NM_FUNCTION;

    return mDataArray.length() + QIODevice::bytesAvailable();

}

/*!

    isSequential. Returns true if this device is sequential.

*/

bool NmViewerViewNetReply::isSequential () const

{

    NM_FUNCTION;

    return false;

}

/*!

    abort. Aborts the operation immediately and close down any

    network connections still open

*/

void NmViewerViewNetReply::abort()

{

    NM_FUNCTION;

}