/*
* Copyright (c) 2004 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 class
*
*/



// INCLUDE FILES
#include "NcnDebug.h"
#include "NcnOutboxSendOperation.h"   // header
#include "NcnModel.h"

#include    <SenduiMtmUids.h>           // MTM Uids
#include    <msvids.h>                  // Entry Ids
#include    <muiumsvuiserviceutilitiesinternal.h> // Messaging utilites
#include    <gsmerror.h>                // SMS sending failure error codes


// CONSTANTS
const TInt KNcnSendPriority=CActive::EPriorityStandard;
const TInt KNcnSendSelectionGranularity=4;

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

// Two-phased constructor.
CNcnOutboxSendOperation* CNcnOutboxSendOperation::NewL(
    CMsvSession& aMsvSession,
    TRequestStatus& aObserverRequestStatus )
    {
    // Create the instance of sending operation
    CNcnOutboxSendOperation* self =
        new (ELeave) CNcnOutboxSendOperation(
            aMsvSession, aObserverRequestStatus );

    // Push self into cleanup stack during construction
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop();

    // Return the object
    return self;
    }

// C++ default constructor can NOT contain any code that
// might leave.
//
CNcnOutboxSendOperation::CNcnOutboxSendOperation(
    CMsvSession& aMsvSession,
    TRequestStatus& aObserverRequestStatus )
    :
    CMsvOperation( aMsvSession, KNcnSendPriority, aObserverRequestStatus ),
    iSelections( KNcnSendSelectionGranularity ),
    iServices(),
    iSupportedMsgs( CNcnOutboxSendOperation::ENcnSupportsSmsSending )
    {
    // Start scheduler
    CActiveScheduler::Add(this);
    }

//destructor
CNcnOutboxSendOperation::~CNcnOutboxSendOperation()
    {
    // Cancel sending
    Cancel();

    // Delete sending operation
    delete iOperation;
    iOperation = NULL;

    // Delete entry
    delete iEntry;
    iEntry = NULL;

    // Remove services from queue and destroy message selections
    iServices.Reset();
    iSelections.ResetAndDestroy();
    }

// ----------------------------------------------------
// CNcnOutboxSendOperation::ConstructL
// ----------------------------------------------------
//
void CNcnOutboxSendOperation::ConstructL()
    {
    // Get rootindex entry
    iEntry = iMsvSession.GetEntryL( KMsvRootIndexEntryId );
    iEntry->SetSortTypeL(
        TMsvSelectionOrdering( KMsvNoGrouping, EMsvSortByNone, ETrue ) );

    // Set sending flags
    iSupportedMsgs |= ENcnSendSms;

    // Start sending
    StartSendingL();
    }

// ----------------------------------------------------
// CNcnOutboxSendOperation::RunL
// ----------------------------------------------------
//
void CNcnOutboxSendOperation::RunL()
    {
    NCN_RDEBUG(_L("CNcnOutboxSendOperation::RunL"));
    User::LeaveIfError( iStatus.Int() );

    // Check and start sending, if needed
    TUid sendMtm;

    // Check if messages needs to be sent
    if( IsSendingNeeded( sendMtm ) )
        {
        StartSendingL();
        }
    // Nothing to send, complete operation
    else
        {
        CompleteObserver( iStatus.Int() );
        }
    }

// ----------------------------------------------------
// CNcnOutboxSendOperation::RunError
// ----------------------------------------------------
//
TInt CNcnOutboxSendOperation::RunError( TInt aError )
    {
    NCN_RDEBUG_INT(_L("CNcnOutboxSendOperation::RunError - Error %d"), aError );
    CompleteObserver( aError );
    return aError;
    }

// ----------------------------------------------------
// CNcnOutboxSendOperation::DoCancel
// ----------------------------------------------------
//
void CNcnOutboxSendOperation::DoCancel()
    {
    // Check if sending operation is running
    if( iOperation )
        {
        // Cancel it
        iOperation->Cancel();
        }

    // Complete operation with current status
    CompleteObserver( iStatus.Int() );
    }

// ----------------------------------------------------
// CNcnOutboxSendOperation::ProgressL
// ----------------------------------------------------
//
const TDesC8& CNcnOutboxSendOperation::ProgressL()
    {
    // Check if operation exists
    if( iOperation )
        {
        // Return the operation
        return iOperation->ProgressL();
        }

    // If no operation, return blank information
    return KNcnBlankBuffer;
    }

// ---------------------------------------------------------
// CNcnOutboxSendOperation::CompleteOperation
// ---------------------------------------------------------
//
void CNcnOutboxSendOperation::CompleteObserver( TInt aStatus )
    {
    // Get the observer status
    TRequestStatus* status = &iObserverRequestStatus;
    User::RequestComplete( status, aStatus );
    }

// ----------------------------------------------------
// CNcnOutboxSendOperation::StartSendingL
// ----------------------------------------------------
//
void CNcnOutboxSendOperation::StartSendingL()
    {
    // Remove any sending operation that currently may be running
    delete iOperation;
    iOperation = NULL;

    // Check if selection can be created for selected

    // Check if there was errors with creating selection
    if  ( CheckAndCreateSelectionL() )
        {
        // Create new operation and trap any errors
        SendWaitingSMSMessages();

        // Clear selection after the operation is complete
        RemoveSelection();
        }
    else
        {
    // Set state to pending
        CompleteSelf( KErrNone );
        }
    }

    // if error, then complete this pass with the error code
void CNcnOutboxSendOperation::SendWaitingSMSMessages()
    {
    TRAPD( err, SendWaitingSMSMessagesL() );
    if  ( err != KErrNone )
        {
        ASSERT( !IsActive() );
        CompleteSelf( err );
        }
    }

// ----------------------------------------------------
// CNcnOutboxSendOperation::SendWaitingSMSMessagesL
// ----------------------------------------------------
//
void CNcnOutboxSendOperation::SendWaitingSMSMessagesL()
    {
    // Get first selection from queue
    CMsvEntrySelection& selection = ( *iSelections[0] );

    // Get count of messages in queue
    TInt count = selection.Count();

    // Go through all messages
    while( count-- )
        {
        // Select message
        iEntry->SetEntryL( selection[count] );
        TMsvEntry entry( iEntry->Entry() );

        // Check if the message is tried to send when in offline
        if( ( entry.SendingState() == KMsvSendStateSuspended ||
              entry.SendingState() == KMsvSendStateFailed ) &&
            ( entry.iError == KErrGsmOfflineOpNotAllowed ||
              entry.iError == KErrGsmOfflineSimOpNotAllowed ) )
            {
            // Set message to wait sending
            NCN_RDEBUG(_L("SendWaitingSMSMessagesL: entry qualified" ) );
            entry.SetSendingState( KMsvSendStateWaiting );
            iEntry->ChangeL( entry );
            }
		else
			{
			NCN_RDEBUG_INT2(_L("SendWaitingSMSMessagesL: entry not qualified: state %d, error %d" ), entry.SendingState(), entry.iError );
			selection.Delete( count );
			}
        }
    selection.Compress();

    // Set entry to outbox
    iMtm = iEntry->Entry().iMtm;
    iEntry->SetEntryL( KMsvGlobalOutBoxIndexEntryId );

	NCN_RDEBUG_INT(_L("SendWaitingSMSMessagesL: %d entries to send" ), selection.Count() );
    // Start sending
	if ( selection.Count() )
		{
		iOperation = iEntry->CopyL( selection, iServices[0], iStatus );
        SetActive();
		}
    else
        {
        // Nothing to send, but we must complete the observer via our RunL callback
        CompleteSelf( KErrNone );
        }
    }


// ----------------------------------------------------
// CNcnOutboxSendOperation::RemoveSelection
// ----------------------------------------------------
//
void CNcnOutboxSendOperation::RemoveSelection()
    {
    // Clear the the current selection.
    iServices.Delete(0);

    // Delete selection object and index
    delete iSelections[0];
    iSelections.Delete(0);
    }

// ----------------------------------------------------
// CNcnOutboxSendOperation::CreateSelectionL
// ----------------------------------------------------
//
void CNcnOutboxSendOperation::CreateSelectionL(
    const TUid &aUidForSel,
    const TMsvId& aServiceId,
    CMsvEntrySelection*& aSelection )
    {
    // Set entry to outbox and get messages from outbox
    iEntry->SetEntryL( KMsvGlobalOutBoxIndexEntryId );
    aSelection = iEntry->ChildrenWithMtmL( *&aUidForSel );

    // Check if there is anything to put into array
    if( aSelection->Count() )
        {
        // Put selection to queue
        CleanupStack::PushL( aSelection );
        iSelections.AppendL( aSelection );
        CleanupStack::Pop( aSelection );

        // Put service to queue
        iServices.AppendL( aServiceId );
        }
    else
        {
        // Remove selection
        delete aSelection;
        aSelection = NULL;
        }
    }

// ----------------------------------------------------
// CNcnOutboxSendOperation::CheckAndCreateSelectionL
// ----------------------------------------------------
//
TBool CNcnOutboxSendOperation::CheckAndCreateSelectionL()
    {
    // Get root index
    iEntry->SetEntryL( KMsvRootIndexEntryId );

    // MTM, for which the selection is collected
    TUid sendMtm;

    // Selection of messages for sending
    CMsvEntrySelection* smsSelection = NULL;

    // While MTM's available for sending
    while( smsSelection == NULL && IsSendingNeeded( sendMtm ) )
        {
        // Find default SMS service
        TMsvId serviceId =
            MsvUiServiceUtilitiesInternal::DefaultServiceForMTML(
                iMsvSession, *&sendMtm, ETrue );

        // Check if the service ID is found
        if( serviceId != KMsvNullIndexEntryId )
            {
            // Create selection of messages of specified MTM
            CreateSelectionL( sendMtm, serviceId, smsSelection );
            }
		else
			{
			NCN_RDEBUG(_L("CNcnOutboxSendOperation::CheckAndCreateSelectionL: default SMS service not found"));
			}

        // Selection has been created, remove the flag
        RemoveSendingFlag( *&sendMtm );
        }

    const TBool selectionAvailable = ( smsSelection != NULL );
    return selectionAvailable;
    }

// ----------------------------------------------------
// CNcnOutboxSendOperation::RemoveSendingFlag
// ----------------------------------------------------
//
void CNcnOutboxSendOperation::RemoveSendingFlag( const TUid& aMtm )
    {
    // Decide actions by mtm
    switch( aMtm.iUid )
        {
        // SMS-messages
        case KSenduiMtmSmsUidValue:
            iSupportedMsgs &= ~ENcnSendSms;
            break;
        // Do nothing
        default:
            break;
        }
    }

// ----------------------------------------------------
// CNcnOutboxSendOperation::IsSendingNeeded
// ----------------------------------------------------
//
TBool CNcnOutboxSendOperation::IsSendingNeeded(
    TUid& aMtm ) const
    {
    // Set starting condition
    TBool needSending = EFalse;

    // Check if sms-sending is supported and messages need to be sent
    if( iSupportedMsgs & ENcnSupportsSmsSending &&
        iSupportedMsgs & ENcnSendSms )
        {
        aMtm = KSenduiMtmSmsUid;
        needSending = ETrue;
        }
    // Otherwise nothing needs to be done
    else
        {
        aMtm.iUid = 0;
        needSending = EFalse;
        }

    // Return the result
    return needSending;
    }

// ----------------------------------------------------
// CNcnOutboxSendOperation::CompleteSelf
// ----------------------------------------------------
//
void CNcnOutboxSendOperation::CompleteSelf( TInt aValue )
    {
    TRequestStatus* status = &iStatus;
    User::RequestComplete( status, aValue );
    SetActive();
    }
    
// End of file