/*

* Copyright (c) 2003, 2004 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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 CWhiteListConverter.

*

*/

// INCLUDE FILES

#include "WhiteListImporter.h"

#include "PushMtmSettings.h"

#include "PushInitiatorList.h"

#include "PushInitiator.h"

#include "PushMtmLog.h"

#include <e32std.h>

// CONSTANTS

/// Max length allowed.

LOCAL_C const TInt KMaxLength = 2048;

/*

* Special characters.

*/

/// ',' character.

LOCAL_C const TUint KComma = ',';

/// ';' character.

LOCAL_C const TUint KSemicolon = ';';

/// Escape '\' character.

LOCAL_C const TUint KEscape = '\\';

/*

* Characters considered as EOS.

*/

/// '\r' character.

LOCAL_C const TUint KCr = '\r';

/// '\n' character.

LOCAL_C const TUint KLf = '\n';

/*

* Separator characters.

*/

/// End-Of-String (0) character. It is a separator.

LOCAL_C const TUint KEos = 0;

/// Record separator (30) character.

LOCAL_C const TUint KRecordSeparator = 30;

/// Unit separator (31) character.

LOCAL_C const TUint KUnitSeparator = 31;

/*

* Keywords.

*/

/// "Ipv4" keyword.

_LIT( KIpv4, "Ipv4" );

/// "Ipv6" keyword.

_LIT( KIpv6, "Ipv6" );

/// "E164" keyword.

_LIT( KE164, "E164" );

/// "Alpha" keyword.

_LIT( KAlpha, "Alpha" );

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

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

// CWhiteListConverter::NewL

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

//

CWhiteListConverter* CWhiteListConverter::NewL( CPushInitiatorList& aPushInitiatorList )

    {

    CWhiteListConverter* converter = 

        new (ELeave) CWhiteListConverter( aPushInitiatorList );

    CleanupStack::PushL( converter );

    converter->ConstructL();

    CleanupStack::Pop( converter );    // converter

    return converter;

    }

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

// CWhiteListConverter::~CWhiteListConverter

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

//

CWhiteListConverter::~CWhiteListConverter()

    {

    delete iConverterBuf;

    delete iBuf;

    iNextCh = NULL; // Only used.

    iMaxCh = NULL; // Only used.

    }

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

// CWhiteListConverter::Buffer2ListL

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

//

void CWhiteListConverter::Buffer2ListL( const TDesC& aSource )

    {

    PUSHLOG_ENTERFN("CWhiteListConverter::Buffer2ListL");

    iSource.Assign( aSource );

    iCurCh = KRecordSeparator; // Cannot be 0, because of GetChar()

    GetChar();

    while( NextLineL() )

        {

        };

    PUSHLOG_LEAVEFN("CWhiteListConverter::Buffer2ListL");

    }

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

// CWhiteListConverter::List2BufferL

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

//

HBufC* CWhiteListConverter::List2BufferL()

    {

    PUSHLOG_ENTERFN("CWhiteListConverter::List2BufferL");

    HBufC* newConverterBuf = KNullDesC().AllocL(); // initial zero length buffer

    delete iConverterBuf;

    iConverterBuf = newConverterBuf;

    TPtr writableConvBuf = iConverterBuf->Des();

    writableConvBuf.SetLength(0);

    TInt itemsToExport = iPushInitiatorList.Count();

    // temp buffers

    TBuf<16> type;

    TBuf<16> entryId;

    for ( TInt i=0; i < itemsToExport; ++i )

        {

        CPushInitiator& curr = iPushInitiatorList.At(i);

        switch ( curr.Type() )

            {

            case CPushInitiator::ETypeIpv4: type=KIpv4; break;

            case CPushInitiator::ETypeIpv6: type=KIpv6; break;

            case CPushInitiator::ETypeE164: type=KE164; break;

            case CPushInitiator::ETypeAlpha: type=KAlpha; break;

            default: type=KE164; break;

            }

        entryId.Format( _L("%d"), curr.EntryID() );

        // check available space

        // 3 is required for 2 commas and 1 semicolon.

        TInt newItemLength = curr.Addr().Length()+type.Length()+entryId.Length()+3;

        if ( writableConvBuf.MaxLength() < writableConvBuf.Length() + newItemLength )

            {

            // reallocate a greater buffer

            TInt currentMaxLength = writableConvBuf.MaxLength();

            iConverterBuf = iConverterBuf->ReAllocL( currentMaxLength + newItemLength );

            writableConvBuf.Set( iConverterBuf->Des() ); // re-initialize

            }

        writableConvBuf.Append( curr.Addr() );

        writableConvBuf.Append( TChar(KComma) );

        writableConvBuf.Append( type );

        writableConvBuf.Append( TChar(KComma) );

        writableConvBuf.Append( entryId );

        if ( i+1 < itemsToExport )

            {

            // there are still items to add

            writableConvBuf.Append( TChar(KSemicolon) );

            }

        }

    HBufC* ret = iConverterBuf; // ownersip is transferred to the caller.

    iConverterBuf = 0;

    PUSHLOG_LEAVEFN("CWhiteListConverter::List2BufferL");

    return ret;

    }

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

// CWhiteListConverter::CWhiteListConverter

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

//

CWhiteListConverter::CWhiteListConverter( CPushInitiatorList& aPushInitiatorList ) 

:   iPushInitiatorList( aPushInitiatorList )

    {

    }

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

// CWhiteListConverter::ConstructL

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

//

void CWhiteListConverter::ConstructL()

    {

    iBuf = new (ELeave) TText[KMaxLength];

    iMaxCh = iBuf + KMaxLength;

    }

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

// CWhiteListConverter::GetChar

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

//

inline void CWhiteListConverter::GetChar()

    {

    // Do not continue if we already reached EOS:

    if ( iCurCh == KEos )

        {

        return;

        }

    iCurCh = iSource.Get();

    if ( iCurCh == KCr || iCurCh == KLf )

        {

        // They are considered as EOS.

        iCurCh = KEos;

        }

    else if ( iCurCh == KEscape )

        {

        // Drop the Escape character and get the next as is.

        iCurCh = iSource.Get();

        }

    else if ( iCurCh == KComma )

        {

        // It is a Unit Separator.

        iCurCh = KUnitSeparator;

        }

    else if ( iCurCh == KSemicolon )

        {

        // It is a Record Separator.

        iCurCh = KRecordSeparator;

        }

    }

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

// CWhiteListConverter::NextLineL

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

//

TBool CWhiteListConverter::NextLineL()

    {

    switch( iCurCh )

        {

        case KEos:

            // EOS

            return EFalse;

        default:

            // Parse White List attributes and process them.

            AttrsL();

            break;

        }

    return ETrue;

    }

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

// CWhiteListConverter::NextTokenL

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

//

TPtrC CWhiteListConverter::NextTokenL( TUint aStopChar )

    {

    iNextCh = iBuf; // Start storing token at start of buffer.

    while ( iNextCh < iMaxCh )

        {

        if ( iCurCh == aStopChar || iCurCh == KEos )

            {

            // Stop character found - return what we have stored so far. 

            // This may be an empty string as well.

            return TPtrC( iBuf, iNextCh - iBuf );

            }

        else

            {

            *iNextCh = STATIC_CAST( TText16, iCurCh );

            iNextCh++;

            GetChar();

            }

        }

    // No more space in buffer to store token.

    User::Leave( KErrOverflow );

    /*NOTREACHED*/

    return TPtrC();

    }

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

// CWhiteListConverter::AttrsL

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

//

void CWhiteListConverter::AttrsL()

    {

    CPushInitiator* newInitiator = new (ELeave) CPushInitiator;

    CleanupStack::PushL( newInitiator );

    TPtrC token;

    // Address.

    token.Set( NextTokenL( KUnitSeparator ) );

    HBufC* address = token.AllocLC(); // Copy the token to a separate area.

    GetChar();

    // Address type and/or entry ID.

    token.Set( NextTokenL( KRecordSeparator ) );

    HBufC* addressTypeBuf = 0;

    HBufC* entryIdBuf = 0;

    // check if it contains an entry ID separated with a comma (KUnitSeparator)

    TInt offset = token.Locate( TChar(KUnitSeparator) );

    if ( offset == KErrNotFound )

        {

        // the whole token is address type

        addressTypeBuf = token.AllocLC(); // Copy the token to a separate area.

        entryIdBuf = 0;

        }

    else

        {

        addressTypeBuf = token.Mid(0,offset).AllocLC();

        TInt tokenLength = token.Length();

        entryIdBuf = token.Mid((offset+1),tokenLength-(offset+1)).AllocLC();

        }

    // Convert the address type string to enum.

    // addressTypeBuf must not be NULL.

    CPushInitiator::TAddrType addrType = CPushInitiator::ETypeE164;

    if      ( !(*addressTypeBuf).Compare( KIpv4 ) )

        {

        addrType = CPushInitiator::ETypeIpv4;

        }

    else if ( !(*addressTypeBuf).Compare( KIpv6 ) )

        {

        addrType = CPushInitiator::ETypeIpv6;

        }

    else if ( !(*addressTypeBuf).Compare( KE164 ) )

        {

        addrType = CPushInitiator::ETypeE164;

        }

    else if ( !(*addressTypeBuf).Compare( KAlpha ) )

        {

        addrType = CPushInitiator::ETypeAlpha;

        }

    else

        {

        User::Leave( KErrCorrupt );

        }

    PUSHLOG_WRITE_FORMAT2("WL Importer: <%S> <%S>",&(address->Des()),

                                                   &(addressTypeBuf->Des()));

    TUint32 entryId(0);

    if ( entryIdBuf )

        {

        PUSHLOG_WRITE_FORMAT("WL Importer entryIdBuf: <%S>",&(entryIdBuf->Des()));

        TLex lex( *entryIdBuf );

        lex.Val( entryId, EDecimal );

        CleanupStack::PopAndDestroy( entryIdBuf ); // entryIdBuf

        }

    GetChar();

    // No more attribute to parse.

    // Add the new initiator data to the Push settings.

    newInitiator->SetAddressL( *address, addrType );

    newInitiator->SetEntryID( entryId );

    CleanupStack::PopAndDestroy( 2, address ); // addressTypeBuf, address

    iPushInitiatorList.AddL( newInitiator );

    CleanupStack::Pop( newInitiator ); // newInitiator

    }