/*

* Copyright (c) 2002-2006 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:  mail message class

*

*/

// INCLUDE FILES

#include    "CMailMessage.h"

#include    <MMailMessageView.h>

#include    <MMessageLoadObserver.h>

#include    "MailLog.h"

#include    <miuthdr.h> // CImHeader

#include    <miutmsg.h>

#include    <miutconv.h>

#include    <charconv.h>

#include    <featmgr.h>

#include    <MuiuOperationWait.h>

#include 	<mmsvattachmentmanager.h>

#include    <ErrorUI.h>

// MODULE DATA STRUCTURES

enum TLoadState

    {

    ELoadMessageBody = 1,

    EHtmlNotFound,

    ELoadAttachments,

    ELoadAttachedMessages,

    ELoadLinkedHtmlContent

    };

// Constants

enum MessageFlags

    {

    EFlagAttachment = KBit0,

    EFlagAttachedMessages = KBit1,

    EFlagStopAfterLoad = KBit2,

    EFlagHtmlError = KBit3,

    EFlagHtmlMessageCharSetOverridden = KBit4

    };

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

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

// CMailMessage::CMailMessage

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CMailMessage::CMailMessage()

: CActive(0), iFlags(0)

    {

    }

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

// CMailMessage::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMailMessage::ConstructL(CMsvEntry& aEntry)

    {

    CActiveScheduler::Add(this);

    iHeader = CImHeader::NewLC();

    CleanupStack::Pop();

    iEntry = aEntry.Session().GetEntryL( aEntry.EntryId() );

    iMessage = CImEmailMessage::NewL(*iEntry);

    iMessageID = iEntry->EntryId();

    if (iEntry->HasStoreL())

        {

        CMsvStore* msvStore = iEntry->ReadStoreL();

        CleanupStack::PushL(msvStore);

        TRAP_IGNORE(iHeader->RestoreL(*msvStore));

        CleanupStack::PopAndDestroy(); // store

        }

    iGlobalParaLayer = CParaFormatLayer::NewL();

    iGlobalCharLayer = CCharFormatLayer::NewL();

    iBodyText = CRichText::NewL(

        iGlobalParaLayer,

        iGlobalCharLayer);

	iLinkedHtmlItems = new( ELeave ) RPointerArray<

		CLinkedHtmlItem>(5);		// CSI: 47 # approx granularity 5

    iAsyncWait = CMuiuOperationWait::NewLC(); //only NewLC variant exists

    CleanupStack::Pop( iAsyncWait );

    }

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

// CMailMessage::NewL

// Two-phased constructor.

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

//

EXPORT_C CMailMessage* CMailMessage::NewL(CMsvEntry& aEntry)

    {

    CMailMessage* self = new( ELeave ) CMailMessage();

    CleanupStack::PushL( self );

    self->ConstructL(aEntry);

    CleanupStack::Pop();

    return self;

    }

// Destructor

CMailMessage::~CMailMessage()

    {

    Cancel();

    delete iAsyncWait; // gets cancelled if running

    delete iHeader;

    delete iMessage;

    delete iBodyText;

    delete iGlobalParaLayer;

    delete iGlobalCharLayer;

    delete iURI;

    delete iEntry;

    if ( iLinkedHtmlItems )

        {

        iLinkedHtmlItems->ResetAndDestroy();

        delete iLinkedHtmlItems;

        }

   	iWaitArray.ResetAndDestroy();

    }

EXPORT_C void CMailMessage::LoadMessageL(

    MMessageLoadObserver& aMessageObserver)

    {

    iState = ELoadMessageBody;

    iMessageObserver = &aMessageObserver;

    // Header is already loaded

    NotifyObserverL(EHeaderReady);

    if( !MessageEntry().MHTMLEmail() )

        {

        LoadBodyTextL();

        }

    else

        {

   		LoadAttachmentsL();

        }

    SetActive();

    }

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

// CMailMessage::LoadLinkedHtmlContentL

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

//

EXPORT_C void CMailMessage::LoadLinkedHtmlContentL(

	const TDesC& aBase, const TDesC& aURI)

	{

	LoadLinkedHTMLContentL(aBase, aURI);

	}

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

// CMailMessage::HtmlCharsetIdL

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

//

EXPORT_C TUint CMailMessage::HtmlCharsetIdL()

    {

    TUint charset = 0;

    //

    if (iMhtmlPartId != 0)

        {

        if ( iFlags & EFlagHtmlMessageCharSetOverridden )

            {

            charset = iCharacterSetId;

            }

        else

            {

            CMsvEntry* htmlEntry = iEntry->Session().GetEntryL( iMhtmlPartId );

            CleanupStack::PushL( htmlEntry );

        	charset = DoGetMimeCharsetIdL( *htmlEntry );

            CleanupStack::PopAndDestroy( htmlEntry );

            }

        }

	LOG1( "CMailMessage::HtmlCharsetIdL %08x", charset );

    return charset;

    }

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

// CMailMessage::CharsetIdL

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

//

EXPORT_C TUint CMailMessage::CharsetIdL()

    {

    TUint characterSetId(0);

    TBool override;

    iMessage->GetCharacterSetL( iMessageID, characterSetId, override);

	LOG1( "CMailMessage::CharsetIdL from CImEmailMessage %08x",

	    	characterSetId );

	if ( characterSetId != 0 )

	    {

	    return characterSetId;

	    }

    if( iEntry->Entry().Id() != iMessageID )

    	iEntry->SetEntryL(iMessageID);

   	return DoGetMimeCharsetIdL( *iEntry );

    }

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

// CMailMessage::ConvertToCharsetL

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

//

EXPORT_C void CMailMessage::ConvertToCharsetL(TUint aCharsetId)

    {

    iMessage->SetCharacterSetL( iMessageID, aCharsetId );

    }

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

// CMailMessage::AttachmentManager

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

//

EXPORT_C MMsvAttachmentManager& CMailMessage::AttachmentManager() const

    {

    ASSERT( iState == ELoadAttachments );

	LOG2( "CMailMessage::AttachmentManager %08x - %08x",

	    iMessageID,

	    iEntry->EntryId() );

    // context still in message ?

    if( iEntry->Entry().Id() != iMessageID )

    	TRAP_IGNORE( iEntry->SetEntryL(iMessageID) );

    return iMessage->AttachmentManager();

    }

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

// CMailMessage::LoadAttachmentsL

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

//

EXPORT_C void CMailMessage::LoadAttachmentsL(MMessageLoadObserver& aObserver)

	{

	iMessageObserver = &aObserver;

	Cancel();

	LoadAttachmentsL();

	iFlags |= EFlagStopAfterLoad;

	SetActive();

	}

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

// CMailMessage::LoadAttachedMessagesL

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

//

EXPORT_C void CMailMessage::LoadAttachedMessagesL(

	MMessageLoadObserver& aObserver)

	{

	iMessageObserver = &aObserver;

	Cancel();

	LoadAttachedMessagesL();

	iFlags |= EFlagStopAfterLoad;

	SetActive();

	}

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

// CMailMessage::LoadHtmlContentL

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

//

EXPORT_C void CMailMessage::LoadHtmlContentL(MMessageLoadObserver& aObserver)

	{

	iMessageObserver = &aObserver;

	Cancel();

	LoadHTMLContentL();

	iFlags |= EFlagStopAfterLoad;

	SetActive();

	}

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

// CMailMessage::LoadLinkedHtmlContentL

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

//

EXPORT_C void CMailMessage::LoadLinkedHtmlContentL(

        	const TDesC& aBase,

        	const TDesC& aURI,

        	MMessageLoadObserver& aObserver )

	{

	iMessageObserver = &aObserver;

	Cancel();

	delete iURI;

	iURI = NULL;

	iURI = aURI.AllocL();

	LoadLinkedHTMLContentL( aBase, aURI );

	iFlags |= EFlagStopAfterLoad;

	SetActive();

	}

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

// CMailMessage::GetFileHandleL

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

//

EXPORT_C RFile CMailMessage::GetFileHandleL( TMsvAttachmentId aId )

    {

    LOG( ">CMailMessage::GetFileHandleL" );

    Cancel();

    // Force message cancel for special cases(lost network coverage)

    if ( iMessage )

    	{

    	iMessage->Cancel();

    	}

    // create an array for active scheduler waits if it does not exist

    CMuiuOperationWait* wait = CMuiuOperationWait::NewLC(); //only NewLC variant exists

    // append the wait to the array

    iWaitArray.AppendL( wait );

    CleanupStack::Pop( wait );

    RFile handle;

    if ( aId == iMhtmlPartId )

        {

        // html body part

        iMessage->FindFirstHTMLPageFileHandleL( iMessageID,

                                                wait->iStatus );

        wait->Start();

        User::LeaveIfError( wait->iStatus.Int() );

        User::LeaveIfError(

            iMessage->GetUniversalResourceIdentifierFileHandle(

            iMhtmlPartId, handle) );

        }

    else if ( IsLinkedItemL( handle, aId) )

        {

        // linked html item

        }

    else

        {

        // normal attachment

        //Async version of GetAttachmentsListL used here,

        //because it is quite slow operation and when there is

        //many attachments to be loaded Ui jams if synchrounous

        //method is called.

        iMessage->GetAttachmentsListL(

            wait->iStatus,

            iMessageID,

            CImEmailMessage::EAllAttachments,

            CImEmailMessage::EThisMessageAndEmbeddedMessages );

        LOG( "CMailMessage::GetFileHandleL: Starting wait" );

        wait->Start();

        LOG( "CMailMessage::GetFileHandleL: Wait finished" );

        User::LeaveIfError( wait->iStatus.Int() );

        LOG( "CMailMessage::GetFileHandleL: Status ok" );

        MMsvAttachmentManager& manager = iMessage->AttachmentManager();

        handle = manager.GetAttachmentFileL( aId );

        }

    // clean up the wait array for any non-active waits

    CleanupWaitArray();

    __ASSERT_DEBUG( handle.SubSessionHandle() != 0, User::Invariant() );

    LOG( "<CMailMessage::GetFileHandleL" );

    return handle;

    }

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

// CMailMessage::CleanupWaitArray

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

//

void CMailMessage::CleanupWaitArray()

	{

	TInt count( iWaitArray.Count() );

    // cleanup the whole array

    for( TInt i = count - 1; i >= 0; i-- )

    	{

    	CMuiuOperationWait* wait = iWaitArray[i];

    	if( !wait->IsActive() )

    		{

    		iWaitArray.Remove( i );

    		delete wait;

    		}

    	}

	}

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

// CMailMessage::OverrideHtmlMessageCharset

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

//

EXPORT_C void CMailMessage::OverrideHtmlMessageCharset( TUint aCharSet )

    {

    iCharacterSetId = aCharSet;

    if ( aCharSet )

        {

        iFlags |= EFlagHtmlMessageCharSetOverridden;

        }

    else

        {

        iFlags &= ~EFlagHtmlMessageCharSetOverridden;

        }

    }

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

// CMailMessage::DoCancel

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

//

void CMailMessage::DoCancel()

    {

    LOG1("DoCancel @ iState:%d", iState);

    if ( iMessage )

    	{

    	iMessage->Cancel();

    	}

    }

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

// CMailMessage::RunL

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

//

void CMailMessage::RunL()

    {

    switch(iState)

        {

        case ELoadMessageBody:

            {

            LOG("CMailMessage::RunL @ ELoadMessageBody");

            User::LeaveIfError( iStatus.Int() );

            // Body content loaded to iBodyText

            // if HTML mail get file handle to content (iBodyText is empty)

            if( MessageEntry().MHTMLEmail() && !(iFlags & EFlagHtmlError) )

                {

            	TInt error(KErrNone);

                // html file handle

                error = iMessage->

                    GetUniversalResourceIdentifierFileHandle(

                    iMhtmlPartId, iHtmlFile);

	            if (error == KErrNone)

	               	{

	                iFlags |= EFlagAttachment;

	               	}

	            else

	            	{

	               	// Can't load HTML, so try to load plain text body

                    LOG1("CMailMessage::RunL @ Can't load HTML: %d",

            	        error);

	               	iState = EHtmlNotFound;

	               	iFlags |= EFlagHtmlError;

	            	break;

	            	}

                }

            NotifyObserverL(EBodyTextReady);

            break;

            }

        case ELoadAttachments:

            {

            LOG("CMailMessage::RunL @ ELoadAttachments");

            // Attachment files loaded

            User::LeaveIfError( iStatus.Int() );

            NotifyObserverL(EAttachmentsReady);

            LOG("CMailMessage::RunL, NotifyObserverL returned");

            break;

            }

        case ELoadAttachedMessages:

            {

            // Attached files loaded

            User::LeaveIfError( iStatus.Int() );

            const CMsvEntrySelection& sel = iMessage->Selection();

            TInt attachedCount(sel.Count());

            LOG1("CMailMessage::RunL @ ELoadAttachedMessages %d",

            	attachedCount);

            if (attachedCount)

                {

                iFlags |= EFlagAttachedMessages;

                }

			NotifyObserverL(EAttachedMessagesReady);

            break;

            }

        case ELoadLinkedHtmlContent:

            {

            LOG("CMailMessage::RunL @ ELoadLinkedHtmlContent");

            // linked file loaded

            TInt error = iMessage->

                    GetUniversalResourceIdentifierFileHandle(

                    iLinkedfileId, iLinkedHtmlFile);

            if ( error == KErrNone )

                {

                CLinkedHtmlItem* htmlItem = new(ELeave) CLinkedHtmlItem(

                    *iURI, iLinkedfileId );

                CleanupStack::PushL( htmlItem );

                iLinkedHtmlItems->AppendL( htmlItem );

                CleanupStack::Pop( htmlItem );

                }

            else

                {

                // ignore errors. If fails linked item is not added to

                // attachment view.

                LOG1("CMailMessage::RunL @ ELoadLinkedHtmlContent error:%d",

                     error);

                iLinkedHtmlFile = RFile(); // return empty handle

                iEntry->SetEntryL( iMessageID );

                }

			NotifyObserverL(ELinkedFileReady);

            break;

            }

        default:

        	// all loading done. Do nothing

            break;

        }

    DoNextStateL();

    }

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

// CMailMessage::RunError

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