/*

* Copyright (c) 2004 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 the class CProcessorBase

*

*/

// INCLUDE FILES

#include "cdcprocessorbase.h"

#include "cdcreaderbase.h"

#include "cdclogger.h"

#include <cmmanagerext.h>

#include <cmconnectionmethoddef.h>

#include <cmconnectionmethodext.h>

#include <cmdestinationext.h>

#include <datamobilitycommsdattypes.h>

using namespace CMManager;

// ================= MEMBER FUNCTIONS =======================

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

// CProcessorBase::CProcessorBase

// Constructor.

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

//

CProcessorBase::CProcessorBase( CReaderBase* aFileReader,

                                RCmManagerExt& aCmManager,

                                RPointerArray< RCmConnectionMethodExt >& aPluginArray,

                                RPointerArray< HBufC >& aPluginNames ) :

        iFileReader( aFileReader ), 

        iProxyEnabled( EFalse ),

        iIsProtected( EFalse )

    {

    iCmManager = &aCmManager;

    iPluginArray = &aPluginArray;

    iPluginName = &aPluginNames;

    }

CProcessorBase::CProcessorBase( CReaderBase* aFileReader,

                        RCmManagerExt& aCmManager,

                        RPointerArray< RCmConnectionMethodExt >& aPluginArray,

                        RPointerArray< HBufC >& aPluginNames,

                        RPointerArray< RCmDestinationExt >& aDestArray,

                        RPointerArray< HBufC >& aDestNames ) :

        iFileReader( aFileReader ), 

        iProxyEnabled( EFalse ),

        iIsProtected( EFalse )

    {

    iCmManager = &aCmManager;

    iPluginArray = &aPluginArray;

    iPluginName = &aPluginNames;

    iDestArray = &aDestArray;

    iDestName = &aDestNames;

    }

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

// CProcessorBase::~CProcessorBase

// Destructor.

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

//

CProcessorBase::~CProcessorBase()

    {

    iPlugin.Close();

    if( iName )

        {

        delete iName;

        }

    }

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

// CProcessorBase::ParseFileL

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

//

//PseudoCode:

// 0010 locates the next access point within the text file

// 0020 parses the location and reads the input data to TagContainer

// 0030 from TagContainer creates Access Point Item Object

// 0040 using the Access Point Item Object creates a new AP record in CommsDat

// 0050 clears TagContainer

//

void CProcessorBase::ParseFileL()

    {

    //LocateAP : locates the access points within the text file

    while ( iFileReader->LocateAPL() )

        {

        //ParseAPL : parses the location, reads the input data to TagContainer

        iFileReader->ParseAPL();

        //from TagContainer creates Access Point Item Object

        ProcessTagL( iFileReader->FieldIDPresent() );

        //adds the Access Point Item Object to CommsDB

        ProcessAPL();

        //clear TagContainer

        TagContainer().Clear();

        }//while    

    CLOG_WRITE( "---------------------\n" )

    }

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

// CProcessorPacketData::ProcessTagL

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

//

void CProcessorBase::ProcessTagL( TBool /*aFieldIDPresent*/ )

    {

    iProxyEnabled= EFalse;

    iIsProtected = EFalse;

    Reset();

    TInt aCMId = -1;

    for ( TInt idx(0); idx < TagContainer().Count(); idx++)

        {

        if ( TagContainer().FieldId( idx ) == ECmId)

            {

            HBufC16* ptrTag = TagContainer().Tag(idx);

            TLex16 lex(ptrTag->Des());

            TInt err = lex.Val(aCMId);

            if (err != KErrNone)

                {

                User::Leave(err);    

                }

            break;

            }

        }

    if (aCMId == -1)

        {

        iPlugin = iCmManager->CreateConnectionMethodL( iBearerType );        

        CLOG_WRITE( "ConnectionMethod created without ECmId.");

        }

    else

        {

        iPlugin = iCmManager->CreateConnectionMethodL( iBearerType, aCMId);        

        CLOG_WRITE_FORMAT( "ConnectionMethod created. ECmId:%d", aCMId);

        }

    for ( TInt idx(0); idx < TagContainer().Count(); idx++)

        {

        HBufC16* ptrTag = TagContainer().Tag(idx);

        TInt field =  TagContainer().FieldId( idx );

        TBool processed = SetGeneralFieldL( field, ptrTag );

        if( !processed )

            {

            ProcessSpecialFieldsL( field, ptrTag, idx );

            }

        }

    AddToPluginArrayL();

    }

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

// CProcessorBase::TagContainer()

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

CTagContainer& CProcessorBase::TagContainer()

    {

    return iFileReader->TagContainer();    

    }

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

// CProcessorBase::AddToPluginArrayL()

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

void CProcessorBase::AddToPluginArrayL()

    {

    if( !iName )

        {

        CLOG_WRITE( "Error: No plugin name !!!" )

        }    

    else

        {

        const RCmConnectionMethodExt* newItem = new (ELeave) 

                RCmConnectionMethodExt( iPlugin );

        iPluginArray->Append( newItem );

        iPluginName->Append( iName->AllocL() );

        delete iName;

        iName = NULL;

        iPlugin.Close();

        }

    }

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

// CProcessorBase::GetLastPluginL()

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

RCmConnectionMethodExt& CProcessorBase::GetLastPluginL()

    {

    return GetPluginL( PluginCount() - 1 );

    }    

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

// CProcessorBase::GetPluginL()

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

RCmConnectionMethodExt& CProcessorBase::GetPluginL( TInt aPos )

    {

    return *(iPluginArray->operator[]( aPos ));

    }    

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

// CProcessorBase::PluginCount()

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

TInt CProcessorBase::PluginCount()

    {

    return iPluginArray->Count();

    }    

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

// CProcessorBase::FindDestinationL

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

//

RCmDestinationExt* CProcessorBase::FindDestinationL( HBufC* aName )

    {

    for( TInt i(0); i < iDestName->Count(); i++ )

        {

        HBufC *name = (*iDestName)[i];

        if( aName->Compare( *name  ) == 0 )

            {

            return (*iDestArray)[ i ];

            }

        }

    CLOG_WRITE_FORMAT("Warning: Destination not found: %S", aName );

    return NULL;

    }

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

// CProcessorBase::GetDestinationIdL

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

//

TInt CProcessorBase::GetDestinationIdL( HBufC16* aName )

    {

    RCmDestinationExt* dest = FindDestinationL( aName );

    TInt ret( KErrNotFound );

    if( dest != NULL )

        {

        ret = dest->Id();

        }

    return ret;    

    }

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

// CProcessorBase::FindPluginL

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

// 

RCmConnectionMethodExt* CProcessorBase::FindPluginL( HBufC* aName )

    {

    TInt pos;

    return FindPluginL( aName, pos );

    } 

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

// CProcessorBase::FindPluginL

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

//

RCmConnectionMethodExt* CProcessorBase::FindPluginL( HBufC* aName, TInt& aPos )

    {

    RCmConnectionMethodExt* ret( NULL );

    aPos = CheckPluginName( aName );

    if ( aPos != KErrNotFound )

        {

        ret = (*iPluginArray)[ aPos ];

        }

    else

        {

        CLOG_WRITE_FORMAT("Warning: Connection method not found: %S", aName );

        }

    return ret;

    }

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

// CProcessorBase::CheckPluginName

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

//

TInt CProcessorBase::CheckPluginName( HBufC* aName )

    {

    TInt ret( KErrNotFound );

    for( TInt i = 0; i < iPluginName->Count() && ret == KErrNotFound; i++ )

        {

        HBufC *name = (*iPluginName)[i];

        if( aName->Compare( *name  ) == 0 )

            {

            ret = i;

            }

        }

    return ret;

    }

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

// CProcessorBase::GetPluginIdL

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

//

TInt CProcessorBase::GetPluginIdL( HBufC16* aName )

    {

    RCmConnectionMethodExt* cm = FindPluginL( aName );

    TInt ret( KErrNotFound );

    if( cm != NULL )

        {

        ret = cm->GetIntAttributeL( CMManager::ECmIapId );

        }

    return ret;    

    }

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

// CProcessorBase::ProcessAPL

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

//

void CProcessorBase::ProcessAPL()

    {

    RCmConnectionMethodExt& plugin = GetLastPluginL();

    if( iIsProtected )

        {

        plugin.SetBoolAttributeL( ECmProtected, ETrue );

        }

    // Writes into the log file.

    DoLogL();

    }

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

// CProcessorBase::ProcessAPL

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

//

TBool CProcessorBase::SetGeneralFieldL( TInt aField, HBufC* aPtrTag )

    {

    TBool processed( ETrue );

    switch( aField )

        {

        case ECmName:     

            {

            // If input is not empty

            if ( aPtrTag->CompareF( KStrEmpty ) != 0 )

                {

                TInt pos = CheckPluginName( aPtrTag );

                if( pos != KErrNotFound )

                    {

                    CLOG_WRITE_FORMAT("Warning: plugin exist. It might be renamed ! : %S", aPtrTag );

                    }

                iPlugin.SetStringAttributeL( aField, *aPtrTag );

                if( !iName )

                    {

                    iName = aPtrTag->AllocL();

                    }

                }

            break;

            }

        case ECmStartPage:

            {

            // If input is not empty

            if ( aPtrTag->CompareF( KStrEmpty ) != 0 )

                {

                iPlugin.SetStringAttributeL( aField, *aPtrTag );

                }

            break;

            }

        case ECmHidden:              //fall through

        case ECmMetaHiddenAgent:     //fall through

        case ECmMetaHighlight:       //fall through

            {

            if( aPtrTag->CompareF( KStrNo ) == 0 )

                {

                iPlugin.SetBoolAttributeL( aField, EFalse );

                }

            else if( aPtrTag->CompareF( KStrYes ) == 0 )

                {

                iPlugin.SetBoolAttributeL( aField, ETrue );

                }

            else

                {

                iPlugin.SetBoolAttributeL( aField, EFalse );

                switch ( aField )

                    {

                    case ECmHidden:

                        CLOG_WRITE( "! Error : Invalid Hidden. Default:No");

                        break;

                    case ECmMetaHiddenAgent:

                        CLOG_WRITE( "! Error : Invalid HiddenAgent. Default:No");

                        break;

                    case ECmMetaHighlight:

                        CLOG_WRITE( "! Error : Invalid Highlight. Default:No");

                        break;

                    }

                }

            break;

            }

        case ECmSeamlessnessLevel:

            {

            if ( aPtrTag->CompareF( KStrNotRoamedTo ) == 0 )

                {

                iPlugin.SetIntAttributeL( aField,

                                        CMManager::ESeamlessnessNotRoamedTo );

                }

            else if ( aPtrTag->CompareF( KStrConfirmFirst ) == 0 )

                {

                iPlugin.SetIntAttributeL( aField,

                                        CMManager::ESeamlessnessConfirmFirst );

                }

            else if ( aPtrTag->CompareF( KStrShowProgress ) == 0 )

                {

                iPlugin.SetIntAttributeL( aField,

                                        CMManager::ESeamlessnessShowprogress );

                }

            else if ( aPtrTag->CompareF( KStrFullySeamless ) == 0 )

                {

                iPlugin.SetIntAttributeL( aField,

                                        CMManager::ESeamlessnessFullySeamless );

                }

            break;

            }

        case ECmProtected:

            {

            // Protection

            if ( aPtrTag->CompareF( KStrYes ) == 0 )

                {

                iIsProtected = ETrue;

                }

            else if ( aPtrTag->CompareF( KStrNo ) != 0 )

                {

                CLOG_WRITE( "! Error : Invalid Protected value. Default:No" )

                }

            break;

            }

        default:

            {

            processed = EFalse;

            }        

        }

    return processed;

    }

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

// CProcessorBase::DoLogL

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

//

void CProcessorBase::DoLogL()

    {

    TInt lastPos = iPluginArray->Count() - 1;

    CLOG_WRITE( "Internet Access Point created:" )

    CLOG_WRITE_FORMAT( "\t Connection name: %S ", (*iPluginName)[ lastPos ] );

    if ( iIsProtected )

        {

        CLOG_WRITE( "\t Protected" )

        }

    else

        {

        CLOG_WRITE( "\t Not protected" )

        }

    }

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

// CProcessorBase::SetAddressFromServerL

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

//

void CProcessorBase::SetAddressFromServerL( TInt aIPField1, 

                                           TInt aIPField2, 

                                           TInt aAddrFromSField,

                                           TInt aIPField1IP6,

                                           TInt aIPField2IP6,

                                           TInt aAddrFromSFieldIP6 )

    {

        //calculate and set Ip6AddrFromServer

        HBufC *pIp1 = NULL;        

        HBufC *pIp2 = NULL;        

        pIp1 = iPlugin.GetStringAttributeL( aIPField1IP6 );

        CleanupStack::PushL( pIp1 );

        pIp2 = iPlugin.GetStringAttributeL( aIPField2IP6 );

        CleanupStack::PushL( pIp2 );

        _LIT( KDynIpv6Address, "0:0:0:0:0:0:0:0" );

        if ( ( pIp1->Compare( KDynIpv6Address ) == 0 ) &&

             ( pIp2->Compare( KDynIpv6Address ) == 0 ) )

            {

            iPlugin.SetBoolAttributeL( aAddrFromSFieldIP6, ETrue );

            }

        else

            {

            iPlugin.SetBoolAttributeL( aAddrFromSFieldIP6, EFalse );

            }

        CleanupStack::PopAndDestroy( 2,pIp1 );