/*

* 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 CIpsSetDataApi.

*

*/

#include "emailtrace.h"

#include <e32base.h>

#include <e32cmn.h>

#include <SendUiConsts.h>

#include <pop3set.h>

#include <imapset.h>

#include <smtpset.h>

#include <centralrepository.h>      // CRepository

#include <iapprefs.h>

// <cmail> #include <ApUtils.h> // CApUtils

#include <commdb.h>

#include <ipssossettings.rsg>

#include <etel.h>                       // RTelServer

#include <etelmm.h>                     // RMobilePhone

#include <cemailaccounts.h>

#include "ipssetdatastorer.h"

#include "ipssetdata.h"

#include "ipssetdatamanager.h"

#include "ipssetdataextension.h"

#include "ipssetdatastorer.h"

#include "ipssetwizardadapter.h"

#include "ipssetui.h"

#include "ipssetdatactrlaccount.h"

#include "ipssetutilsconsts.h"

#include "ipsplgcommon.h"

#include "ipssetdataapi.h"

#include "ipssetwizardadapter.h"

#include "ipssetwizardsettingscenrepkeys.h" 

const TInt KIpsDataApiMaxPassLen = 256;

const TInt KWizardDataPopIndicator = 0;

const TInt KWizardDataImapIndicator = 1;

#ifdef __WINS__

_LIT( KIMAEmulatorImei, "123456789012345" );

#endif // __WINS__

#ifdef _DEBUG

_LIT( KIpsSetApi, "IpsSetApi");

#endif

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

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

EXPORT_C CIpsSetDataApi* CIpsSetDataApi::NewL( CMsvSession& aSession )

    {

    FUNC_LOG;

    CIpsSetDataApi* self = new(ELeave)CIpsSetDataApi( aSession );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

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

CIpsSetDataApi::CIpsSetDataApi( CMsvSession& aSession )

    : iSession( aSession ),

    iServerAddress( NULL )

    {

    FUNC_LOG;

    }

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

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

void CIpsSetDataApi::ConstructL()

    {

    FUNC_LOG;

    }

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

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

CIpsSetDataApi::~CIpsSetDataApi()

    {

    FUNC_LOG;

    delete iServerAddress;

    }

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

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

EXPORT_C TInt CIpsSetDataApi::LaunchSettingsL( const TMsvId aMailboxId )

    {

    FUNC_LOG;

    CIpsSetUi* ui = CIpsSetUi::NewL( aMailboxId );

    TInt ret = ui->ExecuteLD( R_IPS_SET_SETTINGS_DIALOG );

    return ret;

    }

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

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

EXPORT_C TDesC& CIpsSetDataApi::GetServerAddressL( const CMsvEntry& aEntry )

    {

    FUNC_LOG;

    delete iServerAddress;

    iServerAddress = NULL;

    if( aEntry.Entry().iMtm.iUid == KSenduiMtmImap4UidValue )

        {

        CImImap4Settings* settings = new(ELeave) CImImap4Settings();

        CleanupStack::PushL( settings );

        TImapAccount imapAccountId;

        CEmailAccounts* accounts = CEmailAccounts::NewLC();

        accounts->GetImapAccountL( aEntry.Entry().Id(), imapAccountId );

        accounts->LoadImapSettingsL( imapAccountId, *settings );

        iServerAddress = HBufC::NewL( settings->ServerAddress().Length() );

        iServerAddress->Des().Copy( settings->ServerAddress() );

        CleanupStack::PopAndDestroy( 2, settings );

        }

    else if( aEntry.Entry().iMtm.iUid == KSenduiMtmPop3UidValue )

        {

        CImPop3Settings* settings = new(ELeave) CImPop3Settings();

        CleanupStack::PushL( settings );

        TPopAccount popAccountId;

        CEmailAccounts* accounts = CEmailAccounts::NewLC();

        accounts->GetPopAccountL( aEntry.Entry().Id(), popAccountId );

        accounts->LoadPopSettingsL( popAccountId, *settings );

        iServerAddress = HBufC::NewL( settings->ServerAddress().Length() );

        iServerAddress->Des().Copy( settings->ServerAddress() );

        CleanupStack::PopAndDestroy( 2, settings );

        }

    return *iServerAddress;

    }

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

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

EXPORT_C void CIpsSetDataApi::SetNewPasswordL( 

    CMsvEntry& aService, 

    const TDesC& aPassword )

    {

    FUNC_LOG;

    if ( aService.Entry().iMtm.iUid == KSenduiMtmPop3UidValue )

        {

        SetNewPop3PasswordL( aService, aPassword );

        }

    else if ( aService.Entry().iMtm.iUid == KSenduiMtmImap4UidValue )

        {

        SetNewImap4PasswordL( aService, aPassword );

        }

    }

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

// function returns KErrNotSupported if wizard data is not 

// not match for the uid parameter. All leaving function calls are

// trapped to prevent KErrNotSupported error code to return

// in case of real error situation

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

EXPORT_C TInt CIpsSetDataApi::HandleMailboxCreation( 

    const TUid aUid, 

    CMsvSession& aSession )

    {

    FUNC_LOG;

    // NOTE: this function should not leave, CleanupStack not used

    _LIT( KFsBasicPluginStr, "fsp" );

    TInt error = KErrNone;

    CRepository* repository = NULL;

    CIpsSetWizardAdapter* adapter = NULL;

    TInt protocol = 0; // <cmail>

    TIpsSetUtilsTextPlain accountType;

    TRAP( error, repository = CRepository::NewL( KCRUidWizardSettings ) );

    if ( error != KErrNone )

        {

        error = KErrGeneral;

        }

    else

        {

        // protocol 0= POP, 1= IMAP

        error = repository->Get( 

            ECRKSetupWizAccountType, accountType );

        if ( error != KErrNone )

            {

            error = KErrNotSupported;

            }

        }

    // check that protocol match until go further...    

    TInt diff = accountType.Compare( KFsBasicPluginStr );

    if ( error == KErrNone && diff != 0 )

        {

        error = KErrNotSupported;

        }

    if ( error == KErrNone )

        {

        error = repository->Get( 

            ECRKPopImapProtocolIndicatorId, protocol );

        }

    if ( error != KErrNone )

        {

        error = KErrNotSupported;

        }

    else if ( error == KErrNone 

            && protocol == KWizardDataPopIndicator 

            && aUid.iUid == KSenduiMtmImap4UidValue )

        {

        error = KErrNotSupported;

        }

    else if ( error == KErrNone 

            && protocol == KWizardDataImapIndicator 

            && aUid.iUid == KSenduiMtmPop3UidValue )

        {

        error = KErrNotSupported;

        }

    if ( error == KErrNone )

        {

        TRAP( error, adapter = CIpsSetWizardAdapter::NewL(

            *repository, aSession ) );

        if ( error != KErrNone )

            {

            error = KErrGeneral;

            }

        }

    if ( error == KErrNone )

        {

        // before creating mailbox clear common wizard fields to prevent another 

        // ips plugin instances to create (dublicate) mailboxes

        TInt setErr = repository->Set( 

                    ECRKSetupWizAccountType, KNullDesC );

        TRAP( error, adapter->HandleWizardDataL() );

        if ( error != KErrNone )

            {

            error = KErrGeneral;

            }

        }

    delete repository;

    delete adapter;

    return error;

    }

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

// maybe these could be combined...SetNewImap4PasswordL & SetNewPop3PasswordL

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

void CIpsSetDataApi::SetNewImap4PasswordL( 

    CMsvEntry& aService, 

    const TDesC& aPassword )

    {

    FUNC_LOG;

    CImImap4Settings* settings = new(ELeave) CImImap4Settings();

    CleanupStack::PushL( settings );

    TImapAccount imapAccountId;

    CEmailAccounts* accounts = CEmailAccounts::NewLC();

    accounts->GetImapAccountL( aService.Entry().Id(), imapAccountId );

    accounts->LoadImapSettingsL( imapAccountId, *settings );

    TBuf8<KIpsDataApiMaxPassLen> temp;

    temp.Copy( aPassword );

    settings->SetPasswordL( temp );

    accounts->SaveImapSettingsL( imapAccountId, *settings );

    // Possibly update also outgoing service password

    if ( IsOutgoingLoginSameAsIncomingL( 

         TIpsSetDataStorerParams( imapAccountId.iImapAccountId, KSenduiMtmImap4Uid ) ) )

        {

        SetNewSmtpPasswordL( imapAccountId.iSmtpService, temp, *accounts );

        }

    CleanupStack::PopAndDestroy( 2, settings );

    }

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

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

void CIpsSetDataApi::SetNewPop3PasswordL( 

    CMsvEntry& aService, 

    const TDesC& aPassword )

    {

    FUNC_LOG;

    CImPop3Settings* settings = new(ELeave) CImPop3Settings();

    CleanupStack::PushL( settings );

    TPopAccount popAccountId;

    CEmailAccounts* accounts = CEmailAccounts::NewLC();

    accounts->GetPopAccountL( aService.Entry().Id(), popAccountId );

    accounts->LoadPopSettingsL( popAccountId, *settings );

    TBuf8<KIpsDataApiMaxPassLen> temp;

    temp.Copy( aPassword );

    settings->SetPasswordL( temp );

    accounts->SavePopSettingsL( popAccountId, *settings );

    // Possibly update also outgoing service password

    if ( IsOutgoingLoginSameAsIncomingL(

         TIpsSetDataStorerParams( popAccountId.iPopAccountId, KSenduiMtmPop3Uid ) ) )

        {

        SetNewSmtpPasswordL( popAccountId.iSmtpService, temp, *accounts );

        }

    CleanupStack::PopAndDestroy( 2, settings );

    }

//<cmail>

//This method is not used anywhere

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

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

//  

/*EXPORT_C TBool CIpsSetDataApi::IsSmtpAllowedToConnectL( TMsvId aSmtpService, TBool aIsRoaming,

                                                        CMsvSession& aSession )

    {

	FUNC_LOG;

    // get correct imap or pop entry from smtp service

    TMsvId serv;

    TMsvEntry entry; 

    TInt error = KErrNone;

    error = aSession.GetEntry( aSmtpService, serv, entry );

    if( error == KErrNone )

        {

        error = aSession.GetEntry( entry.iRelatedId, serv, entry );

        }

    // service might be deleted

    if( error != KErrNone )

        {

        return EFalse;

        }

    CIpsSetData* setData = CIpsSetData::NewLC();    // << setData

    CIpsSetDataManager* dataMan = CIpsSetDataManager::NewLC( aSession );// << dataMan

    TRAP( error, dataMan->LoadEmailSettingsL( entry, *setData ) );

    if( error != KErrNone )

        {

        CleanupStack::PopAndDestroy( 2 ); // >>> setData, dataMan

        return EFalse;

        }

    TBool isAllowed( ETrue );

    CIpsSetDataExtension* extented = setData->ExtendedSettings();

    if( extented->AlwaysOnlineState() == EMailAoOff )

        {

        //isAllowed = EFalse;

        }

    else if ( aIsRoaming && extented->AlwaysOnlineState() == EMailAoHomeOnly )

        {

        //isAllowed = EFalse;

        }

    // Always ask check, do not check in emulator because

    // lan connection works only with always ask access point

#ifndef __WINS__

    CImIAPPreferences* iapOut = setData->OutgoingIapPref();

    TImIAPChoice iapChoice = iapOut->IAPPreference( 0 );

    isAllowed = ( !iapChoice.iIAP == KIpsServiceIdNoServiceSpecified );

#endif

    CleanupStack::PopAndDestroy( 2 );  //>>> setData, dataMan

    return isAllowed;

    }*/

//</cmail>

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

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

EXPORT_C void CIpsSetDataApi::GoOnlineL( TMsvEntry /*aMailbox*/ )

    {

    FUNC_LOG;

    // remove this

    }

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

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

EXPORT_C void CIpsSetDataApi::GoOfflineL( TMsvEntry /*aMailbox*/ )

    {

    FUNC_LOG;

    // remove this

    }

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

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

EXPORT_C void CIpsSetDataApi::RemoveAccountL( 

    const TMsvEntry& aMailbox, 

    CMsvSession& aSession )

    {

    FUNC_LOG;

    // First let the data manager to delete the account.

    CIpsSetDataManager* manager = CIpsSetDataManager::NewL( aSession );

    TRAPD( err, manager->RemoveAccountL( aMailbox ) );

    delete manager;

    manager = NULL;

    if ( err != KErrNone )

        {

        __ASSERT_DEBUG(EFalse, User::Panic( 

            KIpsSetApi , KErrNotFound ) );

        }

    // Then update the max account number flag.

    CRepository* repository = NULL;

    TRAPD( err2, repository = CRepository::NewL( KCRUidWizardSettings ) );

    // Do not assume repository is always available and working correctly.

    if ( err2 == KErrNone )

        {

        //always reset the max account flag when a mailbox is deleted

        TInt err3 = repository->Set(

            ECRKMaxAccountsReached, EFalse );

        if ( err3 != KErrNone )

            {

            }

        delete repository;

        repository = NULL;

        }

    }

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

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

EXPORT_C TUint32 CIpsSetDataApi::CreateCenRepKeyL( 

        const TUint32 aAccountId,

        const TUid& aProtocol,

        const TUint32 aSettingKey )

    {

    FUNC_LOG;

    return IpsSetDataCtrlAccount::CreateSettingKey( 

        aAccountId, 

        aSettingKey, 

        aProtocol );    

    }

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

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

EXPORT_C void CIpsSetDataApi::GetMailboxAddressL(

    const TMsvEntry& aMailboxEntry,

    HBufC*& aMailboxAddress )

    {

    FUNC_LOG;

    /*CIpsSetData* settingsData = CIpsSetData::NewLC();

    CIpsSetDataManager* dataManager = CIpsSetDataManager::NewLC( iSession );

    TRAP_IGNORE( 

        dataManager->LoadEmailSettingsL( aMailboxEntry, *settingsData ) );

    CIpsSetDataExtension* extentedSettings = settingsData->ExtendedSettings();

    aMailboxAddress = extentedSettings->EmailAddress().Alloc();

    CleanupStack::PopAndDestroy( 2, settingsData ); // dataManager   */

    CEmailAccounts* acc = CEmailAccounts::NewLC();

    TSmtpAccount smtpAcc;

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

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

    CleanupStack::PushL( smtpSet );

    acc->LoadSmtpSettingsL( smtpAcc, *smtpSet );

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

    CleanupStack::PopAndDestroy( 2, acc );

    }

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

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

EXPORT_C void CIpsSetDataApi::SaveSyncStatusL( TMsvEntry aMailbox, TInt aState )

    {

    FUNC_LOG;

    CIpsSetDataStorer* storer = CIpsSetDataStorer::NewLC();

    CIpsSetData* settingsData = CIpsSetData::NewLC();

    CEmailAccounts* accounts = CEmailAccounts::NewLC();

    TUint32 accountId;

    if( aMailbox.iMtm.iUid == KSenduiMtmImap4UidValue )

    	{

    	accounts->GetImapAccountL( aMailbox.Id(), settingsData->ImapAccount() );

    	accountId = settingsData->ImapAccount().iImapAccountId;

    	}

    else

    	{

    	accounts->GetPopAccountL( aMailbox.Id(), settingsData->PopAccount() );

    	accountId = settingsData->PopAccount().iPopAccountId;

    	}

    TInt error = storer->LoadExtendedSettings( 

    		TIpsSetDataStorerParams( accountId, aMailbox.iMtm ),

    		*settingsData->ExtendedSettings() );

    settingsData->ExtendedSettings()->SetSyncStatus( aState );

    error = storer->SaveExtendedSettings( *settingsData->ExtendedSettings() );

    CleanupStack::PopAndDestroy( 3, storer );

    }

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

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

EXPORT_C TInt CIpsSetDataApi::GetLastSyncStatusL( TMsvEntry aMailbox )

    {

    FUNC_LOG;

    CIpsSetDataStorer* storer = CIpsSetDataStorer::NewLC();

    CIpsSetData* settingsData = CIpsSetData::NewLC();

    CEmailAccounts* accounts = CEmailAccounts::NewLC();

    TUint32 accountId;

    if( aMailbox.iMtm.iUid == KSenduiMtmImap4UidValue )

    	{