/*

* 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:  MsgEditorDocument implementation

*

*/

// ========== INCLUDE FILES ================================

#include <mtclbase.h>

#include <mtmuibas.h>                   // MTM UI base

#include <mtmdef.h>

#include <MuiuMsgEditorLauncher.h>      // for TEditorParameters

#include <MuiuOperationWait.h>          // for CMuiuOperationWait

#include "MsgEditorDocument.h"          // module header

#include "MsgEditorModelPanic.h"        // Panics

#include "MsgEditorLauncher.h"

#include "MsgEditorModel.h"             // Model

#include "MsgEditorModelObserver.h"     // MMsgEditorModelObserver

#include "MsgAttachmentModel.h"

#include "MsgEditorAppUi.h"             // MsgEditorAppUi

// ========== EXTERNAL DATA STRUCTURES =====================

// ========== EXTERNAL FUNCTION PROTOTYPES =================

// ========== CONSTANTS ====================================

const TInt KOperationGranularity = 4;

// ========== MACROS =======================================

// ========== LOCAL CONSTANTS AND MACROS ===================

// ========== MODULE DATA STRUCTURES =======================

// ========== LOCAL FUNCTION PROTOTYPES ====================

// ========== LOCAL FUNCTIONS ==============================

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

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

// CMsgEditorDocument::CMsgEditorDocument

//

// Constructor.

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

//

EXPORT_C CMsgEditorDocument::CMsgEditorDocument( CEikApplication& aApp ) :

    CEikDocument( aApp )

    {

    }

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

// CMsgEditorDocument::~CMsgEditorDocument

//

// Destructor.

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

//

EXPORT_C CMsgEditorDocument::~CMsgEditorDocument()

    {

    if ( iOpWatchers )

        {

        iOpWatchers->ResetAndDestroy();

        }

    delete iOpWatchers;

    delete iModel;

    delete iAttachmentModel;

    iAttachmentModel = NULL;

    }

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

// CMsgEditorDocument::SetEntryWithoutNotificationL

//

// Set given entry to be current context.

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

//

EXPORT_C void CMsgEditorDocument::SetEntryWithoutNotificationL( TMsvId aId )

    {

    __ASSERT_DEBUG( ( &( iModel->Session() ) != NULL ), Panic( ENoSession ) );

    iModel->SetEntryL( aId );

    }

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

// CMsgEditorDocument::SetEntryL

//

// Set given entry to be current context and notifies after change.

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

//

EXPORT_C void CMsgEditorDocument::SetEntryL( TMsvId aId )

    {

    SetEntryWithoutNotificationL( aId );

#ifdef RD_MSG_FAST_PREV_NEXT

    SetMsgAsReadL();

#endif

    EntryChangedL();

    }

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

// CMsgEditorDocument::Entry

//

// Return context.

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

//

EXPORT_C const TMsvEntry& CMsgEditorDocument::Entry() const

    {

    __ASSERT_DEBUG( HasModel(), Panic( ENoMessageEntry ) );

    return iModel->Entry();

    }

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

// CMsgEditorDocument::Session

//

// Return session.

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

//

EXPORT_C CMsvSession& CMsgEditorDocument::Session() const

    {

    __ASSERT_DEBUG( iModel, Panic( ENoSession ) );

    return iModel->Session();

    }

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

// CMsgEditorDocument::CurrentEntry

//

// Returns CMsvEntry of the current context.

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

//

EXPORT_C CMsvEntry& CMsgEditorDocument::CurrentEntry() const

    {

    __ASSERT_DEBUG( HasModel(), Panic( ENoMessageEntry ) );

    return iModel->Mtm().Entry();

    }

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

// CMsgEditorDocument::Mtm

//

// Returns the current Mtm.

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

//

EXPORT_C CBaseMtm& CMsgEditorDocument::Mtm() const

    {

    __ASSERT_DEBUG( HasModel(), Panic( ENoMessageEntry ) );

    return iModel->Mtm();

    }

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

// CMsgEditorDocument::MtmUi

//

// to be deprecated

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

//

EXPORT_C CBaseMtmUi& CMsgEditorDocument::MtmUi() const

    {

    __ASSERT_DEBUG( HasModel(), Panic( ENoMessageEntry ) );

    CBaseMtmUi* retVal = NULL;

    TRAP_IGNORE( retVal = &(iModel->MtmUiL() ) );

    return *retVal;

    }

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

// CMsgEditorDocument::MtmUiData

//

// to be deprecated

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

//

EXPORT_C CBaseMtmUiData& CMsgEditorDocument::MtmUiData() const

    {

    __ASSERT_DEBUG( HasModel(), Panic( ENoMessageEntry ) );

    CBaseMtmUiData* retVal = NULL;

    TRAP_IGNORE( retVal = &(iModel->MtmUiDataL() ) );

    return *retVal;

    }

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

// CMsgEditorDocument::MtmUiL

//

// Returns the current MtmUi.

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

//

EXPORT_C CBaseMtmUi& CMsgEditorDocument::MtmUiL() const

    {

    __ASSERT_DEBUG( HasModel(), Panic( ENoMessageEntry ) );

    return iModel->MtmUiL();

    }

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

// CMsgEditorDocument::MtmUiDataL

//

// Returns the current MtmUiData.

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

//

EXPORT_C CBaseMtmUiData& CMsgEditorDocument::MtmUiDataL() const

    {

    __ASSERT_DEBUG( HasModel(), Panic( ENoMessageEntry ) );

    return iModel->MtmUiDataL();

    }

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

// CMsgEditorDocument::PrepareMtmL

//

// Loads client and ui mtm's. Set clietn mtm

// to have some context

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

//

EXPORT_C void CMsgEditorDocument::PrepareMtmL( const TUid aMtmType )

    {

    iModel->PrepareMtmL( aMtmType );

    }

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

// CMsgEditorDocument::RestoreL

//

// Called (by the environment) when editor or viewer is opened embedded.

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

//

EXPORT_C void CMsgEditorDocument::RestoreL(

        const CStreamStore& aStore,

        const CStreamDictionary& aStreamDic )

    {

    TEditorParameters params;

    RStoreReadStream stream;

    stream.OpenLC( aStore, aStreamDic.At( KUidMsvEditorParameterValue ) );

    params.InternalizeL( stream );

    CleanupStack::PopAndDestroy();  // stream

    LaunchParametersL( params );

    EntryChangedL();

    PrepareToLaunchL( static_cast<CMsgEditorAppUi*>( iAppUi ) );

    }

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

// CMsgEditorDocument::HasModel

//

// Check if model is already created.

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

//

EXPORT_C TBool CMsgEditorDocument::HasModel() const

    {

    return ( iModel && NULL != &( iModel->Mtm() ) );

    }

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

// CMsgEditorDocument::ConstructL

//

// 2nd phase constructor.

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

//

EXPORT_C void CMsgEditorDocument::ConstructL()

    {

    iModel = new ( ELeave ) CMsgEditorModel();

    iModel->ConstructL();

    iOpWatchers = new ( ELeave ) CSingleOpWatchers( KOperationGranularity );

    iAttachmentModel = CreateNewAttachmentModelL( EFalse );

    iAttachmentModel->SetObserver( this );

    }

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

// CMsgEditorDocument::PrepareToLaunchL

//

// Calls LaunchView() function after all pre-launch steps are completed.

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

//

EXPORT_C void CMsgEditorDocument::PrepareToLaunchL(

    MMsgEditorLauncher* aLauncher )

    {

    __ASSERT_DEBUG( iModel, Panic( ENoMessageEntry ) );

    iModel->iLaunchWait--;

    if ( iModel->iLaunchWait <= 0 )

        {

        __ASSERT_DEBUG( aLauncher, Panic( EViewNotReady ) );

        aLauncher->LaunchViewL();

        iLaunched = ETrue;

        }

    }

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

// CMsgEditorDocument::LaunchParametersL

//

// Handle command line parameters.

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

//

EXPORT_C void CMsgEditorDocument::LaunchParametersL(

    const TEditorParameters& aParameters )

    {

    iLaunchFlags = aParameters.iFlags;

    iModel->Wait();

    if ( aParameters.iFlags & EMsgCreateMessageToService )

        {

        // Create new message in given folder/service.

        const TMsvId id = CreateNewL( aParameters.iId, DefaultMsgFolder() );

        SetEntryWithoutNotificationL( id );

        }

    else if ( aParameters.iFlags & EMsgCreateNewMessage )

        {

        // create new in folder.

        const TMsvId id = CreateNewL(DefaultMsgService(), aParameters.iId);

        SetEntryWithoutNotificationL(id);

        }

    else if ( aParameters.iFlags & EMsgForwardMessage       ||

             aParameters.iFlags & EMsgReplyToMessageSender ||

             aParameters.iFlags & EMsgReplyToMessageAll )

        {

        const TMsvId id = ChangeContextL( aParameters );

         // Save priority of forwarded message from original entry as

         // entry is changed on SetEntryWithoutNotificationL

        TMsvPriority priority( EMsvMediumPriority );

        if( aParameters.iFlags & EMsgForwardMessage )

            {

            priority = Entry().Priority();

            }

        SetEntryWithoutNotificationL( id );

        TBool changeEntry = EFalse;

        TMsvEntry tEntry = Entry();

        // Set saved priority for new entry.

        tEntry.SetPriority( priority ); 

        if ( tEntry.Visible() )

            {

            tEntry.SetVisible( EFalse );

            changeEntry = ETrue;

            }

        if ( !tEntry.InPreparation() )

            {

            tEntry.SetInPreparation( ETrue );

            changeEntry = ETrue;

            }

        if ( changeEntry )

            {

            CurrentEntry().ChangeL( tEntry );

            }

        }

    else

        {

        // Open editor using the given message id.

        const TMsvId preparedId = PrepareContextL( aParameters.iId );

        SetEntryWithoutNotificationL( preparedId );

        }

    __ASSERT_DEBUG( HasModel(), Panic( ENoMessage ) );

    SetMsgAsReadL();

    }

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

// CMsgEditorDocument::ChangeContextL

//

// Handles existing messages (typically opened from Drafts).

// This function can be overriden by inherited class if some

// preprocessing is needed for the message.

//

// Default implementation just returns the given context.

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

//

EXPORT_C TMsvId CMsgEditorDocument::PrepareContextL( const TMsvId aContext )

    {

    return aContext;

    }

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

// CMsgEditorDocument::ChangeContextL

//

// Handles reply and forward messages, change current message context to

// be context of replied or forwarded message.

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

//

EXPORT_C TMsvId CMsgEditorDocument::ChangeContextL(

    const TEditorParameters& aParameters )

    {

    SetEntryWithoutNotificationL( aParameters.iId );

    CMuiuOperationWait* wait = CMuiuOperationWait::NewLC();

    CMsvOperation* oper = NULL;

    const TMsvPartList parts = aParameters.iPartList;

    const TMsvId dest = aParameters.iDestinationFolderId;

    if ( aParameters.iFlags & EMsgReplyToMessageSender ||

        aParameters.iFlags & EMsgReplyToMessageAll )

        {

        oper = CreateReplyL( dest, parts, wait->iStatus );

        }

    else if (aParameters.iFlags & EMsgForwardMessage)

        {

        oper = CreateForwardL( dest, parts, wait->iStatus );

        }

    __ASSERT_ALWAYS( oper != NULL, Panic( ENoMessage ) );

    CleanupStack::PushL( oper );

    wait->Start();

    const TMsvId id = GetOperId( *oper );

    if ( id < 0 )

        {

        User::Leave( id );

        }

    CleanupStack::PopAndDestroy( 2 );      // oper, wait

    return id;

    }

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

// CMsgEditorDocument::CreateReplyL

//

//

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

//

EXPORT_C CMsvOperation* CMsgEditorDocument::CreateReplyL(

    TMsvId aDest, TMsvPartList aParts, TRequestStatus& aStatus )

    {

    return Mtm().ReplyL( aDest, aParts, aStatus );

    }

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

// CMsgEditorDocument::CreateForwardL

//

//

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

//

EXPORT_C CMsvOperation* CMsgEditorDocument::CreateForwardL(

    TMsvId aDest, TMsvPartList aParts, TRequestStatus& aStatus )

    {

    return Mtm().ForwardL( aDest, aParts, aStatus );

    }

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

// CMsgEditorDocument::AddSingleOperationL

//

// Adds operation into operation queque.

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

//

EXPORT_C void CMsgEditorDocument::AddSingleOperationL(

    CMsvOperation* aOperation, CMsvSingleOpWatcher* aSopWatch )

    {

    __ASSERT_DEBUG( aSopWatch != NULL, Panic( ENullPointer ) );

    __ASSERT_DEBUG( aOperation != NULL, Panic( ENullPointer ) );

    aSopWatch->SetOperation( aOperation );

    iOpWatchers->AppendL( aSopWatch );

    }

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

// CMsgEditorDocument::OpCompleted

//

// Is called when operation is completed. If operation is found, handler is called.

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

//

EXPORT_C void CMsgEditorDocument::OpCompleted(

    CMsvSingleOpWatcher& aOpWatcher, TInt aCompletionCode )

    {

    __ASSERT_DEBUG( iOpWatchers != NULL, Panic( ENullPointer ) );

    const TInt count = iOpWatchers->Count();

    TInt i = 0;

    for ( ; i < count; i++ )

        {

        // looking for right operation in array.

        if ( ( (*iOpWatchers)[i] ) == &aOpWatcher )

            {

            break;

            }

        }

    if ( i >= count )

        {

        // Although invalid operation is an error, we do not

        // want to panic for that in product - since it not supposed

        // to seem anyhow to user (Is this true?)

        __ASSERT_DEBUG( EFalse, Panic( EInvalidOperation ) );

        return ;

        }

    if ( aCompletionCode != KErrNone )

        {

        __ASSERT_DEBUG( HasModel(), Panic( ENullPointer ) );

        TRAP_IGNORE( MtmUi().DisplayProgressSummary( (*iOpWatchers)[i]->Operation().ProgressL() ) );

        }

    // Operation has completed, remove watcher and operation (watcher owns operation)

    // NOTE: Have to delete the watcher first, as the array does not call delete.

    delete (*iOpWatchers)[i];

    iOpWatchers->Delete( i );

    iOpWatchers->Compress();

    }