/*
* 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:    Provisioning item.
*
*/




// INCLUDE FILES
#include <CWPParameter.h>
#include <CWPCharacteristic.h>
#include <commdb.h>
#include <XdmSettingsCollection.h>
#include <XdmSettingsApi.h>

#include "xdmprovitem.h"

#ifdef _DEBUG
    #include "xdmprovadapter.h"
#endif
// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CXdmProvItem::CXdmProvItem
// 
// -----------------------------------------------------------------------------
//
CXdmProvItem::CXdmProvItem():
    iXdmSettingsId( KErrNotFound ),
    iAppId( KNullDesC ),
    iAppName( KNullDesC ),
    iProviderId( KNullDesC ),
    iSipReference( NULL ),
    iToNapId( KNullDesC ),
    iNapId( NULL ),
    iNapName( KNullDesC ),
    iAppRef( KNullDesC ),
    iXcapRootUri( KNullDesC ),
    iUserName( KNullDesC ),
    iPassword( KNullDesC ),
    iAuthType( KNullDesC ),
    iSettingsSaved( EFalse )
    {
    }

// -----------------------------------------------------------------------------
// CXdmProvItem::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CXdmProvItem* CXdmProvItem::NewL()
    {
    CXdmProvItem* self = new (ELeave) CXdmProvItem();
    return self;
    }

// -----------------------------------------------------------------------------
// CXdmProvItem::~CXdmProvItem
// -----------------------------------------------------------------------------
//
CXdmProvItem::~CXdmProvItem()
    {
    iToAppReferences.Close();
    delete iSipReference;
    delete iNapId;
    }    

// -----------------------------------------------------------------------------
// CXdmProvItem::Validate
// -----------------------------------------------------------------------------
//
TBool CXdmProvItem::Validate() const
    {
    if ( !iAppId.Length() )
        {
#ifdef _DEBUG 
    CXdmProvAdapter::WriteToLog( _L8( "CXdmProvItem::Validate  iAppId missing" ) );
#endif
        return EFalse;
        }
    else if ( iAppId.Compare( KXdmProvAppId ) )
        {
#ifdef _DEBUG 
    CXdmProvAdapter::WriteToLog( _L8( "CXdmProvItem::Validate wrong iAppId" ) );
#endif
        return EFalse;
        }
    else if ( !iAppName.Length() )
        {
#ifdef _DEBUG 
    CXdmProvAdapter::WriteToLog( _L8( "CXdmProvItem::Validate iAppName missing" ) );
#endif
        return EFalse;
        }
     else if ( !iToNapId.Length() )
        {
#ifdef _DEBUG 
    CXdmProvAdapter::WriteToLog( _L8( "CXdmProvItem::Validate iNapId missing" ) );
#endif
        return EFalse;
        }
     else if ( !iXcapRootUri.Length() )
        {
#ifdef _DEBUG 
    CXdmProvAdapter::WriteToLog( _L8( "CXdmProvItem::Validate iXcapRootUri missing" ) );
#endif
        return EFalse;
        }
    else
        {
#ifdef _DEBUG 
    CXdmProvAdapter::WriteToLog( _L8( "CXdmProvItem::Validate returns true" ) );
#endif
        return ETrue;   
        }
    }
        
// -----------------------------------------------------------------------------
// CXdmProvItem::Name
// -----------------------------------------------------------------------------
//  
const TDesC& CXdmProvItem::Name() const
    {
    return iAppName; 
    }

// -----------------------------------------------------------------------------
// CXdmProvItem::ApplicationId
// -----------------------------------------------------------------------------
//  
const TDesC& CXdmProvItem::ApplicationId() const
    {
    return iAppId;
    }
    
// -----------------------------------------------------------------------------
// CXdmProvItem::XdmSettingsId
// -----------------------------------------------------------------------------
//  
TInt CXdmProvItem::XdmSettingsId() const
    {
    return iXdmSettingsId;
    }
    
// -----------------------------------------------------------------------------
// CXdmProvItem::AppReference
// -----------------------------------------------------------------------------
//  
const TDesC& CXdmProvItem::AppReference() const
    {
    return iAppRef;
    }
    
// -----------------------------------------------------------------------------
// CXdmProvItem::SaveL
// -----------------------------------------------------------------------------
//  
TInt CXdmProvItem::SaveL()
    {
#ifdef _DEBUG 
    CXdmProvAdapter::WriteToLog( _L8( "CXdmProvItem::SaveL" ) );
#endif
 
    if( !iSettingsSaved )
        {
        CXdmSettingsCollection* settings = new (ELeave) CXdmSettingsCollection();
        CleanupStack::PushL( settings );            // << settings
        settings->AppendL( iAppId, EXdmPropAppId );
        CheckExistingNamesL();
        settings->AppendL( iAppName, EXdmPropName );
        settings->AppendL( iProviderId, EXdmPropProvId );
        FindAccessPointIdL();              
        settings->AppendL( *iNapId, EXdmPropToNapId );
        if( iSipReference )
            {
            settings->AppendL( *iSipReference, EXdmPropToAppRef ); 
            }
        settings->AppendL( iXcapRootUri, EXdmPropUri );
        settings->AppendL( iUserName, EXdmPropAuthName );
        settings->AppendL( iPassword, EXdmPropAuthSecret );
        settings->AppendL( iAuthType, EXdmPropAuthType );
        iXdmSettingsId = TXdmSettingsApi::CreateCollectionL( *settings );
        CleanupStack::PopAndDestroy( settings );    // >>> settings
        iSettingsSaved = ETrue;
#ifdef _DEBUG 
    CXdmProvAdapter::WriteToLog( _L8( "CXdmProvItem::SaveL settings saved" ) );
#endif
        }
    
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CXdmProvItem::ToAppReferences
// -----------------------------------------------------------------------------
//
const RArray<TPtrC>& CXdmProvItem::ToAppReferences() const
    {
    return iToAppReferences;
    }

// -----------------------------------------------------------------------------
// CXdmProvItem::VisitL
// -----------------------------------------------------------------------------
//
void CXdmProvItem::VisitL( CWPCharacteristic& aCharacteristic )
    {
    if ( KWPResource == aCharacteristic.Type( ) )
        {
         aCharacteristic.AcceptL( *this );
#ifdef _DEBUG 
    CXdmProvAdapter::WriteToLog( _L8( "CXdmProvItem::VisitL CWPCharacteristic" ) );
#endif
        }
     }
        
// -----------------------------------------------------------------------------
// CXdmProvItem::VisitL
// -----------------------------------------------------------------------------
//
void CXdmProvItem::VisitL( CWPParameter& aParameter )
    {
#ifdef _DEBUG 
    HBufC8* value = HBufC8::NewLC( aParameter.Value().Length() );   // << value
    TPtr8 bufferPtr = value->Des();
    bufferPtr.Copy( aParameter.Value() );
    CXdmProvAdapter::WriteToLog( _L8( "CXdmProvItem::VisitL CWPParameter aParameter.Value() =%S" ), &bufferPtr );
    CleanupStack::PopAndDestroy( value );                           // >>> value
#endif
    switch( aParameter.ID() )
        {
        case EWPParameterAppID:
            {
            iAppId.Set( aParameter.Value() );
#ifdef _DEBUG 
    CXdmProvAdapter::WriteToLog( _L8( "CXdmProvItem::EWPParameterAppID" ) );
#endif
            }
            break;
    
        case EWPParameterProviderID:
            {
            iProviderId.Set( aParameter.Value() );
#ifdef _DEBUG 
    CXdmProvAdapter::WriteToLog( _L8( "CXdmProvItem::EWPParameterProviderID" ) );
#endif
            }
            break;

        case EWPParameterName:
            {
            iAppName.Set( aParameter.Value() );
#ifdef _DEBUG 
    CXdmProvAdapter::WriteToLog( _L8( "CXdmProvItem::EWPParameterName" ) );
#endif
            }
            break;  
            
        case EWPParameterToAppRef:
            {
            iToAppReferences.Append( aParameter.Value() );  
#ifdef _DEBUG 
    CXdmProvAdapter::WriteToLog( _L8( "CXdmProvItem::EWPParameterToAppRef" ) );
#endif
            }
            break;
    
        case EWPParameterToNapID:
            {
            iToNapId.Set( aParameter.Value() );
#ifdef _DEBUG 
    CXdmProvAdapter::WriteToLog( _L8( "CXdmProvItem::EWPParameterToNapID" ) );
#endif
            }
            break; 
            
        case EWPParameterURI:
            {
            iXcapRootUri.Set( aParameter.Value() );
#ifdef _DEBUG 
    CXdmProvAdapter::WriteToLog( _L8( "CXdmProvItem::EWPParameterURI" ) );
#endif
            }
            break;

        case EWPParameterAAuthName:
            {
            iUserName.Set( aParameter.Value() );
#ifdef _DEBUG 
    CXdmProvAdapter::WriteToLog( _L8( "CXdmProvItem::EWPParameterAAuthName" ) );
#endif
            }
            break;  
            
        case EWPParameterAAuthSecret:
            {
            iPassword.Set( aParameter.Value() );
#ifdef _DEBUG 
    CXdmProvAdapter::WriteToLog( _L8( "CXdmProvItem::EWPParameterAAuthSecret" ) );
#endif
            }
            break;
      
        case EWPParameterAAuthType:
            {
            iAuthType.Set( aParameter.Value() );
#ifdef _DEBUG 
    CXdmProvAdapter::WriteToLog( _L8( "CXdmProvItem::EWPParameterAAuthType" ) );
#endif
            }
            break; 
            
        case EWPParameterAppRef:
            {
            iAppRef.Set( aParameter.Value() );
#ifdef _DEBUG 
    CXdmProvAdapter::WriteToLog( _L8( "CXdmProvItem::EWPParameterAppRef" ) );
#endif
            }
            break;   
        default:
            {
            DetermineNamedParameter( aParameter.Name(), aParameter.Value() );
            }
            break;
        }
    }

// -----------------------------------------------------------------------------
// CXdmProvItem::DetermineNamedParameter
// -----------------------------------------------------------------------------
//
void CXdmProvItem::DetermineNamedParameter( const TDesC& aName, const TDesC& aValue )
    {
    if ( !aName.Compare( KXdmProvAppRef ) )
        {
        iAppRef.Set( aValue );
        }
    else if ( !aName.Compare( KXdmProvToAppRef ) )
        {
        iToAppReferences.Append( aValue ); 
        }
    }
// -----------------------------------------------------------------------------
// CXdmProvItem::VisitLinkL
// -----------------------------------------------------------------------------
//
void CXdmProvItem::VisitLinkL( CWPCharacteristic& aLink )
    {
#ifdef _DEBUG 
    CXdmProvAdapter::WriteToLog( _L8( "CXdmProvItem::VisitLinkL" ) );
#endif
    if( KWPNapDef == aLink.Type() )
        {        
        // check that this is the correct one 
        CArrayFix<TPtrC>* napId = new (ELeave) CArrayFixFlat<TPtrC>(1);
        CleanupStack::PushL( napId );           // << napId
        aLink.ParameterL( EWPParameterNapID, napId );
        if ( 0 < napId->Count() )
            {
            if ( !napId->At(0).Compare( iToNapId ) )
                {
                SetNapDefL( aLink );
                }
            }      
        CleanupStack::PopAndDestroy( napId );   // >>> napId
        }
    }
    
// -----------------------------------------------------------------------------
// CXdmProvItem::SetNapDefL
// -----------------------------------------------------------------------------
//  
void CXdmProvItem::SetNapDefL ( CWPCharacteristic& aLink )
    {
#ifdef _DEBUG 
    CXdmProvAdapter::WriteToLog( _L8( "CXdmProvItem::SetNapDefL" ) );
#endif  
    // find the name of the access point 
    CArrayFix<TPtrC>* name = new (ELeave) CArrayFixFlat<TPtrC>(1);
    CleanupStack::PushL( name );        // << name
    aLink.ParameterL( EWPParameterName, name );
    if ( name->Count() > 0 )
        {
        iNapName.Set( name->At(0) );
        }
    CleanupStack::PopAndDestroy( name ); // >>> name
        
#ifdef _DEBUG 
    CXdmProvAdapter::WriteToLog( _L8( "CXdmProvItem::SetNapDefL done" ) );
#endif  
    }
// -----------------------------------------------------------------------------
// CXdmProvItem::SetSipSettingsIdL
// -----------------------------------------------------------------------------
//  
void CXdmProvItem::SetSipSettingsIdL( const TDesC8& aStorageIdValue )
    {
    delete iSipReference;
    iSipReference = NULL;
    iSipReference = HBufC::NewL( aStorageIdValue.Length() ); 
    iSipReference->Des().Copy( aStorageIdValue );
    }   

// -----------------------------------------------------------------------------
// CXdmProvItem::FindAccessPointIdL
// -----------------------------------------------------------------------------
// 
void CXdmProvItem::FindAccessPointIdL ()
    {       
            
    TInt result( KErrNone );
    TUint32 idNum;
    TBuf<KXdmProvNameLength> name;   
    // Get IAP names and ids from the database
    CCommsDatabase* commsDb = CCommsDatabase::NewL( EDatabaseTypeIAP ); 
    CleanupStack::PushL( commsDb );             // << commsDb
    commsDb->ShowHiddenRecords();    
    CCommsDbTableView* view = commsDb->OpenTableLC( TPtrC( IAP ) ); // << view    
    result = view->GotoFirstRecord();
    
    while( KErrNone == result )
        {
        view->ReadTextL( TPtrC( COMMDB_NAME ), name );
        if ( KErrNotFound != name.Find( iNapName ) )
            {
            view->ReadUintL( TPtrC( COMMDB_ID ), idNum );
#ifdef _DEBUG 
    CXdmProvAdapter::WriteToLog( _L8( "CXdmProvItem::FindAccessPointIdL IAP found id=%d" ), idNum );
#endif
            }
        result = view->GotoNextRecord();
        }
#ifdef _DEBUG 
    CXdmProvAdapter::WriteToLog( _L8( "CXdmProvItem::FindAccessPointIdL IAP using id=%d" ), idNum );
#endif
    CleanupStack::PopAndDestroy( 2, commsDb );  // >>> view, commsDb
    TBuf<KXdmProvIdLength> id;
    id.AppendNum( idNum, EDecimal );
    delete iNapId;
    iNapId = NULL;
    iNapId = id.AllocL();
    }

// -----------------------------------------------------------------------------
// CXdmProvItem::CheckExistingNamesL()
// -----------------------------------------------------------------------------
// 
void CXdmProvItem::CheckExistingNamesL( )
    {    
    TBool ready( EFalse );  
    RArray<TInt> settingIds;
    CleanupClosePushL( settingIds );                // << settingIds
    CDesCArray* settingNames = TXdmSettingsApi::CollectionNamesLC( settingIds ); // << settingNames
    TInt index( 0 );
    while ( !ready )
        {
        TBool found ( EFalse );
        TInt count = settingNames->MdcaCount();
        TBuf<KXdmProvBufLength> tempName;
        tempName.Copy( iAppName );
        if ( index > 0 )
            {
            tempName.Append( KXdmProvStartBracket );
            tempName.AppendNumFixedWidth( index, EDecimal, 2 );
            tempName.Append( KXdmProvCloseBracket );
            }
        for ( TInt i(0); i < count && !found; i++ )
            {
            if ( !settingNames->MdcaPoint(i).CompareF( tempName ) )
                {
                found = ETrue;
                index++;
                }
            }
        if ( !found )
            {
            ready = ETrue;
            iAppName.Set( tempName );
            }
        }
    // only number used in next function, type of RArray
    CleanupStack::PopAndDestroy( 2 );  // >>> settingNames, settingIds
    }


//  End of File