/*

* 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:  Used to read in only access points with the desired characteristics.

*

*/

#include <commdb.h>

#include <e32cmn.h>

#include "irdebug.h"

#include "irfilteredapreader.h"

_LIT( KDynIpAddress, "0.0.0.0" );

_LIT( KEasyWLAN, "Easy WLAN" );

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

// CIRFilteredApReader::NewL

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

//

CIRFilteredApReader* CIRFilteredApReader::NewL( TInt aFilterFlags )

    {

    IRLOG_DEBUG2( "CIRFilteredApReader::NewL - Filter flags = %d", aFilterFlags );

    CIRFilteredApReader* self = CIRFilteredApReader::NewLC( aFilterFlags );

    CleanupStack::Pop( self );

    IRLOG_DEBUG( "CIRFilteredApReader::NewL - Exiting." );    

    return self;

    }

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

// CIRFilteredApReader::NewLC

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

//

CIRFilteredApReader* CIRFilteredApReader::NewLC( TInt aFilterFlags )

    {

    IRLOG_DEBUG2( "CIRFilteredApReader::NewLC - Filter flags = %d", aFilterFlags );

    CIRFilteredApReader* self = new( ELeave ) CIRFilteredApReader( aFilterFlags );

    CleanupStack::PushL( self );

    self->ConstructL();

    IRLOG_DEBUG( "CIRFilteredApReader::NewL - Exiting." );    

    return self;

    }

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

// CIRFilteredApReader::FirstRecordL

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

//

CCDIAPRecord* CIRFilteredApReader::FirstRecordL()

    {

    IRLOG_DEBUG( "CIRFilteredApReader::FirstRecordL - Entering" );    

    CCDIAPRecord* record( NULL );

    iWapTableIndex = 0;

    if ( iWapTable->iRecords.Count() > 0 )

        {

        TBool loaded( EFalse );

        TRAPD( err, loaded = LoadCurrentApDetailsL() ); // may leave because of access rights etc.

        if ( err == KErrNone && loaded && FilterL() )

            {

            record = static_cast<CCDIAPRecord*>( CCDRecordBase::CreateCopyRecordL( *iIapRecord ) );

            record->SetRecordId( iIapRecord->RecordId() );

            IRLOG_INFO2( "CIRFilteredApReader::FirstRecordL - %S accepted.", &record->iRecordName.GetL() );

            }

        else if ( err != KErrNone || !loaded )

            {

            IRLOG_ERROR3( "CIRFilteredApReader::FirstRecordL - Loading AP details failed ( err=%d, loaded=%d ).",

                          err, loaded );            

            record = NextRecordL();

            }

        else

            {

            IRLOG_INFO2( "CIRFilteredApReader::FirstRecordL - %S filtered out.", &iIapRecord->iRecordName.GetL() );

            record = NextRecordL();            

            }

        }        

    IRLOG_DEBUG( "CIRFilteredApReader::FirstRecordL - Exiting." );    

    return record;

    }

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

// CIRFilteredApReader::NextRecordL

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

//

CCDIAPRecord* CIRFilteredApReader::NextRecordL()

    {

    IRLOG_DEBUG( "CIRFilteredApReader::NextRecordL - Entering" );    

    CCDIAPRecord* record( NULL );

    while ( !record && MoveToNextRecord() )

        {

        TBool loaded( EFalse );

        TRAPD( err, loaded = LoadCurrentApDetailsL() ); // may leave because of access rights etc.

        if ( err == KErrNone && loaded && FilterL() )

            {

            record = static_cast<CCDIAPRecord*>( CCDRecordBase::CreateCopyRecordL( *iIapRecord ) );

            record->SetRecordId( iIapRecord->RecordId() );            

            IRLOG_INFO2( "CIRFilteredApReader::FirstRecordL - %S accepted.", &record->iRecordName.GetL() );            

            }

        else if ( err != KErrNone || !loaded )

            {

            IRLOG_ERROR3( "CIRFilteredApReader::NextRecordL - Loading AP details failed ( err=%d, loaded=%d ).",

                          err, loaded );            

            }

        else

            {

            IRLOG_INFO2( "CIRFilteredApReader::NextRecordL - %S filtered out.", &iIapRecord->iRecordName.GetL() );

            }

        }

    IRLOG_DEBUG( "CIRFilteredApReader::NextRecordL - Exiting." );    

    return record;

    }

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

// CIRFilteredApReader::CIRFilteredApReader

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

//

CIRFilteredApReader::CIRFilteredApReader( TInt aFilterFlags ) 

    : iFilterFlags( aFilterFlags )  

    {

    IRLOG_DEBUG( "CIRFilteredApReader::CIRFilteredApReader" );                

    }

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

// CIRFilteredApReader::ConstructL

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

//

void CIRFilteredApReader::ConstructL()

    {

    IRLOG_DEBUG( "CIRFilteredApReader::ConstructL - Entering" );                

    iDbSession = CMDBSession::NewL( CMDBSession::LatestVersion() );

    iWapTable = new ( ELeave ) CMDBRecordSet<CCDWAPAccessPointRecord>( KCDTIdWAPAccessPointRecord );

    iWapTable->LoadL( *iDbSession );

    IRLOG_DEBUG( "CIRFilteredApReader::ConstructL - Exiting." );    

    }

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

// CIRFilteredApReader::~CIRFilteredApReader

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

//

CIRFilteredApReader::~CIRFilteredApReader()

    {

    IRLOG_DEBUG( "CIRFilteredApReader::~CIRFilteredApReader - Entering" );    

    delete iDbSession;

    delete iWapTable;

    delete iWapIpBearerRecord;

    delete iIapRecord;

    IRLOG_DEBUG( "CIRFilteredApReader::~CIRFilteredApReader - Exiting." );    

    }

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

// CIRFilteredApReader::CurrentRecordL

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

//

CCDWAPAccessPointRecord* CIRFilteredApReader::CurrentRecordL() const

    {

    IRLOG_DEBUG( "CIRFilteredApReader::CurrentRecordL - Entering" );    

    if ( iWapTableIndex >= iWapTable->iRecords.Count() )

        {

        IRLOG_FATAL( "CIRFilteredApReader::CurrentRecordL - WAP table overflow!" );

        User::Leave( KErrCorrupt );

        }

    IRLOG_DEBUG( "CIRFilteredApReader::CurrentRecordL - Exiting" );    

    return static_cast<CCDWAPAccessPointRecord*>( iWapTable->iRecords[iWapTableIndex] );

    }

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

// CIRFilteredApReader::MoveToNextRecord

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

//

TBool CIRFilteredApReader::MoveToNextRecord()

    {

    IRLOG_DEBUG( "CIRFilteredApReader::MoveToNextRecord - Entering" );    

    TBool retMe( EFalse );

    if ( ++iWapTableIndex < iWapTable->iRecords.Count() )

        {

        IRLOG_INFO2( "CIRFilteredApReader::MoveToNextRecord - Current record %d", iWapTableIndex );        

        retMe = ETrue;

        }

    else

        {

        IRLOG_INFO( "CIRFilteredApReader::MoveToNextRecord - No more records" );        

        }

    IRLOG_DEBUG( "CIRFilteredApReader::MoveToNextRecord - Exiting" );    

    return retMe;

    }

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

// CIRFilteredApReader::LoadCurrentApDetailsL

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

//

TBool CIRFilteredApReader::LoadCurrentApDetailsL()

    {

    IRLOG_DEBUG( "CIRFilteredApReader::LoadCurrentApDetailsL - Entering" );    

    delete iWapIpBearerRecord;

    iWapIpBearerRecord = NULL;

    delete iIapRecord;

    iIapRecord = NULL;

    // Load record from WAPIPBearer

    iWapIpBearerRecord = static_cast<CCDWAPIPBearerRecord*>( 

            CCDRecordBase::RecordFactoryL( KCDTIdWAPIPBearerRecord ) );

    iWapIpBearerRecord->iWAPAccessPointId.SetL( CurrentRecordL()->RecordId() );

    TBool res = iWapIpBearerRecord->FindL( *iDbSession );

    if ( res )

        {

        iIapRecord = static_cast<CCDIAPRecord*>(

                 CCDRecordBase::RecordFactoryL( KCDTIdIAPRecord ) );

        iIapRecord->SetRecordId( iWapIpBearerRecord->iWAPIAP );

        iIapRecord->LoadL( *iDbSession );

        }

    IRLOG_DEBUG2( "CIRFilteredApReader::LoadCurrentApDetailsL - returning %d", res );    

    return res;

    }

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

// CIRFilteredApReader::FilterL

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

//

TBool CIRFilteredApReader::FilterL() const

    {

    IRLOG_DEBUG2( "CIRFilteredApReader::FilterL - Service type %S", &iIapRecord->iServiceType.GetL() );    

    TBool retMe( ETrue );

    // The WAP check needs to be done only for CSD, GPRS, CDMA and LAN (  because of Easy WLAN )

    // APs. 

    if ( iIapRecord->iServiceType.GetL().Compare( TPtrC( KCDTypeNameDialOutISP ) ) == 0 ||

         iIapRecord->iServiceType.GetL().Compare( TPtrC( KCDTypeNameOutgoingWCDMA ) ) == 0 ||

//         iIapRecord->iServiceType.GetL().Compare( 

//         TPtrC( KCDTypeNameCDMA2000PacketService ) ) == 0 ||

         iIapRecord->iServiceType.GetL().Compare( TPtrC( KCDTypeNameLANService) ) == 0 )

        {

        if ( iFilterFlags & KIRFilterWAPMandatory )

            {

            retMe = FilterWAPMandatoryL();

            }

        if ( retMe && iFilterFlags & KIRFilterWAPOnly )

            {

            retMe = FilterWAPOnlyL();

            }

        if ( retMe && iFilterFlags & KIRFilterEasyWLAN )

            {

            retMe = FilterEasyWlanL();            

            }

        }

    IRLOG_DEBUG2( "CIRFilteredApReader::FilterL - Returning %d", retMe );    

    return retMe;

    }

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

// CIRFilteredApReader::FilterWAPMandatoryL

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

//

TBool CIRFilteredApReader::FilterWAPMandatoryL() const

    {

    IRLOG_DEBUG( "CIRFilteredApReader::FilterWAPMandatoryL - Entering" );    

    TBool retMe( EFalse );

    // First check the WAP_GATEWAY_ADDRESS of WAP_IP_BEARER table.

    if ( iWapIpBearerRecord->iWAPGatewayAddress.IsNull() || 

         iWapIpBearerRecord->iWAPGatewayAddress.GetL().Length() == 0 ||

         iWapIpBearerRecord->iWAPGatewayAddress.GetL().Compare( KDynIpAddress ) == 0 )

        {

        retMe = ETrue;

        }

    IRLOG_INFO3( "CIRFilteredApReader::FilterWAPMandatoryL - Returning %d for %S", retMe, &iIapRecord->iRecordName.GetL() );

    return retMe;

    }

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

// CIRFilteredApReader::FilterWAPOnlyL

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

//

TBool CIRFilteredApReader::FilterWAPOnlyL() const

    {

    IRLOG_DEBUG( "CIRFilteredApReader::FilterWAPOnlyL - Entering" );    

    TBool retMe( EFalse );

    IRLOG_DEBUG2( "CIRFilteredApReader::FilterWAPOnlyL - Service type %S", &iIapRecord->iServiceType.GetL() );

    if ( iIapRecord->iServiceType.GetL().Compare( TPtrC( KCDTypeNameDialOutISP ) ) == 0 )

        {

        CCDDialOutISPRecord* dialOutRecord = static_cast<CCDDialOutISPRecord*>( 

                    CCDRecordBase::RecordFactoryL( KCDTIdDialOutISPRecord ) );

        CleanupStack::PushL( dialOutRecord );

        dialOutRecord->SetRecordId( iIapRecord->iService );

        dialOutRecord->LoadL( *iDbSession );

        if ( dialOutRecord->iType != EIspTypeWAPOnly )

            {

            retMe = ETrue;

            }

        CleanupStack::PopAndDestroy( dialOutRecord );

        }

    else if ( iIapRecord->iServiceType.GetL().Compare( TPtrC( KCDTypeNameOutgoingWCDMA ) ) == 0 )

        {

        CCDWCDMAPacketServiceRecord* gprsRecord = static_cast<CCDWCDMAPacketServiceRecord*>( 

                CCDRecordBase::RecordFactoryL( KCDTIdOutgoingGprsRecord ) );

        CleanupStack::PushL( gprsRecord );

        gprsRecord->SetRecordId( iIapRecord->iService );

        gprsRecord->LoadL( *iDbSession );

        if ( gprsRecord->iGPRSAPType != EIspTypeWAPOnly )

            {

            retMe = ETrue;

            }

        CleanupStack::PopAndDestroy( gprsRecord );

        }

//    else if ( iIapRecord->iServiceType.GetL().Compare( 

//    TPtrC( KCDTypeNameCDMA2000PacketService ) ) == 0 )

//        {

//        CCDCDMA2000PacketServiceRecord* cdmaRecord = static_cast<CCDCDMA2000PacketServiceRecord*>(

//        CCDRecordBase::RecordFactoryL( KCDTIdCDMA2000PacketServiceRecord ) );

//        CleanupStack::PushL( cdmaRecord );

//        cdmaRecord->SetRecordId( iIapRecord->iService );

//        cdmaRecord->LoadL( *iDbSession );

//        if ( cdmaRecord->iApType != EIspTypeWAPOnly )

//            {

//            retMe = ETrue;

//            }

//        CleanupStack::PopAndDestroy( cdmaRecord );

//        }

    else

        {

        retMe = ETrue;

        }

    IRLOG_INFO3( "CIRFilteredApReader::FilterWAPOnlyL - Returning %d for %S", retMe, &iIapRecord->iRecordName.GetL() );    

    return retMe; 

    }

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

// CIRFilteredApReader::FilterEasyWlanL

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

//

TBool CIRFilteredApReader::FilterEasyWlanL() const

    {

    IRLOG_DEBUG( "CIRFilteredApReader::FilterEasyWlanL - Entering" );    

    TBool retMe( EFalse );

    if ( iIapRecord->iRecordName.GetL().Compare( KEasyWLAN ) != 0 )

        {

        retMe = ETrue;

        }

    IRLOG_INFO3( "CIRFilteredApReader::FilterEasyWlanL - Returning %d for %S", retMe, &iIapRecord->iRecordName.GetL() );    

    return retMe;

    }