/*

* Copyright (c) 2008 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: This file implements classes CIpsPlgSosBasePlugin, Plugin.

 *

*/

#include "emailtrace.h"

#include "ipsplgheaders.h"

#include "FreestyleEmailUiConstants.h"

#define FREESTYLE_EMAIL_UI_SID 0x2001E277

const TInt KOpGranularity = 2;

_LIT( KMimeTextCalRequest,  "text/calendar; method=REQUEST;" );

_LIT( KMimeTextCalResponse, "text/calendar; method=RESPONSE;" );

_LIT( KMimeTextCalCancel,   "text/calendar; method=CANCEL;" );

_LIT8( KMethod, "method" );

_LIT8( KRequest, "REQUEST" );

_LIT8( KResponse, "RESPONSE" );

_LIT8( KCancel, "CANCEL" );

#ifdef __WINS__

_LIT( KEmulatorIMEI, "123456789012345" );

#endif // __WINS__

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

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

//

CIpsPlgSosBasePlugin::CIpsPlgSosBasePlugin( const TUint aFSPluginId ) :

    iFSPluginId( aFSPluginId ),

    iSession( NULL ),

    iMsgMapper( NULL ),

    iOperations( KOpGranularity ),

    iActivitytimers( KOpGranularity ),

    iSmtpService( NULL ),

    iCachedEntry( NULL ),

    iCachedEmailMessage( NULL ),

    iMruList( NULL ),

    iSearch( NULL ),

    iSettingsApi( NULL ),

    iEventHandler( NULL ),

    iSessionOk( ETrue ),

    iBrandingId( NULL ),

    iIsUnderUiProcess( EFalse )

    {

    FUNC_LOG;

    }

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

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

//

CIpsPlgSosBasePlugin::~CIpsPlgSosBasePlugin()

    {

    FUNC_LOG;

    if ( iWait.IsStarted() )

        {

        iWait.AsyncStop();

        }

    iOperations.ResetAndDestroy();

    iActivitytimers.ResetAndDestroy();

    iOperations.Close();

    iActivitytimers.Close();

    delete iSmtpService;

    delete iMruList;

    if ( iEventHandler )

        {

        iEventHandler->UnRegisterPropertyObserver( iSyncStateHandler );

        }

    delete iEventHandler;

    delete iCachedEntry;

    delete iCachedEmailMessage;

    delete iMsgMapper;

    delete iSearch;

    delete iSettingsApi;

    delete iSyncStateHandler;

    delete iSession;

    delete iBrandingId;

    }

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

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

void CIpsPlgSosBasePlugin::BaseConstructL()

    {

    FUNC_LOG;

    iEventHandler = CIpsPlgEventHandler::NewL( *this );

    iSession = CMsvSession::OpenAsyncL( *iEventHandler );

    iMsgMapper = CIpsPlgMsgMapper::NewL( *iSession, *this );

    iSmtpService = CIpsPlgSmtpService::NewL( *iSession, *this );

    iMruList = CIpsPlgMruList::NewL( );

    iSearch = CIpsPlgSearch::NewL( *iSession, *this );

    iSettingsApi = CIpsSetDataApi::NewL( *iSession );

    iSettingsApi->GetIMEIFromThePhoneL( iIMEI );

    iSyncStateHandler = CIpsPlgSyncStateHandler::NewL(

            *iSession, *this, iOperations );

    iEventHandler->RegisterPropertyObserverL( iSyncStateHandler );

    RProcess process;

    if ( process.SecureId() == FREESTYLE_EMAIL_UI_SID )

        {

        iIsUnderUiProcess = ETrue;

        }

    else

        {

        iIsUnderUiProcess = EFalse;

        }

    RAlwaysOnlineClientSession aosession;

    TInt err = aosession.Connect();

    if ( err == KErrNone )

        {

        TBuf8<1> dummyBuf;

        TRAP( err, aosession.RelayCommandL(

                EServerAPIEmailDisableAOEmailPlugin,

                dummyBuf ) );

        }

    aosession.Close();

    }

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

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

void CIpsPlgSosBasePlugin::CompleteConstructL()

    {

    FUNC_LOG;

    iSessionOk = ETrue;

    iEventHandler->CompleteConstructL( iSession );

    }

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

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

void CIpsPlgSosBasePlugin::SessionTerminated()

    {

    FUNC_LOG;

    iSessionOk = EFalse;

    }

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

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

void CIpsPlgSosBasePlugin::OpCompleted(

	CIpsPlgSingleOpWatcher& aOpWatcher,

	TInt aCompletionCode )

    {

    FUNC_LOG;

    // Get valid operation count in each, some operations could have been

    // deleted in array

    TInt opId = aOpWatcher.Operation().Id();

    for ( TInt i = iOperations.Count()-1; i >= 0; i-- )

        {

        CMsvOperation& oper = iOperations[i]->Operation();

        if ( oper.Id() == opId )

            {

            DeleteAndRemoveOperation( i, aCompletionCode );

            }

        }

    // make draft deletion synchronous so that empty drafts are not left after application close.

    if ( iWait.IsStarted() )

        {

        iWait.AsyncStop();

        }

    }

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

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

 TFSMailBoxStatus CIpsPlgSosBasePlugin::GetMailBoxStatus(

    const TFSMailMsgId&  aMailBoxId  )

    {

    FUNC_LOG;

    TMsvEntry tEntry;

    TMsvId service;

    TFSMailBoxStatus status;

    if( iSessionOk )

        {

        iSession->GetEntry( aMailBoxId.Id(), service, tEntry );

        if ( tEntry.Connected() )

            {

            status = EFSMailBoxOnline;

            }

        else if ( ConnOpRunning( aMailBoxId ) )

            {

            status = EFSMailBoxOnline;

            }

        else

            {

            status = EFSMailBoxOffline;

            }

        }

    else

        {

        status = EFSMailBoxOffline;

        }

    return status;

    }

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

// CIpsPlgSosBasePlugin::SpecifiedSendingMailbox

// Returns 'null' ID, because the method is not relevant with IPS protocols

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

 TFSMailMsgId CIpsPlgSosBasePlugin::SpecifiedSendingMailbox()

     {

    FUNC_LOG;

     return TFSMailMsgId();

     }

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

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

void CIpsPlgSosBasePlugin::ListMailBoxesL( RArray<TFSMailMsgId>& aMailboxes )

	{

    FUNC_LOG;

	if( !iSessionOk )

        {

        User::Leave( KErrNotReady );

        }

	CMsvEntry* cEntry = iSession->GetEntryL( KMsvRootIndexEntryId );

    CleanupStack::PushL( cEntry );

    CMsvEntrySelection* childEntries = cEntry->ChildrenWithMtmL( MtmId() );

    CleanupStack::PushL( childEntries );

    TInt count( childEntries->Count() );

    for ( TInt i(0); i < count; i++)

        {

      	TFSMailMsgId mailboxId;

    	TMsvEntry tEntry;

    	TMsvId serviceId;

    	TDriveUnit driveUnit = EDriveC;

        iSession->GetEntry( childEntries->At(i), serviceId, tEntry );

        if( iIMEI.Compare( tEntry.iDescription ) == 0 )

            {

            mailboxId.SetPluginId( TUid::Uid( PluginId() ) );

            mailboxId.SetId( childEntries->At(i) );

            aMailboxes.AppendL( mailboxId );

            }

        else

            {

            TRAPD( err, driveUnit = iSession->CurrentDriveL() );

            if ( err == KErrNone && driveUnit == EDriveC )

                {

                // When memory card restored to another phone mailbox

                // should be visible

                mailboxId.SetPluginId( TUid::Uid( PluginId() ) );

                mailboxId.SetId( childEntries->At(i) );

                StoreIMEIToMailboxL( mailboxId.Id() );

                aMailboxes.AppendL( mailboxId );

                }

            }

        }

    CleanupStack::PopAndDestroy( 2, cEntry ); // childEntries

	}

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

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

CFSMailBox* CIpsPlgSosBasePlugin::GetMailBoxByUidL(

    const TFSMailMsgId& aMailBoxId)

	{

    FUNC_LOG;

    CFSMailBox* result( NULL );

    TMsvEntry tEntry;

    TMsvId    serviceId;

    TInt      status;

    HBufC*    address( NULL );

    if( !iSessionOk )

        {

        User::Leave( KErrNotReady );

        }

    status = iSession->GetEntry( aMailBoxId.Id(), serviceId, tEntry );

    if ( status == KErrNone )

        {

        result = CFSMailBox::NewL( aMailBoxId );

        CleanupStack::PushL( result );   // << result

        result->SetName( tEntry.iDetails );

        result->SetSettingsUid( TUid::Uid( IPS_SET_ECOM_IMPLEMENTATION_UID ) );

        iSettingsApi->GetMailboxAddressL( tEntry, address );

        CleanupStack::PushL( address ); // << address

        CFSMailAddress* fsAddress = CFSMailAddress::NewLC();    // << fsAddress

        fsAddress->SetEmailAddress( *address );

        result->SetOwnMailAddressL( fsAddress );

        CleanupStack::Pop( fsAddress ); // >> fsAddress

        CleanupStack::PopAndDestroy( address ); // >>> address

        CleanupStack::Pop( result );    // >> result

        }

    return result;

	}

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

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

void CIpsPlgSosBasePlugin::DeleteMailBoxByUidL(

    const TFSMailMsgId& aMailBoxId,

    MFSMailRequestObserver& aOperationObserver,

    const TInt aRequestId )

    {

    FUNC_LOG;

    TMsvEntry tEntry;

    TMsvId service;

    if( !iSessionOk )

        {

        User::Leave( KErrNotReady );

        }

    // Create connection to Always Online

    RAlwaysOnlineClientSession aosess;

    User::LeaveIfError( aosess.Connect() );

    // Prepare the parameters to be forwarded to AO-server

    TPckg<TMsvId> param = aMailBoxId.Id();

    // Send message to server and close it

    TRAP_IGNORE( aosess.RelayCommandL( EServerAPIEmailAgentRemove, param ) );

    aosess.Close();

    // delete MRU list from cen rep

    iMruList->ClearDataL( aMailBoxId );

    iSyncStateHandler->NotifyMailboxRemove( aMailBoxId.Id() );

    CancelAllOnlineOperations( aMailBoxId );

    iSession->GetEntry( aMailBoxId.Id(), service, tEntry );

    if ( tEntry.Connected() )

        {

        DisconnectL( aMailBoxId, aOperationObserver, aRequestId, ETrue );

        // remove activity timer from array here but leave the actual delete

        // to the disconnect operation. This is because the disconnect op

        // sometimes tries to use the timer after it was deleted here.

        TInt timerCount = iActivitytimers.Count();

        for ( TInt j = 0; j < timerCount; j++ )

            {

            if ( iActivitytimers[j]->FSMailboxId() == aMailBoxId )

                {

                iActivitytimers.Remove( j );

                timerCount--;

                j--;

                }

            }

        }

    else

        {

        iSettingsApi->RemoveAccountL( tEntry, *iSession );

        TFSProgress progress = { TFSProgress::EFSStatus_Waiting, 0, 0, KErrNone };

        progress.iProgressStatus = TFSProgress::EFSStatus_RequestComplete;

        progress.iError = KErrNone;

        TInt requestId = aRequestId;

        aOperationObserver.RequestResponseL( progress, requestId );

        DeleteActivityTimer( aMailBoxId  );

        }

    }

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

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

TDesC& CIpsPlgSosBasePlugin::GetBrandingIdL( const TFSMailMsgId& aMailBoxId )

    {

    FUNC_LOG;

    if( !iSessionOk )

        {

        User::Leave( KErrNotReady );

        }

    CMsvEntry* mboxEntry = iSession->GetEntryL( aMailBoxId.Id() );

    CleanupStack::PushL( mboxEntry );

    TDesC& address = iSettingsApi->GetServerAddressL( *mboxEntry );

    delete iBrandingId;

    iBrandingId = NULL;

    iBrandingId = address.AllocL();

    CleanupStack::PopAndDestroy( mboxEntry );

    return *iBrandingId;

    }

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

// Pop3 has no implementation for this virtual

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

void CIpsPlgSosBasePlugin::MoveMessagesL(

    const TFSMailMsgId& aMailBoxId,

    const RArray<TFSMailMsgId>& aMessageIds,

    const TFSMailMsgId& aSourceFolderId,

    const TFSMailMsgId& aDestinationFolderId )

	{

    FUNC_LOG;

	if( aDestinationFolderId.Id() == KMsvDraftEntryId  )

	    {

	    MoveMessagesToDraftL(

	        aMailBoxId,

	        aMessageIds,

	        aSourceFolderId,

	        aDestinationFolderId );

	    }

	}

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

// asynchronic version from move messages function, pop3 plugin not implent

// this virtual fucntion.

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

TInt CIpsPlgSosBasePlugin::MoveMessagesL(

    const TFSMailMsgId& aMailBoxId,

    const RArray<TFSMailMsgId>& aMessageIds,

    const TFSMailMsgId& aSourceFolderId,

    const TFSMailMsgId& aDestinationFolderId,

    MFSMailRequestObserver& aOperationObserver,

    TInt aRequestId )

    {

    FUNC_LOG;

    TInt ret = KErrNotSupported;

    if( aDestinationFolderId.Id() == KMsvDraftEntryId  )

        {

        MoveMessagesToDraftL(

            aMailBoxId,

            aMessageIds,

            aSourceFolderId,

            aDestinationFolderId );

        ret = KErrNone;

        }

    ret = KErrNotSupported;

    TFSProgress progress = { 

            TFSProgress::EFSStatus_RequestComplete, 0, 0, ret };

    aOperationObserver.RequestResponseL(

            progress, aRequestId );

    return ret;

    }

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

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

void CIpsPlgSosBasePlugin::MoveMessagesToDraftL(

    const TFSMailMsgId& /*aMailBoxId*/,

    const RArray<TFSMailMsgId>& aMessageIds,

    const TFSMailMsgId& aSourceFolderId,

    const TFSMailMsgId& aDestinationFolderId )

    {

    FUNC_LOG;

    TInt count( aMessageIds.Count() );

    if ( !count )

        {

        User::Leave( KErrArgument );

        }

    if( !iSessionOk )

        {

        User::Leave( KErrNotReady );

        }

    TMsvId msgService;

    TMsvEntry tEntry;

    CMsvEntrySelection* sel = new(ELeave) CMsvEntrySelection;

    CleanupStack::PushL(sel);

    CMsvEntry* msgEntry = iSession->GetEntryL( aMessageIds[0].Id() );

    CleanupStack::PushL( msgEntry );

	for( TInt i(0); i < count; i++ )

        {

        iSession->GetEntry( aMessageIds[i].Id(), msgService, tEntry );

        if( aSourceFolderId.Id() == KMsvGlobalOutBoxIndexEntryIdValue )

            {

            if( tEntry.SendingState() != KMsvSendStateSending )

                {

                // Set all states in outbox to suspended

                tEntry.SetSendingState( KMsvSendStateSuspended );

                msgEntry->ChangeL( tEntry );

                sel->AppendL( tEntry.Id() );

                }

            else

                {

                // Not possible to move when sending, what to do???

                // Probably some note back to UI, but we leave..

                User::Leave( KErrNotSupported );

                }

            }

        else

            {

            sel->AppendL( tEntry.Id() );

            }

        }

    if( sel->Count() )

        {

        CIpsPlgOperationWait* wait = CIpsPlgOperationWait::NewLC();

        if( !aSourceFolderId.IsNullId() )

            {

            CMsvEntry* cEntry = iSession->GetEntryL( aSourceFolderId.Id() );

            CleanupStack::PushL( cEntry );

            cEntry->MoveL(

                *sel,

                           aDestinationFolderId.Id(),//KMsvDraftEntryIdValue

                           wait->iStatus );

            CleanupStack::PopAndDestroy( cEntry );

            }

        else

            {

            // Message is in editing state, we can't use parent as entry

            // because it's equal to destination.

            TMsvId parent = msgEntry->Entry().Parent();

            msgEntry->SetEntryL( parent );

            msgEntry->CopyL(

                *sel,

                             aDestinationFolderId.Id(),//KMsvDraftEntryIdValue

                             wait->iStatus );

            }

        wait->Start();

        CleanupStack::PopAndDestroy( wait ); // wait

        }

    CleanupStack::PopAndDestroy( 2, sel ); // msgEntry, sel

    }

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

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