/*

* Copyright (c) 2010 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"

/*!

    \class NmAttachmentManager

    \brief Attachment download manager, shares attachment download between editor and viewer

*/

/*!

*/

NmAttachmentManager::NmAttachmentManager(NmUiEngine &uiEngine) :

    mUiEngine(uiEngine),

    mFetchOperation(NULL),

    mMsgFetchOperation(NULL),

    mFetchObserver(NULL),

    mAttaId(0),

    mProgressValue(0),

    mIsFetching(false)

{

    NM_FUNCTION;

}

/*!

*/

NmAttachmentManager::~NmAttachmentManager()

{

    NM_FUNCTION;

    // fetch operation deleted in cancel fetch

    cancelFetch();

}

/*!

    Starts attachment fetch. If earlier fetch operation exist it is cancelled.

    Set observer with setObserver method to get process and complete events

*/

void NmAttachmentManager::fetchAttachment(

        const NmId &mailboxId, 

        const NmId &folderId, 

        const NmId &messageId, 

        const NmId &messagePartId)

{

    NM_FUNCTION;

    // cancel old fetch operation, Does nothing if fetch not ongoing

    cancelFetch();

    mFetchOperation = mUiEngine.fetchMessagePart(

            mailboxId, folderId, messageId, messagePartId);

    if (mFetchOperation) {

        mAttaId = messagePartId;

        mIsFetching = true;

        QObject::connect(mFetchOperation, SIGNAL(operationCompleted(int)),

                this, SLOT(completeAttachmentFetch(int)));

        QObject::connect(mFetchOperation, SIGNAL(operationProgressChanged(int)),

                this, SLOT(changeProgress(int)));

        // set progress to 5 % already in start

        changeProgress(NmAttachmentManagerInitialProgressPercent);

    }

}

/*!

    Fetch attachments to a message. 

    \return bool true if fetch started, otherwise false.

*/

bool NmAttachmentManager::fetchAttachments(

        const NmId &mailboxId, 

        const NmId &folderId, 

        const NmId &messageId,

        QList<NmId> &messagePartIds)

{

    NM_FUNCTION;

    // cancel old fetch operation, Does nothing if fetch not ongoing

    cancelFetch();

    if (messagePartIds.count() > 0) {

        mFetchOperation = mUiEngine.fetchMessageParts(

            mailboxId,

            folderId,

            messageId,

            messagePartIds);

        if (mFetchOperation) {

            mAttaId = 0;

            mIsFetching = true;

            QObject::connect(mFetchOperation, SIGNAL(operationCompleted(int)),

                    this, SLOT(completeAttachmentFetch(int)));

            QObject::connect(mFetchOperation, SIGNAL(operationProgressChanged(int)),

                    this, SLOT(changeProgress(int)));

            result = true;

        }

    }

    return result;

}

/*!

    Fetch all message parts to a message. Fetches also message part data structure,

    if not fetched already.

      If earlier fetch operation exist it is cancelled and deleted.

*/

void NmAttachmentManager::fetchAllMessageParts(

        const NmId &mailboxId, 

        const NmId &folderId, 

        const NmId &messageId)

{

    NM_FUNCTION;

    mFetchMsg = mUiEngine.message(mailboxId,folderId,messageId);

    // Check if we have part data structure.    

        mFetchMsg->fetchedSize() < mFetchMsg->size()) {

        // cancel old fetch operation, Does nothing if fetch not ongoing

        cancelFetch();

        // Fetch the message.

        mMsgFetchOperation = mUiEngine.fetchMessage(

            mFetchMsg->envelope().mailboxId(),

            mFetchMsg->envelope().folderId(),

            mFetchMsg->envelope().messageId());

        mAttaId = 0;

        mIsFetching = true;

        if (mMsgFetchOperation) {

            QObject::connect(mMsgFetchOperation,

                    SIGNAL(operationCompleted(int)),

                    this,

                    SLOT(completeMessageFetch(int)));

        }

        else {

            completeMessageFetch(NmGeneralError);

        }

    }

    else {

        completeMessageFetch(NmNoError);

    }

}

/*!

    Retruns true if fetch operation is ongoing

*/

bool NmAttachmentManager::isFetching() const

{

    NM_FUNCTION;

    return mIsFetching;

}

/*!

    Retrunrs part id of attachment if fetch operation is ongoing. Zero id is returned otherwise

*/

NmId NmAttachmentManager::partIdUnderFetch() const

{

    NM_FUNCTION;

    return mAttaId;

}

/*!

    Cancels fetch operation. Does nothing if fetch not ongoing

*/

void NmAttachmentManager::cancelFetch()

{

    NM_FUNCTION;

    if (mFetchOperation && mFetchOperation->isRunning()) { 

        mFetchOperation->cancelOperation();

    }

    if (mMsgFetchOperation && mMsgFetchOperation->isRunning()) {

        mMsgFetchOperation->cancelOperation();

    }

    mIsFetching = false;

    mAttaId = 0;

    mProgressValue = 0;

}

/*!

    Used by message part fetch operation

*/

void NmAttachmentManager::changeProgress(int value)

{

    NM_FUNCTION;

    if (mFetchObserver && value > mProgressValue) {

        mProgressValue = value;

        mFetchObserver->progressChanged(value);

    }

}

/*!

    Used by message part fetch operation

*/

void NmAttachmentManager::completeAttachmentFetch(int result)

{

    NM_FUNCTION;

    if (mFetchObserver) {

        mFetchObserver->fetchCompleted(result);

    }

    mAttaId = 0;

    mProgressValue = 0;

    mIsFetching = false;

}

/*!

    Used by message fetch operation

*/

void NmAttachmentManager::completeMessageFetch(int result)

{

    NM_FUNCTION;

    if (result == NmNoError) {

        if (mFetchMsg) {

                }

            }

            else {

            }

        }

        else {

            mFetchObserver->fetchCompleted(NmNotFoundError);

        }

    }

    else {

        mFetchObserver->fetchCompleted(result);

    }

}

/*!

    Sets fetch observer

*/

void NmAttachmentManager::setObserver(NmAttachmentFetchObserver *observer)

{

    NM_FUNCTION;

    mFetchObserver = observer;

    // send progress event wheng observer changes if fetch ongoing 

    // to get progress bar updating

    if (mIsFetching) {

        changeProgress(mProgressValue);

    }

}

/*!

    Clear observer

*/

void NmAttachmentManager::clearObserver()

{

    NM_FUNCTION;

    mFetchObserver = NULL;

}

/*!

    Returns progress value if fetch ongoing. Otherwise returns 0.

*/

int NmAttachmentManager::progressValue() const

{

    NM_FUNCTION;

    return mProgressValue;

}