/*
* 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:  Provides settings management in Central Repository.
*
*/



#include <utf.h>
#include <pdpcontextmanagerinternalcrkeys.h>

#include "nsmldmalwaysonsettingstore.h"
#include "nsmldmalwaysonadapter.h"
#include "logger.h"

// AWON-PDPC
// Values are XY, where X is related to 3G flag and Y is related to 2G flag.
// Possible values are:
// "00", AlwaysOn is OFF for both 3G and 2G
// "10", AlwaysOn is ON for 3G, OFF for 2G
// "01", AlwaysOn is OFF for 3G, ON for 2G
// "11", AlwaysOn is ON for 3G, ON for 2G
const TInt KAwonPdpc_Off3G_Off2G = 00;
const TInt KAwonPdpc_Off3G_On2G  = 01;
const TInt KAwonPdpc_On3G_Off2G  = 10;
const TInt KAwonPdpc_On3G_On2G   = 11;

const TInt KBufSize = 10;

// -----------------------------------------------------------------------------
// CNSmlDmAOSettingStore::NewL
// -----------------------------------------------------------------------------
CNSmlDmAOSettingStore* CNSmlDmAOSettingStore::NewL( CNSmlDmAOAdapter * aAdapter )
    {
    CNSmlDmAOSettingStore* self = new (ELeave) CNSmlDmAOSettingStore( aAdapter );
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CNSmlDmAOSettingStore::CNSmlDmAOSettingStore
// -----------------------------------------------------------------------------
CNSmlDmAOSettingStore::CNSmlDmAOSettingStore( CNSmlDmAOAdapter * aAdapter ) 
    : iAdapter( aAdapter )
    {
    }

// -----------------------------------------------------------------------------
// CNSmlDmAOSettingStore::ConstructL
// -----------------------------------------------------------------------------
void CNSmlDmAOSettingStore::ConstructL()
    {   
    }

// -----------------------------------------------------------------------------
// CNSmlDmAOSettingStore::~CNSmlDmAOSettingStore
// -----------------------------------------------------------------------------
CNSmlDmAOSettingStore::~CNSmlDmAOSettingStore()
    {
    }

// -----------------------------------------------------------------------------
// CNSmlDmAOSettingStore::ExecuteCmdL
// Executes a single command
// -----------------------------------------------------------------------------
void CNSmlDmAOSettingStore::ExecuteCmdL( CSmlDmAOCommandElement& aCmd, TUint aLuid)
    {   
    if( !aCmd.Leaf() )
        {
        ExecuteVendorConfigCmdL( aCmd, aLuid );
        }
    else 
        {
        CRepository* cenrep = CRepository::NewL( KCRUidPDPContextManager );
        CleanupStack::PushL( cenrep );
        
        // name
        if ( !aCmd.LastUriSeg()->Compare( KNSmlDmAOAdapterName ) )
            {
            ExecuteNameCmdL( aCmd, cenrep );            
            }
        // awon-pdpc
        else if ( !aCmd.LastUriSeg()->Compare( KNSmlDmAOAdapterAwonPdpc ) )
            {
            ExecuteAwonPdpcCmdL( aCmd, cenrep );
            } 
        // t-retry
        else if ( !aCmd.LastUriSeg()->Compare( KNSmlDmAOAdapterTRetry ) )
            {
            ExecuteTRetryCmdL( aCmd, cenrep ); 
            } 
        else
            {
            // invalid node
            LOGSTRING( "ExecuteCmdL: Error, Invalid node name" );
            aCmd.SetStatus( CSmlDmAdapter::ENotFound );
            }
                         				    
        aCmd.SetExecuted( ETrue );
        
        CleanupStack::PopAndDestroy( cenrep );    
        }   
    }    

	 
// -----------------------------------------------------------------------------
// CNSmlDmAOSettingStore::GetVendorConfigsL
// Fetches all VENDORCONFIG ids
// -----------------------------------------------------------------------------
void CNSmlDmAOSettingStore::GetVendorConfigsL( RArray<TUint32>& aLUIDArray )
        {
        // Only one VENDORCONFIG node possible at the moment
        aLUIDArray.Append( KDefaultLuid );
        }
 
// -----------------------------------------------------------------------------
// CNSmlDmAOSettingStore::ExecuteVendorConfigCmdL
// Executes a command for VENDORCONFIG node. Either delete or get, adds are handled 
// in StoreVendorConfigL
// -----------------------------------------------------------------------------
void CNSmlDmAOSettingStore::ExecuteVendorConfigCmdL( CSmlDmAOCommandElement& aCmd, 
                                                     TUint /*aLuid*/ )
    {
    
    if ( aCmd.CmdType() == CNSmlDmAOAdapter::EGetCmd )
        {
        aCmd.SetData( KNSmlDmAOAllLeafNodes().AllocL() );
        aCmd.SetStatus( CSmlDmAdapter::EOk );
        aCmd.SetExecuted( ETrue );
        }
    else if ( aCmd.CmdType() == CNSmlDmAOAdapter::EDeleteCmd )
        {
        // Should not be possible to delete
        aCmd.SetStatus( CSmlDmAdapter::EOk );
        aCmd.SetExecuted( ETrue );
        }
    else
        {
        LOGSTRING( "ExecuteVendorConfigCmdL: Error, Invalid cmd type" );
        aCmd.SetStatus( CSmlDmAdapter::EError );
        }
    }


// ---------------------------------------------------------------------------
// CNSmlDmAOSettingStore::ExecuteNameCmdL
// Executes NAME command (add or get )
// ---------------------------------------------------------------------------
//
void CNSmlDmAOSettingStore::ExecuteNameCmdL( CSmlDmAOCommandElement& aCmd, 
                                             CRepository*         /*aCenrep*/ )
    {
    if ( aCmd.CmdType() == CNSmlDmAOAdapter::EAddCmd )
        {
        HBufC* name = HBufC::NewLC( aCmd.Data()->Size() );
        TPtr namePtr = name->Des();
        CnvUtfConverter::ConvertToUnicodeFromUtf8( namePtr, *aCmd.Data() );

        // name is not written to the CentralRepository
        // Add write to CR here

        CleanupStack::PopAndDestroy( name );
        aCmd.SetStatus( CSmlDmAdapter::EOk );
        }        		
    else if ( aCmd.CmdType() == CNSmlDmAOAdapter::EGetCmd ||
              aCmd.CmdType() == CNSmlDmAOAdapter::EGetSizeCmd )
        {
        // name is not written/read to/from the CentralRepository
        // Add read from CR here
        
        //HBufC* data = ...read name
        
        //HBufC8* data8 = HBufC8::NewLC( data->Size() );
        //TPtr8 toPtr = data8->Des();        
        //CnvUtfConverter::ConvertFromUnicodeToUtf8( toPtr, *data );
        //aCmd.SetData( data8 );
        //CleanupStack::Pop( data8 );
        //CleanupStack::PopAndDestroy( data );

        // for size command, set the command data to be the 
        // size of the fetched data
        
        //if( aCmd.CmdType() == CNSmlDmAOAdapter::EGetSizeCmd )
        //    {            
        //    HBufC8* size = iAdapter->IntToDes8L( aCmd.Data()->Size() );
        //    aCmd.SetData( size );
        //    }                
        
        aCmd.SetStatus( CSmlDmAdapter::EOk );
        aCmd.SetExecuted( ETrue );
        }
    else    
        {
        // unsupported command
        // this is checked by framework
        aCmd.SetStatus( CSmlDmAdapter::EError );
        LOGSTRING( "ExecuteNameCmdL: Error, Only Add, Get and Get size commands supported" );
        }  
    }
    
// ---------------------------------------------------------------------------
// CNSmlDmAOSettingStore::ExecuteAwonPdpcCmdL
// Executes AWON-PDPC command (add or get )
// ---------------------------------------------------------------------------
//
void CNSmlDmAOSettingStore::ExecuteAwonPdpcCmdL( CSmlDmAOCommandElement& aCmd, 
                                                 CRepository*         aCenrep )
    {
    if ( aCmd.CmdType() == CNSmlDmAOAdapter::EAddCmd )
        {
        HBufC* data = HBufC::NewLC( aCmd.Data()->Size() );
        TPtr dataPtr = data->Des();
        CnvUtfConverter::ConvertToUnicodeFromUtf8( dataPtr, *aCmd.Data() );

        // write to the CentralRepository
        TInt value( 0 );
        TInt hplmn( 0 );
        TInt vplmn( 0 );
        
        ParseIntegerL( dataPtr, value );
        ParseAwonPdpcValuesL( value, hplmn, vplmn );
        
        User::LeaveIfError( aCenrep->Set( KPDPContextManagerEnableWhenHome,
        hplmn ) );
        User::LeaveIfError( aCenrep->Set( KPDPContextManagerEnableWhenRoaming,
        vplmn ) );

        CleanupStack::PopAndDestroy( data );
        aCmd.SetStatus( CSmlDmAdapter::EOk );
        }        		
    else if ( aCmd.CmdType() == CNSmlDmAOAdapter::EGetCmd ||
              aCmd.CmdType() == CNSmlDmAOAdapter::EGetSizeCmd )
        {
        // read from CentralRepository
        TInt hplmn( 0 );
        TInt vplmn( 0 );
        
        User::LeaveIfError(
        aCenrep->Get( KPDPContextManagerEnableWhenHome, hplmn ) );
        User::LeaveIfError(
        aCenrep->Get( KPDPContextManagerEnableWhenRoaming, vplmn ) );
        
        HBufC* data    = HBufC::NewLC( KBufSize );
        TPtr   dataPtr = data->Des();
        
        dataPtr.Zero();
        dataPtr.FillZ();
        dataPtr.AppendNum( hplmn );
        dataPtr.AppendNum( vplmn );
        
        HBufC8* data8 = HBufC8::NewLC( data->Size() );
        TPtr8 toPtr = data8->Des();        
        CnvUtfConverter::ConvertFromUnicodeToUtf8( toPtr, *data );
        aCmd.SetData( data8 );
        CleanupStack::Pop( data8 );
        CleanupStack::PopAndDestroy( data );

        // for size command, set the command data to be the 
        // size of the fetched data
        if( aCmd.CmdType() == CNSmlDmAOAdapter::EGetSizeCmd )
            {            
            HBufC8* size = iAdapter->IntToDes8L( aCmd.Data()->Size() );
            aCmd.SetData( size );
            }                
        aCmd.SetStatus( CSmlDmAdapter::EOk );
        aCmd.SetExecuted( ETrue );
        }
    else    
        {
        // unsupported command
        // this is checked by framework
        aCmd.SetStatus( CSmlDmAdapter::EError );
        LOGSTRING( "ExecuteNameCmdL: Error, Only Add, Get and Get size commands supported" );
        }  
    }
    
 // ---------------------------------------------------------------------------
// CNSmlDmAOSettingStore::ExecuteTRetryCmdL
// Executes T-RETRY command (add or get )
// ---------------------------------------------------------------------------
//
void CNSmlDmAOSettingStore::ExecuteTRetryCmdL( CSmlDmAOCommandElement& aCmd, 
                                               CRepository*            aCenrep )
    {
    if ( aCmd.CmdType() == CNSmlDmAOAdapter::EAddCmd )
        {
        HBufC* data = HBufC::NewLC( aCmd.Data()->Size() );
        TPtr dataPtr = data->Des();
        CnvUtfConverter::ConvertToUnicodeFromUtf8( dataPtr, *aCmd.Data() );

        // write to the CentralRepository
        TInt value( 0 );
        ParseIntegerL( dataPtr, value );
        
        User::LeaveIfError( aCenrep->Set( KPDPContextManagerRetryTimer,
                            value ) );

        CleanupStack::PopAndDestroy( data );
        aCmd.SetStatus( CSmlDmAdapter::EOk );
        }        		
    else if ( aCmd.CmdType() == CNSmlDmAOAdapter::EGetCmd ||
              aCmd.CmdType() == CNSmlDmAOAdapter::EGetSizeCmd )
        {
        // Read from CentralRepository
        TInt value( 0 );
        User::LeaveIfError( aCenrep->Get( KPDPContextManagerRetryTimer,
                            value ) );
        
        HBufC* data    = HBufC::NewLC( KBufSize );
        TPtr   dataPtr = data->Des();
        
        dataPtr.Zero();
        dataPtr.FillZ();
        dataPtr.AppendNum( value );
        
        HBufC8* data8 = HBufC8::NewLC( data->Size() );
        TPtr8 toPtr = data8->Des();        
        CnvUtfConverter::ConvertFromUnicodeToUtf8( toPtr, *data );
        aCmd.SetData( data8 );
        CleanupStack::Pop( data8 );
        CleanupStack::PopAndDestroy( data );

        // for size command, set the command data to be the 
        // size of the fetched data
        if( aCmd.CmdType() == CNSmlDmAOAdapter::EGetSizeCmd )
            {            
            HBufC8* size = iAdapter->IntToDes8L( aCmd.Data()->Size() );
            aCmd.SetData( size );
            }                
        aCmd.SetStatus( CSmlDmAdapter::EOk );
        aCmd.SetExecuted( ETrue );
        }
    else    
        {
        // unsupported command
        // this is checked by framework
        aCmd.SetStatus( CSmlDmAdapter::EError );
        LOGSTRING( "ExecuteNameCmdL: Error, Only Add, Get and Get size commands supported" );
        }  
    }
    
// -----------------------------------------------------------------------------
// CNSmlDmAOSettingStore::ParseIntegerL
// -----------------------------------------------------------------------------
//
void CNSmlDmAOSettingStore::ParseIntegerL( const TDesC& aPtr, TInt& aInt )
    {
    TLex lex( aPtr );
    User::LeaveIfError( lex.Val( aInt ) );
    }

// -----------------------------------------------------------------------------
// CNSmlDmAOSettingStore::ParseAwonPdpcValuesL
// -----------------------------------------------------------------------------
//
void CNSmlDmAOSettingStore::ParseAwonPdpcValuesL( const TInt aInt,
                                                  TInt& aHplmn,
                                                  TInt& aVplmn )
    {
    switch( aInt )
        {
        case KAwonPdpc_Off3G_Off2G:
            aHplmn = 0;
            aVplmn = 0;
            break;
        case KAwonPdpc_Off3G_On2G:
            aHplmn = 0;
            aVplmn = 1;
            break;
        case KAwonPdpc_On3G_Off2G:
            aHplmn = 1;
            aVplmn = 0;
            break;
        case KAwonPdpc_On3G_On2G:
            aHplmn = 1;
            aVplmn = 1;
            break;
        default:
            User::Leave( KErrNotSupported );
            break;
        }
    }