/*
* 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:  Displays a radio button selection list of VPN policies
*
*/


// includes
#include <aknPopup.h>
// #include <vpnapidefs.h>
#include <aknlists.h>
#include <cmmanager.rsg>
#include <cmpluginvpnui.rsg>
#include <cmcommonui.h>
#include <cmpluginbaseeng.h>
#include <StringLoader.h>
#include <data_caging_path_literals.hrh>
#include <aknradiobuttonsettingpage.h>

#include "cmlogger.h"
#include "cmpvpnpolicyselectiondlg.h"
#include "cmvpncommonconstants.h"
#include <cmpluginvpndef.h>
#include <cmcommonconstants.h>

using namespace CMManager;

// ----------------------------------------------------------------------------
// CmPluginVpnPolicySelectionDlg::NewL
// ----------------------------------------------------------------------------
//
CmPluginVpnPolicySelectionDlg* CmPluginVpnPolicySelectionDlg::NewL( 
                                        CCmPluginBaseEng& aCmPluginBaseEng )
    {
    CmPluginVpnPolicySelectionDlg* self = 
            new ( ELeave ) CmPluginVpnPolicySelectionDlg( aCmPluginBaseEng );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// ----------------------------------------------------------------------------
// CmPluginVpnPolicySelectionDlg::~CmPluginVpnPolicySelectionDlg
// ----------------------------------------------------------------------------
//
CmPluginVpnPolicySelectionDlg::~CmPluginVpnPolicySelectionDlg()
    {

    iVpnServ.Close();

    delete iPolicyInfoList;

    iResourceReader.Close();
    }
    
// ----------------------------------------------------------------------------
// CmPluginVpnPolicySelectionDlg::CmPluginVpnPolicySelectionDlg
// ----------------------------------------------------------------------------
//
CmPluginVpnPolicySelectionDlg::CmPluginVpnPolicySelectionDlg(
                        CCmPluginBaseEng& aCmPluginBaseEng )
    : iCmPluginBaseEng( aCmPluginBaseEng )
    , iResourceReader( *CCoeEnv::Static() )
    , iVpnClientUnaccessible ( EFalse )
    {
    }
    
// ----------------------------------------------------------------------------
// CmPluginVpnPolicySelectionDlg::ConstructL
// ----------------------------------------------------------------------------
//
void CmPluginVpnPolicySelectionDlg::ConstructL()
    {
    LoadResourceL( KPluginVPNResDirAndFileName );
    
    // Get the policies
    iPolicyInfoList = 
        new (ELeave) CArrayFixFlat<TVpnPolicyInfo>( KCmArrayMediumGranularity );
    
    TInt err( iVpnServ.Connect() );
    
    // Vpn client is inaccessible
    if ( err )
        {
        VpnClientInaccessibleL();
        }
    else
        {
        iVpnServ.GetPolicyInfoList( iPolicyInfoList );        
        iVpnServ.EnumeratePolicies( iNumPolicies );
        }
    }

// ----------------------------------------------------------------------------
// CmPluginVpnPolicySelectionDlg::LoadResourceL
// ----------------------------------------------------------------------------
//
void CmPluginVpnPolicySelectionDlg::LoadResourceL( const TDesC& aResFileName )
    {
    TInt err( KErrNone );
    
    // Add resource file.
    TParse* fp = new ( ELeave ) TParse();
    err = fp->Set( aResFileName, 
                        &KDC_RESOURCE_FILES_DIR, 
                        NULL ); 
    if ( err )
        {
        User::Leave( err );
        }   

    TFileName resourceFileNameBuf = fp->FullName();
    delete fp;

    iResourceReader.OpenL( resourceFileNameBuf );
    }

// ----------------------------------------------------------------------------
// CmPluginVpnPolicySelectionDlg::ShowPolicySelectionListL
// ----------------------------------------------------------------------------
//
TBool CmPluginVpnPolicySelectionDlg::ShowPolicySelectionListL()
    {
    LOGGER_ENTERFN( "CmPluginVpnPolicySelectionDlg::ShowPolicySelectionListL" );
    TBool retVal ( EFalse );
    
    CEikTextListBox* list = new ( ELeave ) CAknSinglePopupMenuStyleListBox;
    CleanupStack::PushL( list );
             
    // Create popup list
    CAknPopupList* popupList = CAknPopupList::NewL(
                                       list, 
                                       R_AVKON_SOFTKEYS_SELECT_CANCEL__SELECT,
                                       AknPopupLayouts::EMenuWindow);
    CleanupStack::PushL( popupList );

    // initialise listbox.
    list->ConstructL(popupList, CEikListBox::ELeftDownInViewRect);
    list->CreateScrollBarFrameL( ETrue );
    list->ScrollBarFrame()->SetScrollBarVisibilityL(
                               CEikScrollBarFrame::EOff,
                               CEikScrollBarFrame::EAuto);


    MDesCArray* itemList = list->Model()->ItemTextArray();
	CDesCArray* items = ( CDesCArray* ) itemList;	
	
    // collect the item texts    
    if ( iNumPolicies )
        {
        for ( TInt i = 0; i < iNumPolicies; i++ )
            {
            HBufC* polName = ( iPolicyInfoList->At(i) ).iName.AllocLC();
            items->AppendL( *polName );
            CleanupStack::PopAndDestroy( polName );
            }
        
        // title
        HBufC* title = StringLoader::LoadLC( R_QTN_NETW_CONSET_PRMPT_VPN_POLICY );
        popupList->SetTitleL( *title );
        CleanupStack::PopAndDestroy( title );
        
        // dislay dialog
        CleanupStack::Pop( popupList );
        if ( popupList->ExecuteLD() )
            {
            TInt ix = list->CurrentItemIndex();
            
            // Set VPN Policy to be used
            HBufC* polName = ( iPolicyInfoList->At(ix) ).iName.AllocLC();
            HBufC* polId = ( iPolicyInfoList->At(ix) ).iId.AllocLC();
            
            CLOG_WRITE_2( "New policy settings:[%S], [%S]", polName, polId );

            iCmPluginBaseEng.SetStringAttributeL( EVpnServicePolicyName, *polName );
            iCmPluginBaseEng.SetStringAttributeL( EVpnServicePolicy, *polId );
            CleanupStack::PopAndDestroy( polId );
            CleanupStack::PopAndDestroy( polName );
            
            retVal = ETrue;
            }
        }
    else
        {
        if (!iVpnClientUnaccessible)
        	{
        	// display error note
        	HBufC* text = StringLoader::LoadLC( R_QTN_VPN_INFO_NO_POLICIES_INSTALLED );
        	TCmCommonUi::ShowNoteL( *text, TCmCommonUi::ECmInfoNote );
        	CleanupStack::PopAndDestroy( text );
        	}
        CleanupStack::PopAndDestroy( popupList );
        }


	CleanupStack::PopAndDestroy( list );
    return retVal;
    }


// ----------------------------------------------------------------------------
// CmPluginVpnPolicySelectionDlg::ShowPolicySelectionDlgL
// ----------------------------------------------------------------------------
//
TBool CmPluginVpnPolicySelectionDlg::ShowPolicySelectionDlgL()
    {
    LOGGER_ENTERFN( "CmPluginVpnPolicySelectionDlg::ShowPolicySelectionDlgL" );
    TBool retVal ( EFalse );
    
    TInt selection(0);
    
    // Compile the list items
    CDesCArrayFlat* items = 
            new ( ELeave ) CDesCArrayFlat( KCmArraySmallGranularity );
    CleanupStack::PushL( items );
    
    TInt vpnerr;
    vpnerr = iVpnServ.EnumeratePolicies( iNumPolicies );
    
    if ( vpnerr )
        {
        VpnClientInaccessibleL();
        }
    else
        {        
        if ( iNumPolicies )
            {
            vpnerr = iVpnServ.GetPolicyInfoList( iPolicyInfoList );
            if ( vpnerr == 0 )
                {
                for ( TInt i = 0; i < iNumPolicies; i++ )
                    {
                    HBufC* policyName = 
                            ( iPolicyInfoList->At(i) ).iName.AllocLC();
                    
                            
                    // indicate if this policy is the one in the settings
                    HBufC* val = iCmPluginBaseEng.GetStringAttributeL( 
                                                        EVpnServicePolicyName );
                    
                    if ( !( val->Compare( policyName->Des() ) ) )
                        {
                        selection = i;
                        }
                    delete val;
                    
                    items->AppendL( *policyName );
                    CleanupStack::PopAndDestroy( policyName );
                    }
                // Create the dialog
                CAknRadioButtonSettingPage* dlg = 
                                    new ( ELeave ) CAknRadioButtonSettingPage(
                                            R_RADIO_BUTTON_SETTING_PAGE_OK_CANCEL,
                                            selection, 
                                            items );
                CleanupStack::PushL( dlg );
                
                // set title
                HBufC* title = StringLoader::LoadLC( 
                                        R_QTN_VPN_SETT_VPN_IAP_POLICY_REFERENCE );
                dlg->SetSettingTextL( *title );
                CleanupStack::PopAndDestroy( title );

                // display dialog
                CleanupStack::Pop();
                if ( dlg->ExecuteLD( CAknSettingPage::EUpdateWhenChanged ) )
                    {
                    HBufC* polId = 
                            ( iPolicyInfoList->At( selection ) ).iId.AllocLC();
                    HBufC* polName = 
                            ( iPolicyInfoList->At( selection ) ).iName.AllocLC();
                    iCmPluginBaseEng.SetStringAttributeL( EVpnServicePolicyName,
                                                          *polName );
                    
                    CLOG_WRITE_2( "New policy settings:[%S], [%S]", polName, polId );
                    
                    iCmPluginBaseEng.SetStringAttributeL( EVpnServicePolicy, 
                                                          *polId );
                    CleanupStack::PopAndDestroy( polName );
                    CleanupStack::PopAndDestroy( polId );
                    retVal = ETrue;
                    }
                }
            }
        else
            {
            // note: no VPN policies installed, reset policy to compulsory
            CLOG_WRITE("No policy installed, reset policies");
            
            HBufC* text = StringLoader::LoadLC( 
                                        R_QTN_VPN_INFO_NO_POLICIES_INSTALLED );
            TCmCommonUi::ShowNoteL( *text, TCmCommonUi::ECmInfoNote );
            CleanupStack::PopAndDestroy( text );
            vpnerr = -1;
            }
        }

    if ( vpnerr )
        {
        // note: no VPN policies installed or any other vpn error,
        //  reset policy to compulsory
        CLOG_WRITE("Reset policies");
        
        iCmPluginBaseEng.SetStringAttributeL( EVpnServicePolicyName,
                                              KNullDesC() );
        iCmPluginBaseEng.SetStringAttributeL( EVpnServicePolicy, 
                                              KNullDesC() );
        
        }

    CleanupStack::PopAndDestroy( items );
    return retVal;
    }
    
    
// ----------------------------------------------------------------------------
// CmPluginVpnPolicySelectionDlg::VpnClientInaccessibleL
// ----------------------------------------------------------------------------
//
void CmPluginVpnPolicySelectionDlg::VpnClientInaccessibleL()
    {
    LOGGER_ENTERFN( "CmPluginVpnPolicySelectionDlg::VpnClientInaccessibleL" );
    HBufC* text = StringLoader::LoadLC( R_QTN_VPN_INFO_MGMT_UI_NOT_ACCESSIBLE );
    TCmCommonUi::ShowNoteL( *text, TCmCommonUi::ECmInfoNote );
    CleanupStack::PopAndDestroy( text );
    iVpnClientUnaccessible = ETrue;
    }