/*

* Copyright (c) 2007 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 class CIpsSetWizardAdapter.

*

*/

//INCLUDES

#include "emailtrace.h"

#include <e32base.h>

#include <SendUiConsts.h>

#include <centralrepository.h>      // CRepository

#include <AlwaysOnlineManagerClient.h>

#include <cmdestination.h> 

#include "ipssetwizardadapter.h"

#include "ipssetdatamanager.h"

#include "ipssetuiitemaccesspoint.h"

#include "ipssetutils.h"

#include "ipssetdataextension.h"

#include "ipssetdata.h"

// becuase of RD_IPS_AO_PLUGIN flag, can be removed

// when flag is removed

#include "ipsplgsosbaseplugin.hrh"

//CONSTANTS

const TInt KMaxMailboxes = 10;

const TInt KImapDefFoldersRetrieve = 50; // Default value for retrieve From other folders

// security enums in fs wizard cenrep cenrep

// Security protocol (0 = OFF, 1 = StartTLS, 2 = SSL/TLS)

const TInt KWizardDataSecurityOff = 0;

const TInt KWizardDataSecurityTLS = 1;

const TInt KWizardDataSecuritySSL = 2;

const TInt KWizardTCPMaxPort = 65535;

const TInt KWizardMaxUidValue = 50;

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

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

CIpsSetWizardAdapter* CIpsSetWizardAdapter::NewL( 

    CRepository& aRepository, CMsvSession& aSession ) 

    {

    FUNC_LOG;

    CIpsSetWizardAdapter* self = CIpsSetWizardAdapter::NewLC( 

        aRepository, aSession );

    CleanupStack::Pop( self );

    return self;

    }

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

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

CIpsSetWizardAdapter* CIpsSetWizardAdapter::NewLC( 

    CRepository& aRepository, CMsvSession& aSession )

    {

    FUNC_LOG;

    CIpsSetWizardAdapter* self = new( 

        ELeave ) CIpsSetWizardAdapter( aRepository, aSession );

    CleanupStack::PushL( self );

    self->ConstructL( );

    return self;

    }

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

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

CIpsSetWizardAdapter::~CIpsSetWizardAdapter()

    {

    FUNC_LOG;

    }

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

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

CIpsSetWizardAdapter::CIpsSetWizardAdapter( 

    CRepository& aRepository, CMsvSession& aSession ) 

    : iWizardCenRep( aRepository ), iSession( aSession ) 

    {

    FUNC_LOG;

    }

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

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

void CIpsSetWizardAdapter::ConstructL()

    {

    FUNC_LOG;

    ClearFields();

    }

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

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

void CIpsSetWizardAdapter::ClearFields()

    {

    FUNC_LOG;

    iAccountNumber = 0;

    iMaxAccounts = 0;

    iEmailAddress.Zero();

    iUsername.Zero();

    iPassword.Zero();

    iIncomingServer.Zero();

    iProtocol = 0;

    iInSecurityAuth = 0;

    iInSecurityProtocol = 0;

    iInIncomingPort = 0;

    iProviderOutgoingServer.Zero();

    iProviderOutSecurityAuth = 0;

    iProviderOutSecurityProtocol = 0;

    iProviderOutgoingPort = 0;

    iOperatorOutgoingServer.Zero();

    iOperatorOutSecurityAuth = 0;

    iOperatorOutSecurityProtocol = 0;

    iOperatorOutgoingPort = 0;

    iHiddenData = EFalse;

    iRecomendedAP.Zero();

    iMailboxName.Zero();

    }

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

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

void CIpsSetWizardAdapter::ReadWizardSettignsL()

    {

    FUNC_LOG;

    ClearFields();

    TIpsSetUtilsTextPlain tempText;

    TInt error = KErrNone;

    error = GetIntFromCenRepL( ECRKAccountsConfigured, iAccountNumber );

    if ( error != KErrNone )

        {

        iAccountNumber = KCRKAccountsConfiguredDefault;

        }

    error = GetIntFromCenRepL( ECRKMaxAccountsReached, iMaxAccounts );

    if ( error != KErrNone )

        {

        iMaxAccounts = KCRKMaxAccountsReachedDefault;

        }

    error = GetTextFromCenRepL( ECRKPopImapEmailAddressId, iEmailAddress );

    if ( error != KErrNone )

        {

        iEmailAddress = KCRKPopImapEmailAddressIdDefault;

        }

    tempText.Zero();

    error = GetTextFromCenRepL( ECRKPopImapUsernameId, tempText );

    if ( error != KErrNone )

        {

        tempText = KCRKPopImapUsernameIdDefault;

        }

    ChangeAsciiPrintable( tempText, iUsername );

    tempText.Zero();

    error = GetTextFromCenRepL( ECRKPopImapPasswordId, tempText );

    if ( error != KErrNone )

        {

        tempText = KCRKPopImapPasswordIdDefault;

        }

    ChangeAsciiPrintable( tempText, iPassword );

    tempText.Zero();

    error = GetTextFromCenRepL( ECRKPopImapIncomingServerId, tempText );

    if ( error != KErrNone )

        {

        tempText = KCRKPopImapIncomingServerIdDefault;

        }

    ChangeAsciiPrintable( tempText, iIncomingServer );

    error = GetIntFromCenRepL( ECRKPopImapProtocolIndicatorId, iProtocol );

    if ( error != KErrNone )

        {

        iProtocol = KCRKPopImapProtocolIndicatorIdDefault;

        }

    error = GetIntFromCenRepL( ECRKPopImapIncomingSecurityAuthId, iInSecurityAuth );

    if ( error != KErrNone )

        {

        iInSecurityAuth = KCRKPopImapIncomingSecurityAuthIdDefault;

        }

    error = GetIntFromCenRepL( ECRKPopImapIncomingSecurityProtocolId, 

            iInSecurityProtocol );

    if ( error != KErrNone )

        {

        iInSecurityProtocol = KCRKPopImapIncomingSecurityProtocolIdDefault;

        }

    error = GetIntFromCenRepL(  ECRKPopImapIncomingPortId, iInIncomingPort );

    if ( error != KErrNone )

        {

        iInIncomingPort = KCRKPopImapIncomingPortIdDefault;

        }

    tempText.Zero();

    error = GetTextFromCenRepL( ECRKPopImapOutgoingServerId, tempText );

    if ( error != KErrNone )

        {

        tempText = KCRKPopImapOutgoingServerIdDefault;

        }

    ChangeAsciiPrintable( tempText, iProviderOutgoingServer );

    error = GetIntFromCenRepL( ECRKPopImapOutgoingSecurityAuthId, 

            iProviderOutSecurityAuth );

    if ( error != KErrNone )

        {

        iProviderOutSecurityAuth = KCRKPopImapOutgoingSecurityAuthIdDefault;

        }

    error = GetIntFromCenRepL( ECRKPopImapOutgoingSecurityProtocolId, 

            iProviderOutSecurityProtocol );

    if ( error != KErrNone )

        {

        iProviderOutSecurityProtocol = KCRKPopImapOutgoingSecurityProtocolIdDefault;

        }

    error = GetIntFromCenRepL( ECRKPopImapOutgoingPortId, iProviderOutgoingPort );

    if ( error != KErrNone )

        {

        iProviderOutgoingPort = KCRKPopImapOutgoingPortIdDefault;

        }

    error = GetTextFromCenRepL( ECRKPopImapOperatorOutgoingServerId, 

            iOperatorOutgoingServer );

    if ( error != KErrNone )

        {

        iOperatorOutgoingServer = KCRKPopImapOperatorOutgoingServerIdDefault;

        }

    error = GetIntFromCenRepL( ECRKPopImapOperatorSecurityAuthId, 

            iOperatorOutSecurityAuth );

    if ( error != KErrNone )

        {

        iOperatorOutSecurityAuth = KCRKPopImapOperatorSecurityAuthIdDefault;

        }

    error = GetIntFromCenRepL( ECRKPopImapOperatorSecurityProtocolId, 

            iOperatorOutSecurityProtocol );

    if ( error != KErrNone )

        {

        iOperatorOutSecurityProtocol = KCRKPopImapOperatorSecurityProtocolIdDefault;

        }

    error = GetIntFromCenRepL( ECRKPopImapOperatorPortId,  

            iOperatorOutgoingPort );

    if ( error != KErrNone )

        {

        iOperatorOutgoingPort = KCRKPopImapOperatorPortIdDefault;

        }

    error = GetIntFromCenRepL( ECRKHideUsernameInSettings,  

            iHiddenData );

    if ( error != KErrNone )

        {

        iHiddenData = KCRKPopImapDataHideDefault;

        }

    error = GetTextFromCenRepL( ECRKPopImapAccessPointId, iRecomendedAP );

    if ( error != KErrNone )

        {

        iRecomendedAP = KCRKPopImapAccessPointIdDefault;

        }

    tempText.Zero();

    error = GetTextFromCenRepL( ECRKPopImapMailboxName, tempText );

    if ( error != KErrNone )

        {

        tempText = KCRKPopImapMailboxNameDefault;

        }

    ChangeUnicodePrintable( tempText, iMailboxName );

    EmptyWizardCenRep();

    } 

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

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

TInt CIpsSetWizardAdapter::GetIntFromCenRepL( TIpsSetWizardSettings aSetting, 

                                              TInt& aVariable )

    {

    FUNC_LOG;

    if ( &iWizardCenRep )

        {

        return iWizardCenRep.Get( aSetting, aVariable );

        }

    return KErrNone;

    }

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

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

TInt CIpsSetWizardAdapter::GetTextFromCenRepL( TIpsSetWizardSettings aSetting, 

                                 TIpsSetUtilsTextPlain& aVariable )

    {

    FUNC_LOG;

    if ( &iWizardCenRep )

        {

        return iWizardCenRep.Get( aSetting, aVariable );

        }

    return KErrNone;

    }

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

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

void CIpsSetWizardAdapter::EmptyWizardCenRep()

    {

    FUNC_LOG;

    if ( &iWizardCenRep )

        {

        iWizardCenRep.Set( ECRKPopImapEmailAddressId, KNullDesC );

        iWizardCenRep.Set( ECRKPopImapUsernameId, KNullDesC );

        iWizardCenRep.Set( ECRKPopImapPasswordId, KNullDesC );

        iWizardCenRep.Set( ECRKPopImapIncomingServerId, KNullDesC );

        iWizardCenRep.Set( 

                ECRKPopImapProtocolIndicatorId, KErrNotFound );

        iWizardCenRep.Set( 

                ECRKPopImapIncomingSecurityAuthId, KErrNotFound );

        iWizardCenRep.Set( 

                ECRKPopImapIncomingSecurityProtocolId, KErrNotFound );

        iWizardCenRep.Set( ECRKPopImapIncomingPortId, KErrNotFound );

        iWizardCenRep.Set( ECRKPopImapOutgoingServerId, KNullDesC );

        iWizardCenRep.Set( 

                ECRKPopImapOutgoingSecurityAuthId, KErrNotFound );

        iWizardCenRep.Set( 

                ECRKPopImapOutgoingSecurityProtocolId, KErrNotFound );

        iWizardCenRep.Set( ECRKPopImapOutgoingPortId, KErrNotFound );

        iWizardCenRep.Set( 

                ECRKPopImapOperatorOutgoingServerId, KNullDesC );

        iWizardCenRep.Set( 

                ECRKPopImapOperatorSecurityAuthId, KErrNotFound );

        iWizardCenRep.Set( 

                ECRKPopImapOperatorSecurityProtocolId, KErrNotFound );

        iWizardCenRep.Set( ECRKPopImapOperatorPortId, KErrNotFound );

        iWizardCenRep.Set( ECRKPopImapAccessPointId, KNullDesC );  

        iWizardCenRep.Set( ECRKPopImapMailboxName, KNullDesC );  

        }

    }

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

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

void CIpsSetWizardAdapter::SetSettingsL( CIpsSetData& aSetData )

    {

    FUNC_LOG;

    TImIAPChoice iap;

    TPortValue port;

    TSecurityValue security;

    aSetData.SetProtocol( 

        (iProtocol == 0) ? KSenduiMtmPop3Uid : KSenduiMtmImap4Uid );

    if(iProtocol == 0)// KSenduiMtmPop3Uid - for Pop account- default is Headers Only

        {

        aSetData.SetDownloadSizeL( CIpsSetData::EHeaders,KIpsSetDataHeadersOnly);

        }

    else 

        {

        aSetData.SetDownloadSizeL( CIpsSetData::EHeadersPlus, KIpsSetDataDefaultDownloadSizeKb );

        TInt retImFolders = aSetData.RetrieveLimit(CIpsSetData::EImap4Folders); //TRetrieveLimit

        if(retImFolders==-1)

            {

            TInt retPopInbox = aSetData.RetrieveLimit(CIpsSetData::EPop3Limit); 

            TInt retImInbox  = aSetData.RetrieveLimit(CIpsSetData::EImap4Inbox); 

            aSetData.SetRetrieveLimit(retPopInbox,retImInbox,KImapDefFoldersRetrieve);

            }

        }

    aSetData.SetEmailAddressL( iEmailAddress );

    aSetData.SetUserNameL( iUsername, iUsername );

    aSetData.SetUserPwdL( iPassword, iPassword );

    aSetData.SetMailServerL( iIncomingServer, iProviderOutgoingServer );

    security = SetSecurityValues( iInSecurityProtocol, iProviderOutSecurityProtocol );

    aSetData.SetSecurity( security.inSecurity, security.outSecurity );

    port = CheckPortValues( iProtocol, 

                            iInIncomingPort, 

                            iProviderOutgoingPort, 

                            security );

    aSetData.SetPort( port.inport, port.outport );                             

    aSetData.SetDataHide( iHiddenData );

    aSetData.SetMailboxName( CheckMailboxNamesL( iMailboxName ) );

    aSetData.SetUserAuthentication( CIpsSetData::EUseIncoming );

    iap = SetIAPByNameL( iRecomendedAP );

    TBool setIAP = ETrue;

    RCmManager cmmgr;

    cmmgr.OpenLC();

    TCmDefConnValue defConnValue;

    cmmgr.ReadDefConnL( defConnValue );

    //if IAP isn't set by SettingWizard, we try to get the SNAP.

    if ( iap.iIAP <= 0 )

        {

        //Use SNAP when we got it and it does contain access point.

        //For other situations as below, we set 'ask when need' or default IAP

        //1. defConnValue.iType == ECmDefConnAskOnce

        //2. Got SNAP, but it does not contain any access point

        //3. Got default IAP when defConnValue.iType == ECmDefConnConnectionMethod

        iap.iDialogPref = ECommDbDialogPrefPrompt;

        iap.iIAP = 0;        

        //Check default connection is destination or connection method

        if ( defConnValue.iType == ECmDefConnDestination )

            {

            //Get SNAP from cmmgr

            RCmDestination destination;

            CleanupClosePushL( destination );

            destination = cmmgr.DestinationL( defConnValue.iId );

            //check if SNAP has IAPs

            if ( destination.ConnectionMethodCount() > 0 )

                {

                //if SNAP contain access point, we use SNAP

                CImIAPPreferences* iapPref = CImIAPPreferences::NewLC();

                iapPref->SetSNAPL( defConnValue.iId );

                aSetData.SetIapL( *iapPref, *iapPref );

                CleanupStack::PopAndDestroy( iapPref );

                setIAP = EFalse;

                }

                CleanupStack::PopAndDestroy( &destination );             

            }

        else if( defConnValue.iType == ECmDefConnConnectionMethod ) 

            {

            iap.iDialogPref = ECommDbDialogPrefDoNotPrompt;

            iap.iIAP = defConnValue.iId;

            }

        }

    else

        {

        // recommended IAP is defined

        // try setting SNAP that contains the IAP

        TBool found( EFalse );

        RArray< TUint32 > destArray;

        CleanupClosePushL( destArray );

        //Get list of all destinations

        cmmgr.AllDestinationsL( destArray );

        TInt arrayCount( destArray.Count() );

        CMManager::TSnapMetadataField metaFieldPurpose( CMManager::ESnapMetadataPurpose );

        CMManager::TSnapMetadataField metaFieldLocalized( CMManager::ESnapMetadataDestinationIsLocalised );

        //Traverse list of destinations

        for ( TInt i = 0; i < arrayCount && !found; ++i )

            {

            RCmDestination destination = cmmgr.DestinationL( destArray[ i ] );

            CleanupClosePushL( destination );

            TUint32  destinationPurpose = destination.MetadataL ( metaFieldPurpose );

            TUint32  destinationLocalized = destination.MetadataL ( metaFieldLocalized );

            TInt iapCount ( destination.ConnectionMethodCount() );

            if ( destinationPurpose == CMManager::ESnapPurposeInternet &&

                 destinationLocalized == CMManager::ELocalisedDestInternet && 

                 iapCount )

                {

                // found the Internet destination and it has at least one access point

                for ( TInt c=0;c < iapCount && !found; c++ )

                    {

                    RCmConnectionMethod connMethod = destination.ConnectionMethodL( c );

                    CleanupClosePushL( connMethod );

                    TUint32 iapId = connMethod.GetIntAttributeL( CMManager::ECmIapId );

                    HBufC* connName = connMethod.GetStringAttributeL( CMManager::ECmName );

                    CleanupStack::PushL( connName );

                    CleanupStack::PopAndDestroy( connName ); 

                    if ( iapId == iap.iIAP )

                        {

                        CImIAPPreferences* iapPref = CImIAPPreferences::NewLC();

                        INFO_1( "Setting SNAP %d by IAP", destination.Id() )

                        iapPref->SetSNAPL( destination.Id());

                        aSetData.SetIapL( *iapPref, *iapPref );   

                        found = ETrue;

                        setIAP = EFalse;

                        CleanupStack::PopAndDestroy( iapPref );

                        }

                    CleanupStack::PopAndDestroy( &connMethod ); 

                    }

                }

            CleanupStack::PopAndDestroy( &destination );

            }

        CleanupStack::PopAndDestroy( &destArray );

        }    

        //If no valid IAP or destination, set zero.

        if ( setIAP )

            {

            INFO_1( "IAP is uncategorized, using IAP: %d", iap.iIAP )

            aSetData.SetIapL( iap, iap );                

            }

    CleanupStack::PopAndDestroy( &cmmgr );

    }

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

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

TSecurityValue CIpsSetWizardAdapter::SetSecurityValues( 

    const TInt aInSecurity, const TInt aOutSecurity )

    {

    FUNC_LOG;

    TSecurityValue values;

    switch( aInSecurity )

        {

        case KWizardDataSecurityOff:

            {

            values.inSecurity = CIpsSetData::ESecurityOff;

            break;

            }