/*

* Copyright (c) 2005 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:  Freestyle Email application attachment download info mediator

*

*/

//  INCLUDE FILES

#include "emailtrace.h"

#include <e32svr.h>

//<cmail>

#include "CFSMailClient.h"

//</cmail>

#include <StringLoader.h>

#include <FreestyleEmailUi.rsg>

#include "FreestyleEmailUiConstants.h"

#include "FreestyleEmailUiLiterals.h"

#include "FreestyleEmailUiUtilities.h"

#include "FreestyleEmailDownloadInformationMediator.h"

#include "FreestyleEmailCenRepHandler.h"

#include "FreestyleEmailUiAppui.h"

#include "FSEmail.pan"

// ============================ MEMBER FUNCTIONS ===============================

// ----------------------------------------------------

// CFSEmailDownloadInfoMediator::CFSEmailDownloadInfoMediator

// Default class constructor.

// ----------------------------------------------------

//

CFSEmailDownloadInfoMediator::CFSEmailDownloadInfoMediator( CFSMailClient& aMailClient )

    : CActive( EPriorityNormal ), iMailClient(aMailClient),

    iDownloadArray( KArrayGranularity, _FOFF(TDownload, iRequestId) ), iDownloadsStarted ( EFalse ),

    iNotificationsInProgress( 0 ), iObserverDeleted( EFalse )

	{

    FUNC_LOG;

	CActiveScheduler::Add( this );

	}

// ----------------------------------------------------

// CFSEmailDownloadInfoMediator::ConstructL

// Second phase class constructor.

// ----------------------------------------------------

//

void CFSEmailDownloadInfoMediator::ConstructL()

	{

    FUNC_LOG;

	}

// ----------------------------------------------------

// CFSEmailDownloadInfoMediator::NewL

// Two-phased class constructor.

// Singleton

// ----------------------------------------------------

//

CFSEmailDownloadInfoMediator* CFSEmailDownloadInfoMediator::NewL( CFSMailClient& aMailClient )

	{

    FUNC_LOG;

	CFSEmailDownloadInfoMediator* singleton = NULL;

	// Check Thread Local Storage for instance pointer

	singleton = static_cast<CFSEmailDownloadInfoMediator*>( UserSvr::DllTls( KTlsHandleDownloadInfo ) );

	if ( !singleton )

		{

		singleton = new ( ELeave ) CFSEmailDownloadInfoMediator( aMailClient );

		CleanupStack::PushL( singleton );

		singleton->ConstructL();

		CleanupStack::Pop( singleton );

		// Store a pointer of a new instance in Thread Local Storage

		TInt err = UserSvr::DllSetTls( KTlsHandleDownloadInfo, singleton );

		if ( err )

			{

			delete singleton;

			singleton = NULL;

			User::Leave( err );

			}

		}

	return singleton;

	}

void CFSEmailDownloadInfoMediator::AddObserver( MFSEmailDownloadInformationObserver* aObserver, TFSMailMsgId aMessageId )

	{

    FUNC_LOG;

	TRequestObserver newObserver = {aObserver, aMessageId };

	iObserverArray.Append( newObserver );

	}

void CFSEmailDownloadInfoMediator::AddObserver( MFSEmailDownloadInformationObserver* aObserver )

	{

	iAllObserverArray.Append(aObserver);

	}

// ----------------------------------------------------

// CFSEmailDownloadInfoMediator::~CFSEmailDownloadInfoMediator

// Destructor of CFSEmailDownloadInfoMediator class.

// ----------------------------------------------------

//

CFSEmailDownloadInfoMediator::~CFSEmailDownloadInfoMediator()

	{

	FUNC_LOG;

	iAllObserverArray.Close();

	iObserverArray.Close();

	iDownloadArray.Close();

	iDownloadCountArray.Close();

	Cancel();

    }

void CFSEmailDownloadInfoMediator::RequestResponseL(

	TFSProgress aEvent, TInt aRequestId )

	{

	FUNC_LOG;

	// Find the correct download structure

	TDownload download( aRequestId, TPartData(), KNullDesC(), EFalse );

	TInt idx = iDownloadArray.Find( download );

    if ( idx >= 0 && idx < iDownloadArray.Count() )

    	{

    	// save the progress info from status events

    	if ( aEvent.iProgressStatus == TFSProgress::EFSStatus_Status )

    	    {

        	iDownloadArray[idx].iCounter = aEvent.iCounter;

        	iDownloadArray[idx].iMaxCount = aEvent.iMaxCount;

    	    }

		// Make a local copy of the download object as the object may be

		// removed from the array before we are finished

		download = iDownloadArray[idx];

    	// In case of error, show a note

		if ( aEvent.iError && aEvent.iError != KErrCancel )

		    {

			// Download failed, show error note

			if ( aEvent.iError == KErrCouldNotConnect ||

				 aEvent.iError == KErrConnectionTerminated )

			    { // connection error

			    TFsEmailUiUtility::ShowErrorNoteL(

			    	R_FREESTYLE_EMAIL_ERROR_GENERAL_CONNECTION_ERROR,

			    	ETrue );

			    }

			else // other error

			    {

			    TFsEmailUiUtility::ShowErrorNoteL(

			    	R_FREESTYLE_EMAIL_ERROR_GENERAL_UNABLE_TO_COMPLETE,

			    	ETrue );

			    }

		    }

		// Remove download from array if it has been cancelled or failed

		if ( aEvent.iProgressStatus ==

			 TFSProgress::EFSStatus_RequestCancelled || aEvent.iError )

			{

			iDownloadArray.Remove(idx);

			}

		// Mark download as completed if download just finished

		else if ( aEvent.iProgressStatus ==

				  TFSProgress::EFSStatus_RequestComplete )

		    {

		    if ( !iDownloadArray[idx].iMaxCount )

		        {

		        // Set max count to 1 if no single progress event has arrived

		        // before download is finished.

		        iDownloadArray[idx].iMaxCount = 1;

		        }

		    iDownloadArray[idx].iCounter = iDownloadArray[idx].iMaxCount;

		    }

		TInt completedDownloadsToNotify = 0;        

		// Find and update the count array entry

        TDownloadCount countObject( download.iPartData.iMessageId );

        GetAndUpdateDownloadCountL( countObject, aEvent );

		// Notification may be given if all ongoing downloads from message

		// have finished and there are some properly completed downloads

        if ( download.iNotifyComplete &&

             countObject.iDownloadsCompletedCount &&

             countObject.iDownloadsCompletedCount ==

             	countObject.iDownloadsStartedCount )

            {

			completedDownloadsToNotify = countObject.iDownloadsCompletedCount;

            }

		// if download is complete

		if ( aEvent.iProgressStatus ==

			 TFSProgress::EFSStatus_RequestComplete && !aEvent.iError )

			{

            // if file was set to be saved after download

    		if ( download.iSaveFileName.CompareC( KNullDesC ) )

    			{

    			CFSMailMessage* mailMessage = iMailClient.GetMessageByUidL(

    				download.iPartData.iMailBoxId,

    				download.iPartData.iFolderId,

    				download.iPartData.iMessageId,

    				EFSMsgDataEnvelope );

        		CleanupStack::PushL( mailMessage );

        		CFSMailMessagePart* attachment = mailMessage->ChildPartL(

        			download.iPartData.iMessagePartId );

        		CleanupStack::PopAndDestroy( mailMessage );

        		CleanupStack::PushL( attachment );

        		if ( TFsEmailUiUtility::OkToSaveFileL( download.iSaveFileName, *attachment ) )

        			{

	        		attachment->CopyContentFileL( download.iSaveFileName );       			

        			}

        		CleanupStack::PopAndDestroy( attachment );

    			}

			}

		// relay the event to observers

		NotifyObserversL( aEvent, download.iPartData );

        // <cmail> moved completion note after notifying so that observers can 

        // clear menus etc. before note is displayed

        // if download is complete

		if ( aEvent.iProgressStatus ==

			 TFSProgress::EFSStatus_RequestComplete && !aEvent.iError )

			{

            // Notification of saved attachments may be given if all downloads of the given message has been completed.

            if ( download.iNotifyComplete && countObject.iDownloadsCompletedCount &&

                 {

                 TFsEmailUiUtility::ShowFilesSavedToFolderNoteL( countObject.iSaveRequestedCount );

                 }        

			}

	    // </cmail>

        }

	}

TBool CFSEmailDownloadInfoMediator::IsAnyAttachmentDownloads()

	{

	FUNC_LOG;

	return iDownloadsStarted;

	}

TBool CFSEmailDownloadInfoMediator::IsAnyAttachmentDownloads( TFSMailMsgId aMessageId )

	{

	FUNC_LOG;

	for ( TInt i=0; i<iDownloadArray.Count(); i++ )

		{

		if ( iDownloadArray[i].iPartData.iMessageId == aMessageId )

			{

			return ETrue;

			}

		}

	return EFalse;

	}

TInt CFSEmailDownloadInfoMediator::GetDownloadPercentageL( TFSMailMsgId aMessageId )

    {

	FUNC_LOG;

    TInt count = 0;

    TInt maxCount = 0;

    for ( TInt i=0; i<iDownloadArray.Count(); i++ )

        {

        if ( iDownloadArray[i].iPartData.iMessageId == aMessageId )

            {

            // In case we find an attachment for which maxCount is still missing,

            // update all the missing maxCounts to match the file size of

            // the attachment.

            if ( iDownloadArray[i].iMaxCount <= 0 )

                {

                // This should happen at most once per call to GetDownloadPercentageL().

                UpdateAttachmentSizesL( iDownloadArray[i].iPartData );

                }

            count += iDownloadArray[i].iCounter;

            maxCount += iDownloadArray[i].iMaxCount;

            }

        }

    if ( maxCount <= 0 )

        {

        return KErrNotFound;

        }

    else

        {

        return 100*count/maxCount;

        }

    }

void CFSEmailDownloadInfoMediator::UpdateAttachmentSizesL( const TPartData& aMessageData )

    {

	FUNC_LOG;

    CFSMailMessage* mailMessage = iMailClient.GetMessageByUidL( aMessageData.iMailBoxId, 

                                                                aMessageData.iFolderId, 

                                                                aMessageData.iMessageId, 

                                                                EFSMsgDataEnvelope );

    CleanupStack::PushL( mailMessage );

    RPointerArray<CFSMailMessagePart> attachments;

    CleanupResetAndDestroyClosePushL( attachments );

    mailMessage->AttachmentListL( attachments );

    for ( TInt i=0; i<iDownloadArray.Count(); i++ )

        {

        if ( iDownloadArray[i].iPartData.iMessageId == aMessageData.iMessageId )

            {

            if ( iDownloadArray[i].iMaxCount <= 0 )

                {

                // Find the matching attachment object and retrieve the attachment size

                for ( TInt j=0 ; j<attachments.Count() ; ++j )

                    {

                    if ( attachments[j]->GetPartId() == iDownloadArray[i].iPartData.iMessagePartId )

                        {

                        iDownloadArray[i].iMaxCount = attachments[j]->ContentSize();

                        break;

                        }

                    }

                }

            }

        }

    CleanupStack::PopAndDestroy( &attachments );

    CleanupStack::PopAndDestroy( mailMessage );

    }

TBool CFSEmailDownloadInfoMediator::IsDownloadableL( TPartData aPart )

	{

	FUNC_LOG;

	TBool ret(EFalse);

	// if part is downloading, no more checking is needed

	if ( !IsDownloading( aPart.iMessagePartId ) )

		{

		CFSMailMessage* mailMessage = iMailClient.GetMessageByUidL(

			aPart.iMailBoxId, aPart.iFolderId,

			aPart.iMessageId, EFSMsgDataEnvelope );

		if ( mailMessage )

			{

			CleanupStack::PushL( mailMessage );

			CFSMailMessagePart* mailMessagePart =

				mailMessage->ChildPartL( aPart.iMessagePartId );

			// if the file is fetched full

			if ( mailMessagePart &&

			        mailMessagePart->FetchLoadState() == EFSFull )

				{

				ret = EFalse;

				}

			else

				{

				ret =  ETrue;

				}

			delete mailMessagePart;

			CleanupStack::PopAndDestroy( mailMessage );			

			}

		}

	return ret;

	}

void CFSEmailDownloadInfoMediator::Destroy()

	{

	FUNC_LOG;

    CFSEmailDownloadInfoMediator* self = 

        static_cast<CFSEmailDownloadInfoMediator*>( UserSvr::DllTls( KTlsHandleDownloadInfo ) );

	UserSvr::DllFreeTls( KTlsHandleDownloadInfo );

    delete self;

    }

void CFSEmailDownloadInfoMediator::StopObserving( MFSEmailDownloadInformationObserver* aObserver, TFSMailMsgId aMessageId )

	{

	FUNC_LOG;

    for (TInt i=iObserverArray.Count()-1; i>=0; i--)

    	{

   		if ( iObserverArray[i].iObserver == aObserver && iObserverArray[i].iMessageId == aMessageId )

   			{

            RemoveObserver(i);

   			}

    	}

	}

void CFSEmailDownloadInfoMediator::StopObserving( MFSEmailDownloadInformationObserver* aObserver )

	{

	FUNC_LOG;

    for ( TInt i=iObserverArray.Count()-1; i>=0; i-- )

    	{

   		if ( iObserverArray[i].iObserver == aObserver )

   			{

   			RemoveObserver(i);

   			}

    	}

    for ( TInt i=iAllObserverArray.Count()-1; i>=0; i-- )

    	{

		if ( iAllObserverArray[i] == aObserver )

   			{

   			iAllObserverArray.Remove(i);

   			}

    	}

	}

void CFSEmailDownloadInfoMediator::RemoveObserver( TInt aIdx )

    {

    if ( iNotificationsInProgress == 0 )

        {

        // If we're not currently iterating over the array, remove the entry

        // immediately.

        iObserverArray.Remove( aIdx );

        }

    else

        {

        // We're currently iterating over the array: mark the entry as

        // deleted and flag that we've done so.

        iObserverArray[aIdx].iDeleted = ETrue;

        iObserverDeleted = ETrue;

        }

    }

void CFSEmailDownloadInfoMediator::DownloadL( TPartData aPart, TBool aCompleteNote )

	{

	FUNC_LOG;

	TFileName emptyFileName;

	DownloadAndSaveL( aPart, emptyFileName, aCompleteNote );

	}

void CFSEmailDownloadInfoMediator::DownloadAndSaveL( TPartData aPart, const TDesC& aSaveFileName, TBool aCompleteNote )

	{

	FUNC_LOG;

	// now there is at least one download started 

	iDownloadsStarted = ETrue;

	// fetch message part

	CFSMailMessage* mailMessage = iMailClient.GetMessageByUidL( aPart.iMailBoxId, aPart.iFolderId, aPart.iMessageId, EFSMsgDataEnvelope );

	CleanupStack::PushL( mailMessage );

	CFSMailMessagePart* messagePart = mailMessage->ChildPartL( aPart.iMessagePartId );

	CleanupStack::PopAndDestroy( mailMessage );

	// Panic in udeb builds, the condition !messagePart should not be possible

    ASSERT( messagePart );	

	// to be on the safer side only leave in urel builds

    if ( !messagePart )

	    {

	    User::Leave( KErrNotFound );

	    }	

	CleanupStack::PushL( messagePart );

	// start download and get request id

	TInt requestId = messagePart->FetchMessagePartL( aPart.iMessagePartId, *this, 0 );

	// store download information

	TDownload newDownload( requestId, aPart, aSaveFileName, aCompleteNote );

	AppendDownloadToInternalArraysL( newDownload );

    CleanupStack::PopAndDestroy( messagePart );

	// It may take some time before the first progress event is received from 

	// the protocol plug-in. This is true at least with the current Intellisync

	// plug-in implementation. Send artificial "0% event" to the UI to ensure that

	// the UI shows that the file is being downloaded.

	TFSProgress zeroEvent = { TFSProgress::EFSStatus_Waiting, 0, 0, KErrNone };

	NotifyObserversL( zeroEvent, aPart );

	}

void CFSEmailDownloadInfoMediator::CancelDownloadL(

	TFSMailMsgId aMessagePartId )

	{

	FUNC_LOG;

	// Find the corresponding download object

	TDownload downloadToCancel;

	downloadToCancel.iPartData.iMessagePartId = aMessagePartId;

    TInt idx = iDownloadArray.Find( downloadToCancel, 

                                    TIdentityRelation<TDownload>(EqualMessagePartId) );

    // Cancel if download object was found

    if ( idx >= 0 && idx < iDownloadArray.Count() )

        {

        iMailClient.CancelL( iDownloadArray[idx].iRequestId );

        }

	}

void CFSEmailDownloadInfoMediator::CancelAllDownloadsL( TFSMailMsgId aMailBoxId )

    {

    // Cancel all downloads within mailbox indicated with aMailBoxId

    for (TInt i=0 ; i < iDownloadArray.Count() ; i ++ )

        {

        if ( iDownloadArray[i].iPartData.iMailBoxId == aMailBoxId )

            {

            iMailClient.CancelL( iDownloadArray[i].iRequestId );

            }

        }    

    }

TBool CFSEmailDownloadInfoMediator::IsDownloading(

	TFSMailMsgId aMessagePartId )

	{

	FUNC_LOG;

	TInt dlArrayCount = iDownloadArray.Count();

	for ( TInt i = 0; i < dlArrayCount; i++ )

    	{

    	const TDownload& downloadObject = iDownloadArray[i];

   		if ( downloadObject.iPartData.iMessagePartId == aMessagePartId )

   			{

   			if ( downloadObject.iCounter < downloadObject.iMaxCount ||

   			     downloadObject.iMaxCount <= 0 )

   			    {

   			    // Only return ETrue if the corresponding download entry is

   			    // found and it's not yet finished.

   	            return ETrue;