/*
* 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:  
*     Sends messages from Outbox when user selects "Start" in Outbox.
*
*/




// INCLUDE FILES
#include "MceSendOperation.h"   // header

#include <SenduiMtmUids.h>	// mtm uids
#include <MTMStore.h>		// CMtmStore
#include <mtmuibas.h>		// CBaseMtmUi
#include <muiumsvuiserviceutilitiesinternal.h>
#include <msvstd.hrh>


// CONSTANTS
const TInt KSendPriority=1000;
const TInt KSendSelectionGranularity=4;
const TInt KSendServicesGranularity=4;

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

// Two-phased constructor.
CMceSendOperation* CMceSendOperation::NewL(
    CMsvSession& aMsvSession,
    TRequestStatus& aObserverRequestStatus,
    CMtmStore& aMtmStore,
    CMsvEntrySelection* aSel)
    {
    CMceSendOperation* self = new ( ELeave ) CMceSendOperation(aMsvSession, aObserverRequestStatus, aMtmStore);
    CleanupStack::PushL( self );
    self->ConstructL( aSel );
    CleanupStack::Pop( self );
    return self;
    }

// C++ default constructor can NOT contain any code that
// might leave.
//
CMceSendOperation::CMceSendOperation(
    CMsvSession& aMsvSession,
    TRequestStatus& aObserverRequestStatus,
    CMtmStore& aMtmStore)
    :
    CMsvOperation(aMsvSession, KSendPriority, aObserverRequestStatus),
    iMtmStore( aMtmStore ),
    iSelections( KSendSelectionGranularity ),
    iServices( KSendServicesGranularity ),
    iBlank(_L8(""))
    {
    CActiveScheduler::Add(this);
    }

//destructor
CMceSendOperation::~CMceSendOperation()
    {
    Cancel();
    delete iOperation;
    delete iCEntry;
    iSelections.ResetAndDestroy();
    }

// ----------------------------------------------------
// CMceSendOperation::ConstructL
// ----------------------------------------------------
void CMceSendOperation::ConstructL(CMsvEntrySelection* aSelection)
    {
    //@what if service is defined, but has been deleted?
    //@assert aSelection->Count()>=1
    // split the selection up into separate selections for particular services (grouped by MTM)
    CleanupStack::PushL(aSelection);
    TUid   mtm;
    TMsvId service;
    TMsvId actualMessageService;
    
    CMsvEntry* rootEntry=iMsvSession.GetEntryL(KMsvRootIndexEntryIdValue);
    CleanupStack::PushL(rootEntry);
    rootEntry->SetSortTypeL(TMsvSelectionOrdering(KMsvNoGrouping, EMsvSortByNone, ETrue));

    TInt index;
    CMsvEntrySelection* sel;

    iCEntry=iMsvSession.GetEntryL(aSelection->At(0));

    // nextIndexStart is used to keep the services of a particular MTM together
    TInt nextIndexStart = KErrNotFound;
    TMsvId id;
    TBool isDefaultForMTM = EFalse;
    TBool sendfirst = EFalse;
    while (aSelection->Count()>0)
        {
        index = (nextIndexStart>KErrNotFound) ? nextIndexStart:0;
        iCEntry->SetEntryL( aSelection->At(index) );
        mtm=iCEntry->Entry().iMtm;
        sendfirst = ( mtm==KSenduiMtmSmsUid );
        actualMessageService=iCEntry->Entry().iServiceId;
        service=actualMessageService;
        TInt serviceFoundErr = KErrNone;
        TRAP(serviceFoundErr, rootEntry->ChildDataL(service));
        
        // Use the default service if the actual message service is not available
        if ( service == KMsvUnkownServiceIndexEntryIdValue
            || service == KMsvLocalServiceIndexEntryIdValue
            || serviceFoundErr )
            {
            isDefaultForMTM = ETrue;
            service = MsvUiServiceUtilitiesInternal::DefaultServiceForMTML(
                iMsvSession,
                mtm, 
                ETrue );
            const TInt getDefaultErr = ( service != KMsvUnkownServiceIndexEntryIdValue &&
                service != KMsvLocalServiceIndexEntryIdValue );

            TInt foundDefaultServiceErr = KErrNone;
            if ( getDefaultErr == KErrNone )
                {
                TRAP(foundDefaultServiceErr, rootEntry->ChildDataL(service));
                }
            if (getDefaultErr || foundDefaultServiceErr)
                {
                CMsvEntrySelection* servs=rootEntry->ChildrenWithMtmL(mtm);
                if (servs!=0 && servs->Count()>0)
                    {
                    service=servs->At(0);
                    }
                delete servs;
                }
            }
        else
            {
            isDefaultForMTM=EFalse;
            }
        sel=new(ELeave) CMsvEntrySelection;
        CleanupStack::PushL(sel);
        if (sendfirst)
            {
            iServices.InsertL(0,service);
            iSelections.InsertL(0,sel);
            }
        else
            {
            iServices.AppendL(service);
            iSelections.AppendL(sel);
            }
        CleanupStack::Pop( sel );
        nextIndexStart = KErrNotFound;
        
        // Entry IDs for this service
        while (index<aSelection->Count())
            {
            id=aSelection->At(index);
            iCEntry->SetEntryL(id);
            TBool entryIsForThisMTM = (iCEntry->Entry().iMtm==mtm );
            TMsvId thisServiceId=iCEntry->Entry().iServiceId;
            if (entryIsForThisMTM && (thisServiceId==service  || (actualMessageService==thisServiceId && serviceFoundErr) || ((thisServiceId==KMsvUnkownServiceIndexEntryIdValue || thisServiceId==KMsvLocalServiceIndexEntryIdValue) && isDefaultForMTM)))
                {
                sel->AppendL(id);
                aSelection->Delete(index);
                }
            else
                {
                if (nextIndexStart == KErrNotFound && entryIsForThisMTM)
                    {
                    nextIndexStart=index;
                    }

                ++index;
                }
            }
        }

    CleanupStack::PopAndDestroy(2, aSelection); // aSelection, rootEntry

    StartNextOperation();
    }


// ----------------------------------------------------
// CMceSendOperation::StartNextOperation
// ----------------------------------------------------
void CMceSendOperation::StartNextOperation()
    {
    if(iOperation)
        {
        delete iOperation;
        iOperation = NULL;
        }
    TRAPD(err, MakeNewOperationL());

    // whether error or not, remove the data for this operation
    iServices.Delete(0);
    delete iSelections[0];
    iSelections.Delete(0);
    // and set active
    iStatus=KRequestPending;
    SetActive();
    // if error, then complete this pass with the error code
    if (err)
        {
        TRequestStatus* status = &iStatus;
        User::RequestComplete(status, err);
        }
    }

// ----------------------------------------------------
// CMceSendOperation::MakeNewOperationL
// ----------------------------------------------------
void CMceSendOperation::MakeNewOperationL()
    {
    // get the service entry
    iCEntry->SetEntryL(iServices[0]);
    // get the UI setting context to the service
    CBaseMtmUi& mtmui=iMtmStore.GetMtmUiAndSetContextLC(iCEntry->Entry());
    // set the new current selection
    iOperation=mtmui.CopyToL(*iSelections[0], iStatus);
    // set the current mtm
    iMtm=iCEntry->Entry().iMtm;
    CleanupStack::PopAndDestroy(); // release mtmUi
    }

// ----------------------------------------------------
// CMceSendOperation::DoCancel
// ----------------------------------------------------
void CMceSendOperation::DoCancel()
    {
    if (iOperation)
        {
        iOperation->Cancel();
        }
    TRequestStatus* status = &iObserverRequestStatus;
    User::RequestComplete(status, iStatus.Int());
    }

// ----------------------------------------------------
// CMceSendOperation::RunL
// ----------------------------------------------------
void CMceSendOperation::RunL()
    {
    if (iSelections.Count()==0)
        {
        // nothing left to process, so complete the observer
        TRequestStatus* status = &iObserverRequestStatus;
        User::RequestComplete(status, iStatus.Int());
        }
    else
        {
        const TDesC8& progress=ProgressL();
        if (progress.Length()>0)
            {
            iMtmStore.GetMtmUiLC(iCEntry->Entry().iMtm).DisplayProgressSummary(progress);
            CleanupStack::PopAndDestroy(); // release mtmUi
            }
        // start the next pass
        StartNextOperation();
        }
    }

// ----------------------------------------------------
// CMceSendOperation::ProgressL
// ----------------------------------------------------
const TDesC8& CMceSendOperation::ProgressL()
    {
    if (iOperation)
        {
        return iOperation->ProgressL();
        }
    return iBlank;
    }

// End of file