/*

* 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:  Wizard used for adding connection methods

*

*/

#include <AknWaitDialog.h>

#include <cmmanager.rsg>

#include <StringLoader.h>

#include <avkon.hrh>

#include "cmwizard.h"

#include <cmcommonconstants.h>

#include <cmcommonui.h>

#include "cmdestinationimpl.h"

#include "cmlogger.h"

#include "cmmanagerimpl.h"

#include <cmpluginbaseeng.h>

#include <cmpluginbase.h>

#include "selectdestinationdlg.h"

using namespace CMManager;

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

// CCmWizard::CCmWizard

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

//

CCmWizard::CCmWizard( CCmManagerImpl& aCmManager ) 

    : iCmManager( aCmManager )

    {

    CLOG_CREATE;

    }

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

// CCmWizard::~CCmWizard

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

//

CCmWizard::~CCmWizard()

    {

    if( iCheckConnDlg )

        {

        delete iCheckConnDlg;

        }

    CLOG_CLOSE;

    }

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

// CCmWizard::CreateConnectionMethodL

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

//

TInt CCmWizard::CreateConnectionMethodL

                                    ( CCmDestinationImpl* aTargetDestination )

    {

    TInt index( KErrCancel );

    LOGGER_ENTERFN( "CCmWizard::CreateConnectionMethodL" );

    TBool wizardCancelled = EFalse; // indicates if the wizard has got cancelled

    TUint32 bearerType = 0;

    TBool manuallyConfigure ( EFalse );

    if ( AutoCheckForCmsL() )

        {

        RArray<TUint32> availableBearers( KCmArrayMediumGranularity );

        CleanupClosePushL( availableBearers );

        CLOG_WRITE( "CCmWizard::Starting CheckForCms" );

        CheckForCmsL( availableBearers );

        // If user has cancelled the dialog, then (s)he wanted to terminate

        // the whole procedure.

        if ( iCheckConnDlgCancelled )

            {

            CLOG_WRITE( "CCmWizard::wizardCancelled" );

            wizardCancelled = ETrue;

            }

        else

            {

            // If there's coverage for at least one of the bearer types

            if ( availableBearers.Count() )

                {

                CLOG_WRITE_1( "CCmWizard::CreateConnectionMethodL av. bearers: [%d]",

                               availableBearers.Count() );

                // Show available conn methods in a list from which user has to

                // select.

                bearerType = TCmCommonUi::ShowAvailableMethodsL

                                                ( availableBearers,

                                                  iCmManager );

                if ( !bearerType )

                    {

                    wizardCancelled = ETrue;

                    CLOG_WRITE( "CCmWizard::wizardCancelled" );

                    }

                }

            else    // no coverage at all

                {

                CLOG_WRITE( "CCmWizard::CreateConnectionMethodL no available bearers, manual selection." );

                // "Do you want to configure conn methods manually?"

                if ( ManualCheckForCmsL() )

                    {

                    // Yes, select a bearer manually

                    bearerType = TCmCommonUi::SelectBearerL( iCmManager );

                    if ( !bearerType )

                        {

                        // Cancelled dialog

                        wizardCancelled = ETrue;

                        }

                    else

                        {

                        manuallyConfigure = ETrue;

                        }

                    }

                else

                    {

                    // No, user has cancelled the dialog

                    wizardCancelled = ETrue;

                    }

                }

            }

        CleanupStack::PopAndDestroy( &availableBearers );

        }

    else    // "No" for checking conn methods automatically

        {

        CLOG_WRITE( "CCmWizard::AutoCheckForCmsL returned FALSE" );

        // Manual bearer selection

        bearerType = TCmCommonUi::SelectBearerL( iCmManager );

        if ( !bearerType )

            {

            // Cancelled dialog

            wizardCancelled = ETrue;

            }

        else

            {

            manuallyConfigure = ETrue;

            }

        }

    if ( !wizardCancelled )

        {

        CCmPluginBase* plugin = iCmManager.CreateConnectionMethodL(

                                            bearerType, aTargetDestination );

        CleanupStack::PushL( plugin );

        CLOG_WRITE( "CCmWizard::CreateConnectionMethodL plugin created, starting initialization" );

        // Bearer-specific UI-supported initialization is done by plug-ins

	    TBool ret = EFalse;

	    TRAPD(err, ret = plugin->InitializeWithUiL( manuallyConfigure ) );

        if ( err == KErrNone && ret )

            {

            CCmDestinationImpl* targetDest = aTargetDestination;

            // If target destination is not yet specified...

            if ( !aTargetDestination )

                {

                // For virtual bearers: eliminated the underlying destination 

                // from the destination selection dialog

                TUint32 targetDestId( 0 );

                RArray<TUint32> destArray( iCmManager.DestinationCountL() );

                CleanupClosePushL( destArray );

                iCmManager.AllDestinationsL( destArray );

                // now do the filtering

                plugin->FilterPossibleParentsL( destArray );

                if ( !destArray.Count() )

                    {

                    // there are no destinations to put the CM into

                    TCmCommonUi::ShowNoteL( R_CMWIZARD_NO_VPN_STACKING,

                                            TCmCommonUi::ECmErrorNote );

                    CleanupStack::PopAndDestroy( &destArray );

                    CleanupStack::PopAndDestroy( plugin );

                    CLOG_WRITE_1( "CCmWizard::CreateConnectionMethodL no valid parents after filtering, index: [%d]", index );

                    return index;

                    }

                // ... then let the user select a destination.

                CSelectDestinationDlg* dlg = CSelectDestinationDlg::NewL( targetDestId,

                                                                          iCmManager,

                                                                          &destArray );

                dlg->ExecuteLD( R_CMMANAGER_LIST_QUERY_WITH_MSGBOX );

                CleanupStack::PopAndDestroy( &destArray );

                if ( targetDestId )

                    {

                    // CREATE an object based on an ID.

                    targetDest = iCmManager.DestinationL( targetDestId );

                    CleanupStack::PushL( targetDest );

                    }

                }

            CLOG_WRITE_1( "CCmWizard::CreateConnectionMethodL target dest: [0x%x]",

                           targetDest );

            // If the target destination is still unspecified at this point,

            // then the only reason could be that the previous dialog was

            // cancelled ==> do something only if we have the target 

            // destination

            if ( targetDest )

                {

                plugin->UpdateL();  // commit changes

                index = iCmManager.CopyConnectionMethodL( *targetDest,

                                                                    *plugin );

                RArray<TUint32> additionalCms;

                CleanupClosePushL (additionalCms);

                plugin->GetAdditionalUids( additionalCms );

                if ( additionalCms.Count() )

                    {//if there are additional cms created, move them to the target destination as well

                    for ( TInt i = 0; i<additionalCms.Count(); i++)

                        {

                        CCmPluginBase* cm = iCmManager.GetConnectionMethodL( additionalCms[i] );

                        CleanupStack::PushL(cm);

                        iCmManager.CopyConnectionMethodL( *targetDest,

                                                                    *cm );

                        CleanupStack::PopAndDestroy( cm );

                        }

                    }

                CleanupStack::PopAndDestroy( &additionalCms );

                HBufC* destName = targetDest->NameLC();

                TCmCommonUi::ShowNoteL( R_CMWIZARD_NEW_METHOD_ADDED,

                                        *destName,

                                        TCmCommonUi::ECmOkNote );

                CleanupStack::PopAndDestroy( destName );

                // Here's a tricky one: if 'aTargetDestination' was NULL, then

                // I had to create 'targetDest' myself (with

                // iCmManager.DestinationL), consequently I have to

                // free it up, too.

                if ( !aTargetDestination )

                    {

                    CleanupStack::PopAndDestroy( targetDest );

                    }

                }

            else // Wi-Fi may have set IAP in database. So, delete it.

                {

                CLOG_WRITE( "CCmWizard::CreateConnectionMethodL, handling cancel add destination -- start" );                                   

                RArray<TUint32> additionalCms;

                CleanupClosePushL (additionalCms);

                plugin->GetAdditionalUids( additionalCms );

                CLOG_WRITE_1( "CCmWizard::CreateConnectionMethodL, addtionalCms count [%d]", additionalCms.Count() );

                for ( TInt i = 0; i<additionalCms.Count(); i++)

                    {

                    CCmPluginBase* cm = iCmManager.GetConnectionMethodL( additionalCms[i] );

                    CleanupStack::PushL(cm);

                    cm->DeleteL( ETrue );

                    CleanupStack::PopAndDestroy( cm );

                    }

                // If plugin hasn't got Iap Id, it's "normal" CM which has not been saved

                // into CommsDat yet. Otherwise it's Wifi CM and has to be deleted by using

                // DeleteL() method. 

                if( plugin->GetIntAttributeL( ECmIapId ) )

                    {

                    plugin->DeleteL( ETrue );

                    }

                CleanupStack::PopAndDestroy( &additionalCms );

                CLOG_WRITE( "CCmWizard::CreateConnectionMethodL, handling cancel add destination -- end" );

                }

    		    }

        CleanupStack::PopAndDestroy( plugin );

        }

    return index;

    }

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

// CCmWizard::DialogDismissedL

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

//

void CCmWizard::DialogDismissedL( TInt aButtonId )

    {

    LOGGER_ENTERFN( "CCmWizard::DialogDismissedL" );

    CLOG_WRITE_1( "CCmWizard::DialogDismissedL, aButtonId: [%d]", aButtonId );

    if ( aButtonId == EAknSoftkeyCancel )

        {

        if ( iCheckConnDlg != NULL )

            {

            CLOG_WRITE( "CCmWizard::CheckConnDlg is not NULL" );

            iCheckConnDlgCancelled = ETrue;

            }

        }

    }

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

// CCmWizard::AutoCheckForCmsL

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

//

TBool CCmWizard::AutoCheckForCmsL() const

    {

    LOGGER_ENTERFN( "CCmWizard::AutoCheckForCmsL" );

    // Automatically check for available conn methods?

    TInt retval =

            TCmCommonUi::ShowConfirmationQueryL( R_CMWIZARD_AUTOMATIC_CHECK );

    return ( retval == EAknSoftkeyYes || retval == EAknSoftkeyOk )

            ? ETrue : EFalse;

    }

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

// CCmWizard::ManualCheckForCmsL

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

//

TBool CCmWizard::ManualCheckForCmsL() const

    {

    LOGGER_ENTERFN( "CCmWizard::ManualCheckForCmsL" );

    // Manually configure CMs?

    TInt retval =

            TCmCommonUi::ShowConfirmationQueryL(    

                                             R_CMWIZARD_MANUAL_CONFIGURATION );

    return ( retval == EAknSoftkeyYes || retval == EAknSoftkeyOk )

            ? ETrue : EFalse;

    }

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

// CCmWizard::CheckForCmsL

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

//

void CCmWizard::CheckForCmsL( RArray<TUint32>& aCoverageArray )

    {

    LOGGER_ENTERFN( "CCmWizard::CheckForCmsL" );

    // Show a wait dialog

    iCheckConnDlgCancelled = FALSE;

    iCheckConnDlg = new (ELeave) CAknWaitDialog(

                          ( REINTERPRET_CAST( CEikDialog**, &iCheckConnDlg )) );

    iCheckConnDlg->SetCallback( this );

    iCheckConnDlg->SetTone( CAknNoteDialog::EConfirmationTone );

    HBufC* text = StringLoader::LoadLC( R_CMWIZARD_CHECKING_METHODS );

    iCheckConnDlg->SetTextL( *text );

    CleanupStack::PopAndDestroy( text );

    iCheckConnDlg->ExecuteLD( R_CMMANAGER_WAIT_NOTE );

    RArray<TUint32> bearers( KCmArrayMediumGranularity );

    CleanupClosePushL( bearers );

    iCmManager.SupportedBearersL( bearers );

    for ( TInt i = 0; i < bearers.Count() && !iCheckConnDlgCancelled; i++ )

        {

        TBool avail( EFalse );

        TRAPD( err, avail = iCmManager.GetBearerInfoBoolL( bearers[i], ECmCoverage ) );

        CLOG_WRITE_2( "CCmWizard::CheckForCms, bearer [%d] coverage error [%d]", i, err );

        if( err )

            {

            continue;

            }

        if ( avail &&

             iCmManager.GetBearerInfoBoolL( bearers[i], ECmAddToAvailableList ) )

            {

            aCoverageArray.AppendL( bearers[i] );

            CLOG_WRITE_1( "CCmWizard::CheckForCms, bearer [%d] appended", i );

            }

        }

    CleanupStack::PopAndDestroy( &bearers );

    // Dismiss wait dialog

    if( !iCheckConnDlgCancelled )

        {

        CLOG_WRITE( "CCmWizard::CheckForCms, cancelling wait dlg" );

        iCheckConnDlg->SetCallback( NULL );

        iCheckConnDlg->ProcessFinishedL();

        CLOG_WRITE( "CCmWizard::CheckForCms, wait dialog deleted" );

        }

    else

        {

        CLOG_WRITE( "CCmWizard::CheckForCms, wait dlg was already cancelled" );

        }

    // Set the member to NULL every case

    iCheckConnDlg = NULL;

    }

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

// CCmWizard::FindTargetDestinationL

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

//

TUint32 CCmWizard::FindTargetDestinationL( CCmPluginBase* aPlugin )

    {

    LOGGER_ENTERFN( "CCmWizard::FindTargetDestinationL" );

    // Tries to read the destination id

    TUint32 targetDestId (0); 

    TRAPD( err, targetDestId = 

                aPlugin->GetIntAttributeL( ECmNextLayerSNAPId ) );

    // only supported by virtual bearers, don't leave        

    if ( err && err != KErrNotSupported )

       {

       User::Leave( err );

       }

    // targetDestId == 0 means that not destination but a connection 

    // method have been selected

    if ( targetDestId == 0 )

        {

        // Now the destination containing the connection method 

        // should be obtained

        TUint32 targetCmId (0); 

        TRAPD( err, targetCmId = 

                    aPlugin->GetIntAttributeL( ECmNextLayerIapId ) );

        // only supported by virtual bearers, don't leave        

        if ( err && err != KErrNotSupported )

            {

            User::Leave( err );

            }

        targetDestId = FindParentDestinationL( targetCmId );   

        }

    return targetDestId;    

    }

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

// CCmWizard::FindParentDestinationL

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

//

TUint32 CCmWizard::FindParentDestinationL( TUint32 aCmId )

    {

    LOGGER_ENTERFN( "CCmWizard::FindParentDestinationL" );

    TBool found = EFalse;

    TUint32 targetDestId (0); 

    RArray<TUint32> destinations;

    iCmManager.AllDestinationsL( destinations );

    CleanupClosePushL( destinations );

    RArray<TUint32> cms;

    for ( TInt i = 0; i < destinations.Count() && !found; i++ )

        {            

        CCmDestinationImpl* dest = 

                          iCmManager.DestinationL( destinations[i] );

        CleanupStack::PushL( dest );

        dest->ConnectMethodIdArrayL( cms );

        CleanupClosePushL( cms );

        for ( TInt j = 0; j < cms.Count() && !found; j++ )

            {

            if( cms[j] == aCmId)

                {

                targetDestId = destinations[i];

                found = ETrue;

                }

            }

        CleanupStack::PopAndDestroy( &cms );

        CleanupStack::PopAndDestroy( dest );

        }

    CleanupStack::PopAndDestroy( &destinations );

    return targetDestId;    

    }