/* 

 *

 * Copyright (c) <2010> Comarch S.A. 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".

 *

 * Original Contributors:

 * Comarch S.A. - original contribution.

 *

 * Contributors:

 *

 * Description:

 *

 */

#include <badesca.h>

#include "hspcommandparser.h"

#include "debug.h"

CHsHSPParser* CHsHSPParser::NewL()

    {

    CHsHSPParser *self = CHsHSPParser::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

CHsHSPParser* CHsHSPParser::NewLC()

    {

    CHsHSPParser *self = new ( ELeave ) CHsHSPParser();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

CHsHSPParser::~CHsHSPParser()

    {

    }

void CHsHSPParser::ParseL( const TDesC8& aBufCommand, const TBool aFromAG,

        CHsHSPCommand& aCommand )

    {

    TRACE_FUNC_ENTRY

    aCommand.SetSource( aFromAG );

    THsHSPCommandType type = EHSPCmdUnknown;

    type = RetrieveTypeL( aBufCommand );

    User::LeaveIfError( aCommand.SetType( type ) );

    if ( type == EHSPCmdOK || type == EHSPCmdERROR || type == EHSPCmdRING )

        {

        User::LeaveIfError( aCommand.SetMode( ECmdModeNormal ) );

        RATParamArray params( 1 );

        User::LeaveIfError( aCommand.SetParams( params ) );

        }

    else

        {

        THsHSPCommandMode mode = ECmdUnknownMode;

        mode = RetrieveModeL( aBufCommand, aFromAG );

        User::LeaveIfError( aCommand.SetMode( mode ) );

        RATParamArray params( 4 );

        RetrieveParamsL( aBufCommand, mode, params );

        User::LeaveIfError( aCommand.SetParams( params ) );

        }

    TRACE_FUNC_EXIT

    }

CHsHSPParser::CHsHSPParser()

    {

    }

void CHsHSPParser::ConstructL()

    {

    }

THsHSPCommandMode CHsHSPParser::RetrieveModeL( const TDesC8 &aCommand,

        const TBool aFromAG )

    {

    TRACE_FUNC_ENTRY

    THsHSPCommandMode res = ECmdUnknownMode;

    if ( aFromAG )

        {

        if ( aCommand.Find( KHsHSPATTestModeDesAG ) != KErrNotFound )

            {

            res = ECmdModeTest;

            }

        else if ( aCommand.Find( KHsHSPATReadModeDesAG ) != KErrNotFound )

            {

            res = ECmdModeRead;

            }

        else if ( aCommand.Find( KHsHSPATWriteModeDesAG ) != KErrNotFound )

            {

            res = ECmdModeWrite;

            }

        }

    else

        {

        if ( aCommand.Find( KHsHSPATTestModeDes ) != KErrNotFound )

            {

            res = ECmdModeTest;

            }

        else if ( aCommand.Find( KHsHSPATReadModeDes ) != KErrNotFound )

            {

            res = ECmdModeRead;

            }

        else if ( aCommand.Find( KHsHSPATWriteModeDes ) != KErrNotFound )

            {

            res = ECmdModeWrite;

            }

        }

    if ( res == ECmdUnknownMode )

        {

        User::Leave( KErrArgument );

        }

    TRACE_FUNC_EXIT

    return res;

    }

THsHSPCommandType CHsHSPParser::RetrieveTypeL( const TDesC8 &aCommand )

    {

    TRACE_FUNC_ENTRY

    THsHSPCommandType res = EHSPCmdUnknown;

    if ( aCommand.Find( KHsHSPOKCommand ) != KErrNotFound )

        {

        res = EHSPCmdOK;

        }

    else if ( aCommand.Find( KHsHSPERRORCommand ) != KErrNotFound )

        {

        res = EHSPCmdERROR;

        }

    else if ( aCommand.Find( KHsHSPRINGCommand ) != KErrNotFound )

        {

        res = EHSPCmdRING;

        }

    else if ( aCommand.Find( KHsHSPVGSCommand ) != KErrNotFound )

        {

        res = EHSPCmdVGS;

        }

    else if ( aCommand.Find( KHsHSPVGMCommand ) != KErrNotFound )

        {

        res = EHSPCmdVGM;

        }

    else if ( aCommand.Find( KHsHSPCKPDCommand ) != KErrNotFound )

        {

        res = EHSPCmdCKPD;

        }

    if ( res == EHSPCmdUnknown )

        User::Leave( KErrArgument );

    TRACE_FUNC_EXIT

    return res;

    }

void CHsHSPParser::RetrieveParamsL( const TDesC8 &aCommand,

        const THsHSPCommandMode aCmdMode, RATParamArray& aParams )

    {

    TRACE_FUNC_ENTRY

    RBuf8 buf;

    buf.CreateL( aCommand );

    buf.CleanupClosePushL();

    TInt prefixLength = 0;

    TInt suffixLength = 0;

    TInt modeLength = 0;

    TInt leftOffset = 0;

    TInt rightOffset = 0;

    TInt startPos = 0;

    TBool indicatorsFound = EFalse;

    if ( buf.Find( KHsHSPIndicatorParamsSeparator ) != KErrNotFound )

        {

        indicatorsFound = ETrue;

        }

    if ( indicatorsFound )

        {

        prefixLength = 9;

        suffixLength = 2;

        rightOffset = 2;

        leftOffset = 1;

        }

    else

        {

        rightOffset = 1;

        suffixLength = 2;

        switch ( aCmdMode )

            {

            case ECmdModeTest:

                {

                startPos = buf.Find( KHsHSPATTestModeDes );

                modeLength = 2;

                }

                break;

            case ECmdModeRead:

                {

                startPos = buf.Find( KHsHSPATReadModeDes );

                modeLength = 1;

                }

                break;

            case ECmdModeWrite:

                {

                startPos = buf.Find( KHsHSPATWriteModeDes );

                modeLength = 1;

                if ( startPos == KErrNotFound )

                    {

                    startPos = buf.Find( KHsHSPATWriteModeDesAG );

                    modeLength = 2;

                    }

                }

                break;

            default:

                User::Leave( KErrArgument );

                break;

            }

        }

    if ( startPos != KErrNotFound )

        {

        //strip command's prefix

        buf.Delete( 0, prefixLength + startPos + modeLength );

        //strip command's suffix

        buf.Delete( buf.Length() - suffixLength, suffixLength );

        }

    else

        User::Leave( KErrArgument );

    while ( buf.Size() > 0 )

        {

        TInt pos = 0;

        if ( indicatorsFound )

            {

            pos = buf.Find( KHsHSPIndicatorParamsSeparator );

            }

        else

            {

            pos = buf.Find( KHsHSPParamsSeparator );

            }

        if ( pos == KErrNotFound )

            {

            aParams.AppendL( buf );

            buf.Zero();

            }

        else

            {

            TPtrC8 ptr = ( buf.Left( pos + leftOffset ) );

            aParams.AppendL( ptr );

            buf.Delete( 0, pos + rightOffset );

            }

        }

    CleanupStack::PopAndDestroy( &buf );

    TRACE_FUNC_EXIT

    }