/*

* 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:  Implementation of application setting UI.

*

*/

#include <coemain.h>

#include <featmgr.h>

#include <data_caging_path_literals.hrh>

#include <StringLoader.h>

#include <cmmanager.rsg>

#include <AknsUtils.h>

#include <ConnectionUiUtilities.h>

#include <cmcommonconstants.h>

#include "cmapplicationsettingsui.h"

#include <cmmanager.h>

#include "cmmanagerimpl.h"

#include "cmdestinationimpl.h"

#include "cmmanagerimpl.h"

#include <cmpluginbaseeng.h>

#include <cmpluginbase.h>

#include "cmconnsettingsuiimpl.h"

#include "cmconnselectrbpage.h"

using namespace CMManager;

typedef struct

    {

    TInt                iCmIapId;

    TInt                iCmDefaultPriority;

    }TCmListItem;

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

//  CCmConnSettingsUiImpl::NewL

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

//

EXPORT_C CCmConnSettingsUiImpl* CCmConnSettingsUiImpl::NewL( CCmManagerImpl* aCCmManagerImpl )

    {

    CCmConnSettingsUiImpl* self = 

                                new (ELeave) CCmConnSettingsUiImpl();

    CleanupStack::PushL( self );

    self->ConstructL( aCCmManagerImpl );

    CleanupStack::Pop( self );   // self

    return self;

    }

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

//  CCmConnSettingsUiImpl::NewL

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

//

CCmConnSettingsUiImpl* CCmConnSettingsUiImpl::NewWithoutTablesL()

    {

    CCmConnSettingsUiImpl* self = 

                                new (ELeave) CCmConnSettingsUiImpl();

    CleanupStack::PushL( self );

    self->iCreateTables = EFalse;

    self->ConstructL( NULL );

    CleanupStack::Pop( self );   // self

    return self;

    }    

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

//  CCmConnSettingsUiImpl::TCmDCSettingSelection

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

//

CCmConnSettingsUiImpl::CCmConnSettingsUiImpl()

    : iResourceReader( *CCoeEnv::Static() )

    , iAreDestinations ( ETrue )

    , iShowAlwaysAsk( EFalse )

    , iShowEasyWlan( EFalse )

    , iShowVirtualCMs( ETrue )

    , iShowEmptyDestinations( EFalse )

    , iShowAskOnce( EFalse )

    , iShowUncat( EFalse )

    , iShowDefConn( EFalse )

    , iUsePassedDestinationArray( EFalse )

    , iHelpContext ( KSET_HLP_APP_DEST_ASSOC_VIEW )

    , iCreateTables( ETrue )

    {

    }

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

//  CCmConnSettingsUiImpl::~TCmDCSettingSelection

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

//

CCmConnSettingsUiImpl::~CCmConnSettingsUiImpl()

    {

    if ( iOwnCmManager )

        {

        delete iCmManagerImpl;

        }    

    iResourceReader.Close();

    iItems.Close();

    iPassedDestinations.Close();

    }

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

// CCmConnSettingsUiImpl::LoadResourceL

// Load the resource for the dll module

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

//

TInt CCmConnSettingsUiImpl::LoadResourceL ()

    {    

    // Add resource file.

    TParse* fp = new(ELeave) TParse(); 

    TInt err = fp->Set( KACMManagerResDirAndFileName, 

                        &KDC_RESOURCE_FILES_DIR, 

                        NULL ); 

    if ( err != KErrNone)

        {

        User::Leave( err );

        }   

    TFileName resourceFileNameBuf = fp->FullName();

    delete fp;

    iResourceReader.OpenL( resourceFileNameBuf );

    return err;

    }

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

//  CCmConnSettingsUiImpl::ConstructL()

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

//

void CCmConnSettingsUiImpl::ConstructL( CCmManagerImpl* aCCmManagerImpl )

    {

    iOwnCmManager = !(aCCmManagerImpl);

    if ( iOwnCmManager )

        {

        if (iCreateTables)

            {

            iCmManagerImpl = CCmManagerImpl::NewL();            

            }

        else

            {

            iCmManagerImpl = CCmManagerImpl::NewL(EFalse);                            

            }

        }

    else

        {

        iCmManagerImpl = aCCmManagerImpl;

        }

    LoadResourceL();

    AknsUtils::SetAvkonSkinEnabledL( ETrue );

    }

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

// CCmConnSettingsUiImpl::ShowConnSelectRadioPageL

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

//

TBool CCmConnSettingsUiImpl::ShowConnSelectRadioPageL( 

                                           TCmDCSettingSelection& aSelection, 

                                           const TInt aTitleStringResource,

                                           TBearerFilterArray& aFilterArray )

    {

    TBool retVal( EFalse );

//    aSelection.iResult = EDCAlwaysAsk;

    CDesCArrayFlat* items = 

                    new ( ELeave ) CDesCArrayFlat( KCmArrayBigGranularity );

    CleanupStack::PushL( items );

    if (iAreDestinations)

        {

        BuildDestinationArrayL( items, aFilterArray );        

        }

    else    

        {

        BuildCMArrayL( items, aFilterArray ); 

        }

    // Uncategorized connection methods

    RPointerArray<CCmPluginBase> uncatArray( KCmArraySmallGranularity );

    CCmManagerImpl::CleanupResetAndDestroyPushL< RPointerArray<CCmPluginBase> >( uncatArray );

    if ( iShowUncat )

        {

        BuildUncatArrayL( uncatArray, items,

                    aFilterArray);

        }

    //appending items in reverse order of priority    

    // Check if Ask Once should be shown 

    if ( iShowAskOnce )

        {

        HBufC* buf = StringLoader::LoadLC( R_CMMANAGERUI_SETT_ASK_ONCE );

        items->InsertL( 0, *buf );

        iItems.InsertL( KDestItemAskOnce, 0 );

        CleanupStack::PopAndDestroy( buf );    

        }

    // Check if Always Ask should be shown

    if ( iShowAlwaysAsk )

        {

        HBufC* buf = StringLoader::LoadLC( R_CMMANAGERUI_SETT_ALWAYS_ASK );

        items->InsertL( 0, *buf );

        iItems.InsertL( KDestItemAlwaysAsk, 0 );

        CleanupStack::PopAndDestroy( buf );    

        }

    // Check if Default Connection should be shown 

    //feautre flag

    if ( iCmManagerImpl->IsDefConnSupported() )

        {

        //client's selection

        if ( iShowDefConn )

            {

            HBufC* buf = StringLoader::LoadLC( R_CMMANAGERUI_SETT_DEFAULT_CONNECTION );

            items->InsertL( 0, *buf );

            iItems.InsertL( KDestItemDefaultConnection, 0 );

            CleanupStack::PopAndDestroy( buf );    

            } 

        }

    if (!items->Count())

        {

        User::Leave(KErrConnectionNotFound);           

        }

    TInt listIndex(0);

    if (iAreDestinations)

        {

        switch ( aSelection.iResult )

                {

                case EDCDestination:

                    {

                    TInt newIndex = iItems.Find(aSelection.iId);

                    if (newIndex >=0)

                        {

                        listIndex = newIndex;

                        }

                    break;

                    }

                case EDCConnectionMethod:

                    {

                    TInt err(KErrNotFound);

                    CCmPluginBase* cm = NULL;

                    TRAP( err, cm = iCmManagerImpl->GetConnectionMethodL(aSelection.iId));

                    if ( err == KErrNone )

                        {

                        // connection method is valid

                        CleanupStack::PushL( cm );

                        TUint32 parentId = 0;

                        CCmDestinationImpl* parent = cm->ParentDestination();

                        if (parent)

                            {

                            // it has a parent, get it's id

                            parentId = parent->Id();

                            delete parent;

                            }

                        else

                            {

                            // no parent means Uncategorised

                            parentId = KDestItemUncategorized;

                            }

                        // get the index based on id    

                        TInt tempIndex = iItems.Find( parentId );

                        if ( tempIndex != KErrNotFound )

                            {

                            // found destination id in list

                            listIndex = tempIndex;

                            }                            

                        CleanupStack::PopAndDestroy( cm );

                        }

                    break;

                    }

                case EDCDefaultConnection:

                    {

                    TInt newIndex = iItems.Find(KDestItemDefaultConnection);

                    if (newIndex >=0)

                        {

                        listIndex = newIndex;

                        }

                    break;

                    }

                case EDCAlwaysAsk:

                    {

                    TInt newIndex = iItems.Find(KDestItemAlwaysAsk);

                    if (newIndex >=0)

                        {

                        listIndex = newIndex;

                        }

                    break;

                    }

                case EDCAskOnce:

                    {

                    TInt newIndex = iItems.Find(KDestItemAskOnce);

                    if (newIndex >=0)

                        {

                        listIndex = newIndex;

                        }

                    break;

                    }                

                default: // use default value (0)

                    {

                    break;

                    }                            

                }

            }

         else

            {

            if (aSelection.iResult == EDCConnectionMethod)

                {

                TInt newIndex = iItems.Find(aSelection.iId);

                if (newIndex >=0)

                    {

                    listIndex = newIndex;

                    }

                }

            }

    if ( UserSelectionDlgL( listIndex, items, aSelection, 

                            aTitleStringResource,

                            iOpenDestination) )

        {

        // Handle selection

        switch ( aSelection.iResult )

            {

            case EDCConnectionMethod:

                {

                // from the first list?

                if (!iAreDestinations)

                    {

                    aSelection.iId = iItems[listIndex];

                    retVal = ETrue;                    

                    }

                else

                    {

                    // Uncategorised?

                    TUint32 destId = iItems[ listIndex ];

                    if ( destId == KDestItemUncategorized )

                        {

                        TBearerFilterArray emptyFilter;

                        retVal = ShowConnectionMethodsL( uncatArray, 

                                        aSelection, aTitleStringResource, emptyFilter );

                        }

                    else

                        {

                        RPointerArray<CCmPluginBase> cmArray ( KCmArrayMediumGranularity );

                        if ( iShowVirtualCMs ) //create a flat list to show cms in embedded destinations

                            {

                            iCmManagerImpl->CreateFlatCMListLC( destId, cmArray);

                            }

                         else

                            {

                            //append only the cms in the destination

                            iCmManagerImpl->AppendCmListLC( destId, cmArray ); 

                            }

                        retVal = ShowConnectionMethodsL( cmArray, 

                                        aSelection, aTitleStringResource,

                                        aFilterArray );

                        CleanupStack::PopAndDestroy( &cmArray );

                        }                    

                    }

                break;

                }

            case EDCDestination:

                {

                // Store the destination Id

                aSelection.iId = iItems[listIndex];

                retVal = ETrue;

                break;

                }

            case EDCAlwaysAsk:

                {

                // nothing more to do

                retVal = ETrue;

                break;

                }        

            case EDCDefaultConnection:

                {

                // nothing more to do

                retVal = ETrue;

                break;

                }            

            case EDCAskOnce:

                {

                // nothing more to do

                retVal = ETrue;

                break;

                }            

            default:

                {

                break;

                }

            }

        }

    CleanupStack::PopAndDestroy( &uncatArray );

    CleanupStack::PopAndDestroy( items );

    return retVal;

    }

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

//  CCmConnSettingsUiImpl::RunSettingsL()

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

//

EXPORT_C TBool CCmConnSettingsUiImpl::RunApplicationSettingsL( 

                                        TCmSettingSelection& aSelection, 

                                        TUint aListItems,

                                        TBearerFilterArray& aFilterArray)

    {

    iItems.Close();

    iAreDestinations = ETrue;

    if (!aListItems)

        {

        User::Leave(KErrArgument);        

        }

    if ( !iCmManagerImpl->IsDefConnSupported() &&

         !(aListItems & EShowAlwaysAsk) &&  

         !(aListItems & EShowConnectionMethods) &&  

         !(aListItems & EShowDestinations) 

         )

        {

        // default conn would be the only one but not supported

        User::Leave(KErrNotSupported);   

        }

    if ( aListItems & EShowDefaultConnection )

        {

        EnableDefConn( ETrue );        

        }

    else

        {

        EnableDefConn( EFalse );                

        }

    if (aListItems & EShowAlwaysAsk)

        {

        EnableAlwaysAsk( ETrue );

        }

    else

        {

        EnableAlwaysAsk( EFalse );

        }

    if ( (aListItems & EShowConnectionMethods) && (aListItems & EShowDestinations) )

        {

        iOpenDestination = ETrue;

        iShowUncat = ETrue;

        }

    else

        {

        iOpenDestination = EFalse;

        }

    if ( (aListItems & EShowConnectionMethods) && !(aListItems & EShowDestinations) )

        {

        iAreDestinations = EFalse;

        GetCMArrayL( );            

        }

    else if ( aListItems & EShowDestinations )

        {

        if (iUsePassedDestinationArray)

            {

            // now fill up iItems

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

                {

                iItems.Append(iPassedDestinations[i]);

                }

            }

        else

            {

            iCmManagerImpl->AllDestinationsL( iItems );

            TInt i( 0 );

            TInt count = iItems.Count();

            for ( i=0; i < count; i++ )

                {

                if ( iItems[i] > 0 && iItems[i] < 255 )

                    {

                    CCmDestinationImpl* dest = 

        	                            iCmManagerImpl->DestinationL( iItems[i] );

                    CleanupStack::PushL( dest );

        	        if ( dest->IsHidden() )

                        {

                        iItems.Remove(i);

                        i--;

                        count = count-1;

                        }

                    CleanupStack::PopAndDestroy();

                    }

                }

            iItems.Compress();

            }

        }

    TBool ret = EFalse;

    TCmDCSettingSelection userDefSelection;

    // convert selection

    switch ( aSelection.iResult )

        {

        case EDestination: 

            {

            userDefSelection.iResult = EDCDestination; 

            userDefSelection.iId = aSelection.iId;        

            break;

            }

        case EConnectionMethod: 

            {

            userDefSelection.iResult = EDCConnectionMethod; 

            userDefSelection.iId = aSelection.iId;        

            break;

            }

        case EDefaultConnection: 

            {

            userDefSelection.iResult = EDCDefaultConnection; 

            userDefSelection.iId = 0;