/*

* Copyright (c) 2006 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:  ImumInHealthServicesImpl.cpp

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <MuiuMsvUiServiceUtilities.h>  // MsvUiServiceUtilities

#include <cemailaccounts.h>             // CEmailAccounts

#include <etelmm.h>

#include <SendUiConsts.h>

#include "ImumInternalApiImpl.h"            // CImumInternalApiImpl

#include "ImumMboxManager.h"

#include "EmailUtils.H"

#include "ImumInHealthServicesImpl.h"

#include "ImumInMailboxUtilitiesImpl.h"

#include "ImumUtilsLogging.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

#ifdef __WINS__

_LIT( KIMAEmulatorImei, "123456789012345" );

#endif // __WINS__

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

// CImumInHealthServicesImpl::CImumInHealthServicesImpl()

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

//

CImumInHealthServicesImpl::CImumInHealthServicesImpl(

    CImumInternalApiImpl& aMailboxApi )

    :

    iInternalApi( aMailboxApi ),

    iExtendedSettings( NULL ),

    iRoot( NULL ),

    iUtils( NULL )

    {

    IMUM_CONTEXT( CImumInHealthServicesImpl::CImumInHealthServicesImpl, 0, KLogInApi );

    IMUM_IN();

    IMUM_OUT();

    }

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

// CImumInHealthServicesImpl::~CImumInHealthServicesImpl()

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

//

CImumInHealthServicesImpl::~CImumInHealthServicesImpl()

    {

    IMUM_CONTEXT( CImumInHealthServicesImpl::~CImumInHealthServicesImpl, 0, KLogInApi );

    IMUM_IN();

    delete iExtendedSettings;

    iExtendedSettings = NULL;

    delete iRoot;

    iRoot = NULL;

    iUtils = NULL;

    IMUM_OUT();

    }

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

// CImumInHealthServicesImpl::ConstructL()

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

//

void CImumInHealthServicesImpl::ConstructL()

    {

    IMUM_CONTEXT( CImumInHealthServicesImpl::ConstructL, 0, KLogInApi );

    IMUM_IN();

    iExtendedSettings = CImumMboxDataExtension::NewL();

    GetIMEIFromThePhoneL();

    iRoot = iInternalApi.MsvSession().GetEntryL( KMsvRootIndexEntryIdValue );

    iRoot->SetSortTypeL( TMsvSelectionOrdering(

        KMsvGroupByType | KMsvGroupByStandardFolders,

        EMsvSortByDetailsReverse, ETrue ) );

    iUtils = const_cast<MImumInMailboxUtilities*>(

        &iInternalApi.MailboxUtilitiesL() );

    IMUM_OUT();

    }

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

// CImumInHealthServicesImpl::NewL()

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

//

CImumInHealthServicesImpl* CImumInHealthServicesImpl::NewL(

    CImumInternalApiImpl& aMailboxApi )

    {

    IMUM_STATIC_CONTEXT( CImumInHealthServicesImpl::NewL, 0, utils, KLogInApi );

    IMUM_IN();

    CImumInHealthServicesImpl* self = NewLC( aMailboxApi );

    CleanupStack::Pop( self );

    IMUM_OUT();

    return self;

    }

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

// CImumInHealthServicesImpl::NewLC()

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

//

CImumInHealthServicesImpl* CImumInHealthServicesImpl::NewLC(

    CImumInternalApiImpl& aMailboxApi )

    {

    IMUM_STATIC_CONTEXT( CImumInHealthServicesImpl::NewLC, 0, utils, KLogInApi );

    IMUM_IN();

    CImumInHealthServicesImpl* self = new ( ELeave ) CImumInHealthServicesImpl( aMailboxApi );

    CleanupStack::PushL( self );

    self->ConstructL();

    IMUM_OUT();

    return self;

    }

/******************************************************************************

    Cleanup operations

******************************************************************************/

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

// CImumInHealthServicesImpl::GetIMEIFromTheEntry()

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

//

TIMDErrors CImumInHealthServicesImpl::GetIMEIFromTheEntry(

    const TMsvId aEntryId,

    TDes& aIMEI ) const

    {

    TMsvEntry mailbox;

    TIMDErrors result = GetMailboxEntry( aEntryId, mailbox );

    if ( result == EIMDNoError )

        {

        aIMEI.Copy( mailbox.iDescription.Left( KIMAMaxPhoneIdLength ) );

        }

    return result;

    }

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

// CImumInHealthServicesImpl::GetIMEIFromTheEntry()

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

//

TIMDErrors CImumInHealthServicesImpl::GetIMEIFromTheEntry(

    const TMsvEntry& aEntry,

    TDes& aIMEI ) const

    {

    // IMEI is stored into description field

    aIMEI.Copy( aEntry.iDescription.Left( KIMAMaxPhoneIdLength ) );

    return EIMDNoError;

    }

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

// CImumInHealthServicesImpl::GetIMEIFromThePhone()

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

//

void CImumInHealthServicesImpl::GetIMEIFromThePhoneL()

    {

    IMUM_CONTEXT( CImumInHealthServicesImpl::GetIMEIFromThePhoneL, 0, KLogInApi );

    IMUM_IN();

    // In Emulator version, the imei cannot be fetched, so the basic number

    // is used instead

#ifndef __WINS__

    RTelServer telServer;

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

    CleanupClosePushL(telServer);

    TInt numPhones = 0;

    User::LeaveIfError( telServer.EnumeratePhones( numPhones ) );

    if ( numPhones < 1 )

        {

        User::Leave( KErrNotFound );

        }

    RTelServer::TPhoneInfo info;

    User::LeaveIfError( telServer.GetPhoneInfo( 0, info ) );

    RMobilePhone mobilePhone;

    User::LeaveIfError( mobilePhone.Open( telServer, info.iName ) );

    CleanupClosePushL( mobilePhone );

    //mobilePhone.Initialise();

    TUint32 identityCaps;

    User::LeaveIfError( mobilePhone.GetIdentityCaps( identityCaps ) );

    if ( identityCaps & RMobilePhone::KCapsGetSerialNumber )

        {

        TRequestStatus status;

        RMobilePhone::TMobilePhoneIdentityV1 mobilePhoneIdentity;

        mobilePhone.GetPhoneId( status, mobilePhoneIdentity );

        User::WaitForRequest( status );

        User::LeaveIfError( status.Int() );

        iIMEI.Copy( mobilePhoneIdentity.iSerialNumber );

        }

    else

        {

        User::Leave( KErrNotSupported );

        }

    CleanupStack::PopAndDestroy( &mobilePhone );

    CleanupStack::PopAndDestroy( &telServer );

#else

    iIMEI.Copy( KIMAEmulatorImei );

#endif // __WINS__

    IMUM1(0, "Phones IMEI code: %S", &iIMEI);

    IMUM_OUT();

    }

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

// CImumInHealthServicesImpl::StoreIMEIToMailbox()

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

//

TIMDErrors CImumInHealthServicesImpl::StoreIMEIToMailbox(

    const TMsvId aMailboxId ) const

    {

    IMUM_CONTEXT( CImumInHealthServicesImpl::StoreIMEIToMailbox, 0, KLogInApi );

    IMUM1_IN( "aMailboxId = 0x%x", aMailboxId );

    // Get available mailbox entries

    TMsvEntry entry;

    TIMDErrors result = GetMailboxEntry( aMailboxId, entry );

    // Imap4 & Pop3 & Smtp protocols contain two entries

    if ( result == EIMDNoError )

        {

        // Attempt to store the IMEI code to the entry

        result = StoreIMEIToEntry( entry.Id() );

        }

    // Imap4 / Pop3 protocols have two different entries

    if ( iUtils->IsMailMtm( entry.iMtm ) )

        {

        TMsvEntry secondaryEntry;

        result = GetMailboxEntry( entry.iRelatedId, entry );

        if ( result == EIMDNoError )

            {

            // Attempt to store the IMEI code to the entry

            result = StoreIMEIToEntry( entry.Id() );

            }

        }

    IMUM_OUT();

    return result;

    }

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

// CImumInHealthServicesImpl::StoreIMEIToEntry()

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

//

TIMDErrors CImumInHealthServicesImpl::StoreIMEIToEntry(

    const TMsvId aMailboxId ) const

    {

    IMUM_CONTEXT( CImumInHealthServicesImpl::StoreIMEIToEntry, 0, KLogInApi );

    IMUM1_IN( "aMailboxId = 0x%x", aMailboxId );

    TRAPD( error, StoreIMEIToEntryL( aMailboxId ) );

    IMUM_OUT();

    return ( error == KErrNone ) ? EIMDNoError : EIMDStoringFailureWithIMEI;

    }

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

// CImumInHealthServicesImpl::StoreIMEIToEntryL()

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

//

void CImumInHealthServicesImpl::StoreIMEIToEntryL(

    const TMsvId aMailboxId ) const

    {

    IMUM_CONTEXT( CImumInHealthServicesImpl::StoreIMEIToEntryL, 0, KLogInApi );

    IMUM1_IN( "aMailboxId = 0x%x", aMailboxId );

    CMsvEntry* centry = iInternalApi.MsvSession().GetEntryL( aMailboxId );

    CleanupStack::PushL( centry );

    TMsvEntry tentry = centry->Entry();

    tentry.iDescription.Set( iIMEI );

    centry->ChangeL( tentry );

    CleanupStack::PopAndDestroy( centry );

    centry = NULL;

    IMUM_OUT();

    }

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

// CImumInHealthServicesImpl::GetMailboxEntry()

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

//

TIMDErrors CImumInHealthServicesImpl::GetMailboxEntry(

    const TMsvId aMailboxId,

    TMsvEntry& aMailboxEntry ) const

    {

    IMUM_CONTEXT( CImumInHealthServicesImpl::GetMailboxEntry, 0, KLogInApi );

    IMUM1_IN( "aMailboxId = 0x%x", aMailboxId );

    // Get both receiving and sending entries of the mailbox

    TIMDErrors result = EIMDNoError;

    TMsvId service;

    TInt error = iInternalApi.MsvSession().GetEntry(

        aMailboxId, service, aMailboxEntry );

    // Make sure getting of the entry was ok

    if ( error == KErrNone )

        {

        // Verify that the entry has mail mtm

        if ( !iUtils->IsMailMtm( aMailboxEntry.iMtm, ETrue ) )

            {

            result = EIMDNotMailMtmId;

            }

        // Mailbox, log the details

        else

            {

            IMUM0( 0, "************ Entry Data START ******************" );

            IMUM1( 0, "MailboxId    = 0x%x", aMailboxEntry.Id() );

            IMUM1( 0, "RelatedId    = 0x%x", aMailboxEntry.iRelatedId );

            IMUM1( 0, "MTM type     = 0x%x", aMailboxEntry.iMtm.iUid );

            IMUM1( 0, "Visible      = %d", aMailboxEntry.Visible() );

            IMUM1( 0, "iMtmData2    = 0x%x", aMailboxEntry.iMtmData2 );

            IMUM1( 0, "iDescription = %S", &aMailboxEntry.iDescription );

            IMUM1( 0, "iDetails     = %S", &aMailboxEntry.iDetails );

            IMUM0( 0, "************* Entry Data END *******************" );

         	//Make sure that all settings are ok

            if ( aMailboxEntry.iDetails.Length() > KIMASMaxMailboxNameLength  )

                {

            	if ( aMailboxEntry.iMtm == KUidMsgTypeIMAP4 )

            		{

            		result = EIMDGetEntryFailure;

            		TRAP_IGNORE( result = iInternalApi.SettingsStorerL().CheckMailboxNameImap( aMailboxEntry ) );

            		// Should SettingsStorerL leave, result == EIMDGetEntryFailure

            		}

            	else if ( aMailboxEntry.iMtm == KUidMsgTypePOP3 )

            		{

            		result = EIMDGetEntryFailure;

            		TRAP_IGNORE( result = iInternalApi.SettingsStorerL().CheckMailboxNamePop( aMailboxEntry ) );

            		// Should SettingsStorerL leave, result == EIMDGetEntryFailure

            		}

            	else if ( aMailboxEntry.iMtm == KUidMsgTypeSMTP )

            		{

            		result = EIMDGetEntryFailure;

            		TRAP_IGNORE( result = iInternalApi.SettingsStorerL().CheckMailboxNameSmtp( aMailboxEntry ) );

            		// Should SettingsStorerL leave, result == EIMDGetEntryFailure

            		}

            	else

            		{

        			result = EIMDGetEntryFailure;

            		}

                }

            }

        }

    else

        {

        result = EIMDGetEntryFailure;

        }

    IMUM1( 0, "Result of getting the entry: %d", result );

    IMUM_OUT();

    return result;

    }

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

// CImumInHealthServicesImpl::VerifyMailboxHealth()

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

//

TIMDErrors CImumInHealthServicesImpl::VerifyMailboxHealth(

    const TMsvId aMailboxId ) const

    {

    IMUM_CONTEXT( CImumInHealthServicesImpl::VerifyMailboxHealth, 0, KLogInApi );

    IMUM1_IN( "aMailboxId = 0x%x", aMailboxId );

    TMsvEntry primaryEntry;

    TMsvEntry secondaryEntry;

    TMsvEntry* secondaryEntryPtr = NULL;

    TIMDErrors verification = GetMailboxEntry( aMailboxId, primaryEntry );

    // Imap4 & Pop3 & Smtp protocols contain two entries

    if ( verification == EIMDNoError &&

         iUtils->IsMailMtm( primaryEntry.iMtm ) )

        {

        verification = GetMailboxEntry(

            primaryEntry.iRelatedId, secondaryEntry );

        if ( verification == EIMDNoError )

            {

            secondaryEntryPtr = &secondaryEntry;

            }

        }

    // Make sure

    if ( verification == EIMDNoError )

        {

        verification = VerifyMailboxHealth( primaryEntry, secondaryEntryPtr );

        }

    IMUM_OUT();

    return verification;

    }

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

// CImumInHealthServicesImpl::VerifyMailboxHealth()

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

//

TIMDErrors CImumInHealthServicesImpl::VerifyMailboxHealth(

    const TMsvEntry& aPrimaryEntry,

    const TMsvEntry* aSecondaryEntry ) const

    {

    IMUM_CONTEXT( CImumInHealthServicesImpl::VerifyMailboxHealth, 0, KLogInApi );

    IMUM_IN();

    // Verify that SMTP part of the mailbox has got the settings

    // Verify that SMTP account id's matches with the settings

    // Verify that SMTP mailbox id's matches with the settings

    TIMDErrors verification = MatchEntryWithSettings( aPrimaryEntry );

    IMUM1( 0, "Mailbox primary entry IMEI settings matching result: %d", verification );

    // Verify that related part of the mailbox has got the settings

    // Verify that related account id's matches with the settings

    // Verify that related mailbox id's matches with the settings

    if ( !verification && aSecondaryEntry )

        {

        verification = MatchEntryWithSettings( *aSecondaryEntry );

        IMUM1( 0, "Mailbox secondary entry IMEI settings matching result: %d", verification );

        }

    // Verify that primary entry has IMEI code stored

    if ( !verification )

        {

        verification = VerifyEntryIMEI( aPrimaryEntry );

        IMUM1( 0, "Mailbox primary entry IMEI verification result: %d", verification );

        if( verification == EIMDMissingIMEI )

            {

            // Mailbox has no IMEI code stored. This Mailbox is most likely created

            // with CEmailAccounts. Lock the account to current Phone.

            verification = StoreIMEIToMailbox( aPrimaryEntry.Id() );

            IMUM1( 0, "IMEI missing. Lock to current device: %d", verification );

            }

        }

    // Verify that related entry has IMEI code stored

    if ( !verification && aSecondaryEntry )

        {

        verification = VerifyEntryIMEI( *aSecondaryEntry );

        IMUM1( 0, "Mailbox secondary entry IMEI verification result: %d", verification );

        if( verification == EIMDMissingIMEI )

            {

            // Mailbox has no IMEI code stored. This Mailbox is most likely created

            // with CEmailAccounts. Lock the account to current Phone.

            verification = StoreIMEIToMailbox( aSecondaryEntry->Id() );

            IMUM1( 0, "IMEI missing. Lock to current device: %d", verification );

            }

        }

    IMUM_OUT();

    return verification;

    }

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

// CImumInHealthServicesImpl::MatchEntryWithSettings()

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

//

TIMDErrors CImumInHealthServicesImpl::MatchEntryWithSettings(

    const TMsvEntry& aMailbox ) const

    {

    IMUM_CONTEXT( CImumInHealthServicesImpl::MatchEntryWithSettings, 0, KLogInApi );

    IMUM1_IN( "aMailbox.Id = 0x%x", aMailbox.Id() );

    IMUM_OUT();

    switch ( aMailbox.iMtm.iUid )

        {

        case KSenduiMtmImap4UidValue:

            return VerifyImap4EntryWithSettings( aMailbox );

        case KSenduiMtmPop3UidValue:

            return VerifyPop3EntryWithSettings( aMailbox );

        case KSenduiMtmSmtpUidValue:

            return VerifySmtpEntryWithSettings( aMailbox );

        default:

        	// 3rd party mailbox

        	// MTM UID is unknown -> check technology type and return

        	// EIMDNoError if it is mailbox

        	if( iUtils->IsMailbox( aMailbox.Id() ) )

        		{

        		return EIMDNoError;

        		}

            break;