/*
* Copyright (c) 2002 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:  Implements document class of Mail Editor
*
*/


// INCLUDE FILES
#include "MsgMailEditorDocument.h"
#include "MsgMailEditorAppUi.h"
#include "MsgMailPreferences.h"
#include "MsgMailDRMHandler.h"
#include "MailUtils.h"
#include "CMailCRHandler.h"

#include <cntdef.h>
#include <mtclreg.h>                 // for CClientMtmRegistry
#include <mtmuibas.h>                // for CBaseMtmUi
#include <miutmsg.h>
#include <akninputblock.h>           // CAknInputBlock
#include <MuiuOperationWait.h> // CMuiuOperationWait
#include <MuiuMsgEditorLauncher.h>
#include <MuiuMsvUiServiceUtilities.h>
#include <mmsvattachmentmanager.h>
#include <coeutils.h>
#include <featmgr.h>
#include <bldvariant.hrh>
#include <MsgEditor.hrh>
#include <MsgAttachmentInfo.h>
#include <MsgAttachmentModel.h>
#include <MsgMailEditor.rsg>
#include <mtmuibas.h>
#include <MTMStore.h>
#include <SendUiConsts.h>

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

// Constructor
CMsgMailEditorDocument::CMsgMailEditorDocument( CEikApplication& aApp )
    : CMsgMailDocument( aApp )
    { 
    }

// destructor
CMsgMailEditorDocument::~CMsgMailEditorDocument()
    {
    delete iPrefs;
    iPrefs = NULL; // owned by CMsgMailDocument
    delete iMailCRHandler;
    delete iEmailApi;
    iEmailApi = NULL;
    iMailboxArray.Close();    
    }
// ----------------------------------------------------------------------------
// CMsgMailEditorDocument::ConstructL()
// Symbian OS constructor can leave.
// ----------------------------------------------------------------------------
//
void CMsgMailEditorDocument::ConstructL()
    {
    CMsgEditorDocument::ConstructL();
    iMailCRHandler = CMailCRHandler::NewL( this );
    iEmailApi = CreateEmailApiL( &(Session()) );

    iPrefs = new (ELeave) CMsgMailPreferences();
    iPrefs->SetEncodingSupport( iMailCRHandler->MailEncodingSetting() );
    
    PrepareMtmL( KSenduiMtmSmtpUid );
    }

// ----------------------------------------------------------------------------
// CMsgMailEditorDocument::NewL()
// ----------------------------------------------------------------------------
//
CMsgMailEditorDocument* CMsgMailEditorDocument::NewL( 
        CEikApplication& aApp )     // CMsgMailEditorApp reference
    {
    CMsgMailEditorDocument* self = 
        new (ELeave) CMsgMailEditorDocument( aApp );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );

    return self;
    }
   
// ----------------------------------------------------------------------------
// CMsgMailEditorDocument::CreateAppUiL()
// ----------------------------------------------------------------------------
//
CEikAppUi* CMsgMailEditorDocument::CreateAppUiL()
    {
    return new(ELeave) CMsgMailEditorAppUi;
    }

// ----------------------------------------------------------------------------
// CMsgMailEditorDocument::NotifyChanges()
// ----------------------------------------------------------------------------
//
void CMsgMailEditorDocument::NotifyChanges(TMsgAttachmentCommand aCommand, 
                                           CMsgAttachmentInfo* aAttachmentInfo)
    { 
    TRAP_IGNORE(NotifyChangesL(aCommand, aAttachmentInfo));
    }

// ----------------------------------------------------------------------------
// CMsgMailEditorDocument::GetAttachmentFileL()
// ----------------------------------------------------------------------------
//
RFile CMsgMailEditorDocument::GetAttachmentFileL( TMsvAttachmentId aId )
	{
	return GetAttachmentManagerL().GetAttachmentFileL( aId );
	}
// ----------------------------------------------------------------------------
// CMsgMailEditorDocument::NotifyChangesL()
// ----------------------------------------------------------------------------
//
void CMsgMailEditorDocument::NotifyChangesL(TMsgAttachmentCommand aCommand, 
                                           CMsgAttachmentInfo* aAttachmentInfo)
    {
    // block key events while handling with attachments.
    CAknInputBlock::NewLC();
    switch (aCommand)
        {
        case EMsgAttachmentAdded:
            {
            // don't show confirmation when restoring message
            if (ShowConfirmation())
                {             
                SetChanged(ETrue);
                }            
            break;
            }
        case EMsgAttachmentRemoved:
            {  
            CMuiuOperationWait* wait = CMuiuOperationWait::NewLC();
			
			TMsvAttachmentId attachmentId = aAttachmentInfo->AttachmentId();
			MMsvAttachmentManager& manager = MessageL().AttachmentManager();
			manager.RemoveAttachmentL(attachmentId, wait->iStatus);
            
            wait->Start();
            CleanupStack::PopAndDestroy( wait );
            SetChanged(ETrue);
            break;
            }
        default:

        break;
        }   
    CleanupStack::PopAndDestroy();  // CSI: 12 # CAknInputBlock    
    }

// ----------------------------------------------------------------------------
// CMsgMailEditorDocument::IsNewMessage()
// ----------------------------------------------------------------------------
//    
TBool CMsgMailEditorDocument::IsNewMessage() const
    {
    return (!CurrentEntry().Entry().Visible());
    }

// ----------------------------------------------------------------------------
// CMsgMailEditorDocument::IsReplyMessage()
// ----------------------------------------------------------------------------
//
TBool CMsgMailEditorDocument::IsReplyMessage() const
    {
    return ( (LaunchFlags() & EMsgReplyToMessageSender) ||
        (LaunchFlags() & EMsgReplyToMessageAll));
    }

// ----------------------------------------------------------------------------
// CMsgMailEditorDocument::IsForwardMessage()
// ----------------------------------------------------------------------------
//
TBool CMsgMailEditorDocument::IsForwardMessage() const
	{
	return ( LaunchFlags() & EMsgForwardMessage );
	}

void CMsgMailEditorDocument::ReadSendOptionsL()
    {
    if (!CurrentEntry().Entry().Visible())
        {
        // get default send options from default account
        SendOptions().DefaultAccountSettingsL(
            CurrentEntry().Entry().iServiceId,
            Session());
        }
    else
        {
        // opening old message
        SendOptions().ExportSendOptionsL(Entry());
        }        
    }

// ----------------------------------------------------------------------------
// CMsgMailEditorDocument::IsOnlineL()
// ----------------------------------------------------------------------------
//
TBool CMsgMailEditorDocument::IsOnlineL()
    {
    CMsvEntrySelection* accounts = MsvUiServiceUtilities::GetListOfAccountsL(
        Session() );
    CleanupStack::PushL(accounts);

    CMsvEntry* rootEntry = Session().GetEntryL(KMsvRootIndexEntryId);
    CleanupStack::PushL(rootEntry);

    TBool active = EFalse;
    for (TInt cc=0; cc<accounts->Count(); cc++)
        {
        TMsvEntry tentry;
        TRAPD( err, tentry=rootEntry->ChildDataL(accounts->At(cc)) );

        if ( err==KErrNone && tentry.Connected() )
            {
            active = ETrue;
            break;
            }
        }
    CleanupStack::PopAndDestroy( 2, accounts );				// CSI: 47,12 # rootEntry, accounts
    return active;
    }

// ----------------------------------------------------------------------------
// CMsgMailEditorDocument::OpenMailMessageEntryL()
// ----------------------------------------------------------------------------
//
void CMsgMailEditorDocument::OpenMailMessageEntryL( TMsvEntry aEntry )
    {
    CMtmStore* store = CMtmStore::NewL( Session() );
    CleanupStack::PushL(store);
    CBaseMtmUi& mtmUi=store->GetMtmUiAndSetContextLC( aEntry );
    CMuiuOperationWait* wait = CMuiuOperationWait::NewLC();
    CMsvOperation* op=mtmUi.EditL( wait->iStatus );
    wait->Start();
    CleanupStack::PopAndDestroy( 3, store );				// CSI: 47,12 # store, ContextLC, wait
    delete op;    
    }

// ----------------------------------------------------------------------------
// CMsgMailEditorDocument::SendImmediatelyL()
// ----------------------------------------------------------------------------
//
void CMsgMailEditorDocument::SendImmediatelyL( const TMsvId aMsgId )
    {
    CMsvEntrySelection* selection = new (ELeave) CMsvEntrySelection;
    CleanupStack::PushL(selection);
    selection->AppendL( aMsgId );

    CMuiuOperationWait* wait = CMuiuOperationWait::NewLC();

    // Switch MTM context to the service to send to.
    const TMsvEntry entry( Entry() );
    Mtm().SwitchCurrentEntryL( entry.iServiceId );

    CBaseMtmUi& ui= MtmUi();
    CMsvOperation* op=ui.CopyToL(*selection, wait->iStatus);

    CleanupStack::PushL( op );
    wait->Start(); // wait for asynch operation

    const TDesC8& finalBuf = op->ProgressL();

    ui.DisplayProgressSummary(finalBuf);

    CleanupStack::PopAndDestroy(3, selection);				// CSI: 47,12 # op, wait, selection
    }
    
// ----------------------------------------------------------------------------
// CMsgMailEditorDocument::GetHealthyMailboxListL()
// ----------------------------------------------------------------------------
//  
MImumInHealthServices::RMailboxIdArray 
        CMsgMailEditorDocument::GetHealthyMailboxListL(
        const TInt64& aFlags )
    {    
    // The list of mailboxes must be updated. 
    User::LeaveIfError( 
        iEmailApi->HealthServicesL().GetMailboxList( 
            iMailboxArray, aFlags ) );
    
    return iMailboxArray;
    }
        
// ----------------------------------------------------------------------------
// CMsgMailEditorDocument::GetAttachmentManagerL()
// ----------------------------------------------------------------------------
//
MMsvAttachmentManager& CMsgMailEditorDocument::GetAttachmentManagerL()
    {
	// Load Attachment list
	MessageL().GetAttachmentsListL(iMessageID, 
		CImEmailMessage::EAllAttachments, 
		CImEmailMessage::EThisMessageAndEmbeddedMessages);
	
	return MessageL().AttachmentManager();       
    }
    
// End of File