/* 
 *
 * 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 "hfpcommand.h"
#include "debug.h"

TATParam::TATParam( const TDesC8& aValue )
    {
    if ( aValue.Length() <= KHsHFPMaxATParamSize )
        {
        iValue.Copy( aValue );
        }
    }

const TDesC8& TATParam::Des() const
    {
    return iValue;
    }

TInt TATParam::IntL() const
    {
    TRACE_FUNC_ENTRY
    TLex8 lex( iValue );
    TInt res = KErrNotFound;
    User::LeaveIfError( lex.Val( res ) );

    TRACE_FUNC_EXIT
    return res;

    }

CHsHFPCommand* CHsHFPCommand::NewL()
    {
    CHsHFPCommand *self = CHsHFPCommand::NewLC();
    CleanupStack::Pop( self );

    return self;
    }

CHsHFPCommand* CHsHFPCommand::NewLC()
    {

    CHsHFPCommand *self = new ( ELeave ) CHsHFPCommand();
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

CHsHFPCommand::~CHsHFPCommand()
    {
    TRACE_FUNC_ENTRY
    iParams.Close();
    iModeDes.Close();
    iParamsDes.Close();
    iTypeDes.Close();
    TRACE_FUNC_EXIT
    }

TInt CHsHFPCommand::SetType( const THsHFPCommandType aType )
    {
    TRACE_FUNC_ENTRY
    iType = aType;

    switch ( iType )
        {
        case EHFPCmdOK:
            iTypeDes.Copy( KHsHFPOKCommand );
            break;
        case EHFPCmdERROR:
            iTypeDes.Copy( KHsHFPERRORCommand );
            break;
        case EHFPCmdBRSF:
            iTypeDes.Copy( KHsHFPBRSFCommand );
            break;
        case EHFPCmdCIND:
            iTypeDes.Copy( KHsHFPCINDCommand );
            break;
        case EHFPCmdCMER:
            iTypeDes.Copy( KHsHFPCMERCommand );
            break;
        case EHFPCmdCIEV:
            iTypeDes.Copy( KHsHFPCIEVCommand );
            break;
        case EHFPCmdCHUP:
            iTypeDes.Copy( KHsHFPCHUPCommand );
            break;
        case EHFPCmdCOPS:
            iTypeDes.Copy( KHsHFPCOPSCommand );
            break;
        case EHFPCmdRING:
            iTypeDes.Copy( KHsHFPRINGCommand );
            break;
        case EHFPCmdATA:
            iTypeDes.Copy( KHsHFPATACommandWithoutPrefix );
            break;
        case EHFPCmdVGS:
            iTypeDes.Copy( KHsHFPVGSCommand );
            break;
        case EHFPCmdVGM:
            iTypeDes.Copy( KHsHFPVGMCommand );
            break;
        case EHFPCmdBLDN:
            iTypeDes.Copy( KHsHFPBLDNCommand );
            break;
        case EHFPCmdATD:
            iTypeDes.Copy( KHsHFPATDCommandWithoutPrefix );
            break;
        case EHFPCmdCLIP:
            iTypeDes.Copy( KHsHFPCLIPCommand );
            break;
        default:
            TRACE_FUNC_EXIT
            return KErrArgument;
        }
    TRACE_FUNC_EXIT
    return KErrNone;
    }

TInt CHsHFPCommand::SetMode( const THsHFPCommandMode aMode )
    {
    TRACE_FUNC_ENTRY
    iMode = aMode;
    switch ( iMode )
        {
        case ECmdModeRead:
            iModeDes.Copy( KHsHFPATReadModeDes );
            break;
        case ECmdModeWrite:
            iModeDes.Copy( KHsHFPATWriteModeDes );
            break;
        case ECmdModeTest:
            iModeDes.Copy( KHsHFPATTestModeDes );
            break;
        case ECmdModeNormal:
            iModeDes.Copy( KNullDesC8 );
            break;
        case ECmdModeOther:
            iModeDes.Copy( KNullDesC8 );
            break;
        default:
            TRACE_FUNC_EXIT
            return KErrArgument;
        }
    TRACE_FUNC_EXIT
    return KErrNone;
    }

TInt CHsHFPCommand::SetParams( const RATParamArray& aParams )
    {
    TRACE_FUNC_ENTRY
    TInt res = KErrNone;
    
    if ( aParams.Count() > 0 )
        {
        iParams.Reset();
        iParams = aParams;
        iParamsDes.Zero();

        for ( TInt i = 0; i < iParams.Count() - 1; i++ )
            {
            iParamsDes.Append( iParams[i].Des() );
            iParamsDes.Append( KHsHFPParamsSeparator );
            }

        iParamsDes.Append( iParams[iParams.Count() - 1].Des() );
        }
    TRACE_FUNC_EXIT
    return res;
    }

void CHsHFPCommand::SetSource( const TBool aFromAG )
    {
    iFromAG = aFromAG;
    }

void CHsHFPCommand::ToDes8( TDes8& aBuf ) const
    {
    TRACE_FUNC_ENTRY
    if ( iMode == ECmdModeNormal )
        {
        aBuf.Copy( KHsHFPCommandPrefix );
        aBuf.Append( iTypeDes );
        aBuf.Append( KHsHFPCommandSuffix );
        }

    else if ( iType != EHFPCmdUnknown )
        {
        aBuf.Copy( KHsHFPCommandPrefix );
        aBuf.Append( iTypeDes );
        aBuf.Append( iModeDes );
        aBuf.Append( iParamsDes );
        aBuf.Append( KHsHFPCommandSuffix );
        }
    else
        {
        aBuf.Zero();
        }

    TRACE_INFO((_L8("Command to des: %S"),&aBuf));
    TRACE_FUNC_EXIT
    }

THsHFPCommandType CHsHFPCommand::Type() const
    {
    return iType;
    }

THsHFPCommandMode CHsHFPCommand::Mode() const
    {
    return iMode;
    }

TBool CHsHFPCommand::FromAG() const
    {
    return iFromAG;
    }

const RATParamArray& CHsHFPCommand::Params() const
    {
    return iParams;
    }

void CHsHFPCommand::CopyL( const CHsHFPCommand& aCmdFrom, CHsHFPCommand& aCmdTo )
    {
    TRACE_STATIC_FUNC_ENTRY
    aCmdTo.iMode = aCmdFrom.iMode;
    aCmdTo.iType = aCmdFrom.iType;

    aCmdTo.iParams.Reset();
    for ( TInt i = 0; i < aCmdFrom.iParams.Count(); i++ )
        {
        aCmdTo.iParams.AppendL( aCmdFrom.iParams[i] );
        }

    aCmdTo.iFromAG = aCmdFrom.iFromAG;

    aCmdTo.iModeDes.Copy( aCmdFrom.iModeDes );
    aCmdTo.iTypeDes.Copy( aCmdFrom.iTypeDes );
    aCmdTo.iParamsDes.Copy( aCmdFrom.iParamsDes );
    TRACE_FUNC_EXIT
    }

CHsHFPCommand::CHsHFPCommand() :
    iType( EHFPCmdUnknown ), iParams( KParamArrayGranularity )
    {

    }

void CHsHFPCommand::ConstructL()
    {
    TRACE_FUNC_ENTRY
    iModeDes.CreateL( KModeDesMaxLength );
    iTypeDes.CreateL( KTypeDesMaxLength );
    iParamsDes.CreateL( KParamsDesMaxLength );
    TRACE_FUNC_EXIT
    }