/*

* 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 "ipsplgsosbaseplugin.hrh"

#include "ipsplgmailstoreroperation.h"

#include "ipsplgmessagepartstoreroperation.h"

// <cmail> S60 UID update

#define FREESTYLE_EMAIL_UI_SID 0x200255BA

// </cmail> S60 UID update

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 ),

    iEventHandler( NULL ),

    iSessionOk( ETrue ),

    iBrandingId( NULL ),

    iIsUnderUiProcess( EFalse )

    {

    FUNC_LOG;

    }

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

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

//

CIpsPlgSosBasePlugin::~CIpsPlgSosBasePlugin()

    {

    FUNC_LOG;

    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 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 );

    iSyncStateHandler = CIpsPlgSyncStateHandler::NewL( 

            *iSession, *this, iOperations );

    iEventHandler->RegisterPropertyObserverL( iSyncStateHandler );

    RProcess process;

    if ( process.SecureId() == FREESTYLE_EMAIL_UI_SID )

        {

        iIsUnderUiProcess = ETrue;

        }

    else

        {

        iIsUnderUiProcess = EFalse;

        }

#ifndef RD_101_EMAIL

    RAlwaysOnlineClientSession aosession; 

    TInt err = aosession.Connect();

    if ( err == KErrNone )

        {

        TBuf8<1> dummyBuf;

        TRAP( err, aosession.RelayCommandL( 

                EServerAPIEmailDisableAOEmailPlugin, 

                dummyBuf ) );

        }

    aosession.Close();

#endif    

    } 

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

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

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 );

            }

        }

    }

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

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

 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 ) );

        CEmailAccounts* acc = CEmailAccounts::NewLC();

        TSmtpAccount smtpAcc;

        acc->GetSmtpAccountL( tEntry.iRelatedId , smtpAcc );

        CImSmtpSettings* smtpSet = new (ELeave) CImSmtpSettings();

        CleanupStack::PushL( smtpSet );

        acc->LoadSmtpSettingsL( smtpAcc, *smtpSet );

        address = smtpSet->EmailAddress().AllocL();

        CleanupStack::PopAndDestroy( 2, acc );

        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 );

        }

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

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

    // delete MRU list from cen rep

    iMruList->ClearDataL( aMailBoxId );

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

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

    if ( tEntry.Connected() )

        {

        DisconnectL( aMailBoxId, aOperationObserver, aRequestId, ETrue );

        }

    else

        {

        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 );

    CleanupStack::PopAndDestroy( mboxEntry );

    return *iBrandingId;

    }

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

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

void CIpsPlgSosBasePlugin::MoveMessagesL( 

    const TFSMailMsgId& aMailBoxId,

    const RArray<TFSMailMsgId>& aMessageIds,

    const TFSMailMsgId& aSourceFolderId,

    const TFSMailMsgId& aDestinationFolderId )

	{

    FUNC_LOG;

	// Pop3 has no implementation for this virtual

	if( aDestinationFolderId.Id() == KMsvDraftEntryId  )

	    {

	    MoveMessagesToDraftL( 

	        aMailBoxId, 

	                          aMessageIds, 

	                          aSourceFolderId, 

	                          aDestinationFolderId );

	    }

	}

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

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

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

    }

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

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

void CIpsPlgSosBasePlugin::CopyMessagesL(

    const TFSMailMsgId& /*aMailBoxId*/,

    const RArray<TFSMailMsgId>& /*aMessageIds*/,

    RArray<TFSMailMsgId>& /*aNewMessages*/,

    const TFSMailMsgId& /*aSourceFolderId*/,

    const TFSMailMsgId& /*aDestinationFolderId*/ )

	{

	}

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

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

MDesCArray* CIpsPlgSosBasePlugin::GetMrusL(

                const TFSMailMsgId& aMailBoxId)

    {

    return iMruList->GetMruListL( aMailBoxId );

    }

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

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

void CIpsPlgSosBasePlugin::SetMrusL(

    const TFSMailMsgId& aMailBoxId,

    MDesCArray*  aNewMruList )

    {

    iMruList->SetMruListL( aMailBoxId, aNewMruList );

    }

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

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

void CIpsPlgSosBasePlugin::GoOnlineL( const TFSMailMsgId& aMailBoxId )

    {

    if ( !ConnOpRunning( aMailBoxId) )

        {

        // append mailbox id go online mailbox array

        RefreshNowL( aMailBoxId, *this, 0 );

        }

    }

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

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

void CIpsPlgSosBasePlugin::GoOfflineL( const TFSMailMsgId& aMailBoxId )

    {

    FUNC_LOG;

    CancelAllOnlineOperations( aMailBoxId );

    // use 0 for request id