/* 

 *

 * 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 "hfpcommandparser.h"

#include "badesca.h"

#include "debug.h"

CHsHFPParser* CHsHFPParser::NewL()

    {

    CHsHFPParser *self = CHsHFPParser::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

CHsHFPParser* CHsHFPParser::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

CHsHFPParser::~CHsHFPParser()

    {

    }

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

        CHsHFPCommand& aCommand )

    {

    TRACE_FUNC_ENTRY

    aCommand.SetSource( aFromAG );

    THsHFPCommandType type = EHFPCmdUnknown;

    type = RetrieveTypeL( aBufCommand );

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

    if ( type == EHFPCmdOK || type == EHFPCmdERROR || type == EHFPCmdCHUP

            || type == EHFPCmdRING || type == EHFPCmdATA || type == EHFPCmdBLDN )

        {

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

        RATParamArray params( 1 );

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

        }

    else if ( type == EHFPCmdATD )

        {

        aCommand.SetMode( ECmdModeOther );

        RBuf8 buf;

        buf.CreateL( aBufCommand );

        buf.CleanupClosePushL();

        buf.Delete( 0, KHsHFPATDCommand().Size() );

        buf.Delete( buf.Size() - KHsHFPCommandSuffix().Size(), KHsHFPCommandSuffix().Size() );

        RATParamArray params;

        params.AppendL( TATParam( buf ) );

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

        CleanupStack::PopAndDestroy( &buf );

        }

    else

        {

        THsHFPCommandMode 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

    }

CHsHFPParser::CHsHFPParser()

    {

    }

void CHsHFPParser::ConstructL()

    {

    }

THsHFPCommandMode CHsHFPParser::RetrieveModeL( const TDesC8 &aCommand,

        const TBool aFromAG )

    {

    TRACE_FUNC_ENTRY

    THsHFPCommandMode res = ECmdUnknownMode;

    if ( aFromAG )

        {

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

            {

            res = ECmdModeTest;

            }

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

            {

            res = ECmdModeRead;

            }

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

            {

            res = ECmdModeWrite;

            }

        }

    else

        {

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

            {

            res = ECmdModeTest;

            }

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

            {

            res = ECmdModeRead;

            }

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

            {

            res = ECmdModeWrite;

            }

        }

    if ( res == ECmdUnknownMode )

        {

        User::Leave( KErrArgument );

        }

    TRACE_FUNC_EXIT

    return res;

    }

THsHFPCommandType CHsHFPParser::RetrieveTypeL( const TDesC8 &aCommand )

    {

    TRACE_FUNC_ENTRY

    THsHFPCommandType res = EHFPCmdUnknown;

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

        {

        res = EHFPCmdBRSF;

        }

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

        {

        res = EHFPCmdCHUP;

        }

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

        {

        res = EHFPCmdCIEV;

        }

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

        {

        res = EHFPCmdOK;

        }

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

        {

        res = EHFPCmdERROR;

        }

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

        {

        res = EHFPCmdCIND;

        }

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

        {

        res = EHFPCmdCMER;

        }

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

        {

        res = EHFPCmdCOPS;

        }

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

        {

        res = EHFPCmdRING;

        }

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

        {

        res = EHFPCmdATA;

        }

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

        {

        res = EHFPCmdVGS;

        }

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

        {

        res = EHFPCmdVGM;

        }

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

        {

        res = EHFPCmdBLDN;

        }

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

        {

        res = EHFPCmdATD;

        }

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

        {

        res = EHFPCmdCLIP;

        }

    if ( res == EHFPCmdUnknown )

        User::Leave( KErrArgument );

    TRACE_FUNC_EXIT

    return res;

    }

void CHsHFPParser::RetrieveParamsL( const TDesC8 &aCommand,

        const THsHFPCommandMode 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( KHsHFPIndicatorParamsSeparator ) != 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( KHsHFPATTestModeDes );

                modeLength = 2;

                }

                break;

            case ECmdModeRead:

                {

                startPos = buf.Find( KHsHFPATReadModeDes );

                modeLength = 1;

                }

                break;

            case ECmdModeWrite:

                {

                startPos = buf.Find( KHsHFPATWriteModeDes );

                modeLength = 1;

                if ( startPos == KErrNotFound )

                    {

                    startPos = buf.Find( KHsHFPATWriteModeDesAG );

                    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( KHsHFPIndicatorParamsSeparator );

            }

        else

            {

            pos = buf.Find( KHsHFPParamsSeparator );

            }

        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

    }