/*

* Copyright (c) 2008-2008 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:  CCFCountOneShot class implementation.

*

*/

// INCLUDES

#include "cfcountoneshot.h"

#include "cfcontextoperationutils.h"

#include "cfbasicoptrace.h"

#include <cfcontextobject.h>

#include <gmxmlelement.h>

// CONSTANTS

_LIT( KScriptCountName,                "count"              );

_LIT( KScriptOneShotAtAttribute,       "oneShotAt"          );

_LIT( KScriptTypeAttribute,            "type"               );

_LIT( KScriptCountTypeRemainName,      "remain"             );

_LIT( KScriptCountTypeChangeName,      "change"             );

_LIT( KScriptCountTypeTriggerName,     "trigger"            );

_LIT( KScriptContextRefName,           "contextRef"         );

_LIT( KScriptPersistencyFileAttribute, "persistencyFile"    );

static const TInt KCountMinAttributes = 1;

static const TUint KInitialCount = 0;

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

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

// CCFCountOneShot::CCFCountOneShot

// C++ default constructor can NOT contain any code, that might leave.

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

//

CCFCountOneShot::CCFCountOneShot( MCFOperationServices& aServices,

    CCFOperationNode* aParent,

    HBufC* aName,

    HBufC* aSource,

    const CCFContextOperation::TCmpType aType,

    const TUint aCount,

    const TCountType aCountType )

    :   CCFCount( aServices, aParent, aName, aSource, aType, aCount,

            aCountType )

    {

    FUNC_LOG;

    }

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

// CCFCountOneShot::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CCFCountOneShot::ConstructL( const TDesC& aCmpVal )

    {

    FUNC_LOG;

    CCFCount::ConstructL( aCmpVal );

    }

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

// CCFCountOneShot::NewL

// Two-phased constructor.

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

//

CCFCountOneShot* CCFCountOneShot::NewL( MCFOperationServices& aServices,

    CCFOperationNode* aParent,

    TDesC& aName,

    TDesC& aSource,

    const CCFContextOperation::TCmpType aType,

    const TDesC& aCmpVal,

    const TUint aCount,

    const TCountType aCountType )

    {

    FUNC_LOG;

    CCFCountOneShot* self = NewLC( aServices,

            aParent,

            aName,

            aSource,

            aType,

            aCmpVal,

            aCount,

            aCountType );

    CleanupStack::Pop( self );

    return self;

    }

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

// CCFCountOneShot::NewLC

// Two-phased constructor.

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

//

CCFCountOneShot* CCFCountOneShot::NewLC( MCFOperationServices& aServices,

    CCFOperationNode* aParent,

    TDesC& aName,

    TDesC& aSource,

    const CCFContextOperation::TCmpType aType,

    const TDesC& aCmpVal,

    const TUint aCount,

    const TCountType aCountType )

    {

    FUNC_LOG;

    HBufC* name = aName.AllocLC();

    HBufC* source = aSource.AllocLC();

    CCFCountOneShot* self = new( ELeave ) CCFCountOneShot( aServices,

            aParent,

            name,

            source,

            aType,

            aCount,

            aCountType );

    CleanupStack::PushL( self );

    self->ConstructL( aCmpVal );

    // Cleanup

    CleanupStack::Pop( self );

    CleanupStack::Pop( source );

    CleanupStack::Pop( name );

    CleanupStack::PushL( self );

    return self;

    }

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

// CCFCountOneShot::ParseL

// Construction with parsing from a DOM node.

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

//

CCFCountOneShot* CCFCountOneShot::ParseL( MCFOperationServices& aServices,

    CCFOperationNode* aParent,

    CMDXMLNode& aNode )

    {

    FUNC_LOG;

    if ( aNode.NodeName().CompareF( KScriptCountName ) != 0

        || aNode.NodeType() != CMDXMLNode::EElementNode )

        {

        return NULL; // Cannot create count operation from the given node.

        }

    // Check & get count attributes.

    CMDXMLElement& element = static_cast< CMDXMLElement& >( aNode );

    TPtrC countAttributeValue;

    if ( KErrNone != element.GetAttribute( KScriptOneShotAtAttribute,

            countAttributeValue ) )

        {

        INFO( "CCFCountOneShot::ParseL - count missing required attribute" );

        return NULL;

        }

    TInt expectedAttributeCount = KCountMinAttributes;

    // Check optional persistency file.

    TPtrC persistencyFileAttributeValue;

    if ( KErrNone == element.GetAttribute( KScriptPersistencyFileAttribute,

            persistencyFileAttributeValue ) )

        {

        if ( persistencyFileAttributeValue.Length() == 0 )

            {

            ERROR_GEN( "CCFCountOneShot::ParseL - Persistency File attribute length is zero!" );

            return NULL;

            }

        expectedAttributeCount++;

        }

    CCFCount::TCountType countType( CCFCount::ECountTypeRemain );

    TPtrC countTypeValue;

    element.GetAttribute( KScriptTypeAttribute, countTypeValue );

    if ( countTypeValue.Length() )

        {

        expectedAttributeCount++;

        if ( element.NumAttributes() != expectedAttributeCount )

            {

            INFO_1( "CCFCountOneShot::ParseL - count attributes != %d",

                    expectedAttributeCount );

            return NULL;

            }

        if ( countTypeValue.CompareF( KScriptCountTypeRemainName ) == 0 )

            {

            // Default value, already set.

            }

        else if ( countTypeValue.CompareF( KScriptCountTypeChangeName ) == 0 )

            {

            countType = CCFCount::ECountTypeChange;

            }

        else if ( countTypeValue.CompareF( KScriptCountTypeTriggerName ) == 0 )

            {

            countType = CCFCount::ECountTypeTrigger;

            }

        else

            {

            INFO_1( "CCFCountOneShot::ParseL - unknown attribute value [%S] for type",

                    &countTypeValue );

            return NULL;

            }

        }

    else

        {

        if ( element.NumAttributes() != expectedAttributeCount )

            {

            INFO_1( "CCFCountOneShot::ParseL - count attributes != %d",

                    expectedAttributeCount );

            return NULL;

            }

        }

    // Convert the attribute value to TUint.

    TUint countValue( 0 );

    TLex lex( countAttributeValue );

    TInt err = lex.Val( countValue );

    ERROR_1( err,

        "CCFCountOneShot::ParseL - Extracting count value from string [%S] failed!",

        &countAttributeValue );

    if ( err != KErrNone )

        {

        User::Leave( KErrArgument );

        }

    TPtrC contextSource;

    TPtrC contextType;

    TPtrC contextValue;

    TCmpType compareType( CCFContextOperation::EInvalidCmpType );

    TPtrC compareValue;

    TInt contextLevelDelay( 0 );

    TBool contextRefOK( EFalse );

    TBool comparisonTypeValueOK( EFalse );

    TBool argsOK( ETrue ); // Will be set to false if unknown nodes detected.

    CMDXMLNode* child = aNode.FirstChild();

    while ( child )

        {

        if ( child->NodeType() == CMDXMLNode::EElementNode )

            {

            if ( child->NodeName().CompareF( KScriptContextRefName ) == 0 )

                {

                if ( !contextRefOK )

                    {

                    contextRefOK = CFContextOperationUtils::ParseContextRef(

                            *child,

                            contextSource,

                            contextType,

                            contextValue,

                            contextLevelDelay );

                    if ( !contextRefOK )

                        {

                        argsOK = EFalse;

                        break;

                        }

                    }

                else

                    {

                    argsOK = EFalse;

                    break;

                    }

                }

            else

                {

                if ( !comparisonTypeValueOK )

                    {

                    comparisonTypeValueOK

                        = CFContextOperationUtils::ParseComparisonTypeValue(

                                *child,

                                compareType,

                                compareValue );

                    if ( !comparisonTypeValueOK )

                        {

                        argsOK = EFalse;

                        break;

                        }

                    }

                else

                    {

                    argsOK = EFalse;

                    break;

                    }

                }

            }

        else if ( child->NodeType() != CMDXMLNode::ECommentNode )

            {

            argsOK = EFalse;

            break;

            }

        child = child->NextSibling();

        }

    TBool parsed( EFalse );

    if ( argsOK && contextRefOK )

        {

        if ( ( comparisonTypeValueOK && !contextValue.Length() )

            || ( !comparisonTypeValueOK && contextValue.Length() ) )

            {

            if ( !comparisonTypeValueOK )

                {

                compareType = CCFContextOperation::EStringCmp;

                compareValue.Set( contextValue );

                }

            }

        else if ( comparisonTypeValueOK && contextValue.Length() )

            {

            INFO( "CCFCountOneShot::ParseL - Ambiguous definition for comparison value" );

            return NULL;

            }

        parsed = ETrue;

        }

    CCFCountOneShot* self = NULL;

    if ( parsed )

        {

        // Below                                    // CLEANUP<< self

        self = NewLC( aServices,

                aParent,

                contextType,

                contextSource,

                compareType,

                compareValue,

                countValue,

                countType );

        if ( contextLevelDelay )

            {

            self->iContextLevelDelay = contextLevelDelay;

            }

        if ( persistencyFileAttributeValue.Length() > 0 )

            {

            self->iPersistencyFile = persistencyFileAttributeValue.AllocL();

            }

        CleanupStack::Pop( self );                  // CLEANUP>> self

        }

    else

        {

        INFO( "CCFCountOneShot::ParseL - Unsupported arguments" );

        }

    return self;

    }

// Destructor

CCFCountOneShot::~CCFCountOneShot()

    {

    FUNC_LOG;

    }

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

// CCFCountOneShot::IsTrueL

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

//

TBool CCFCountOneShot::IsTrueL( const CCFContextObject& /*aContext*/ )

    {

    FUNC_LOG;

    TBool value( EFalse );

    if ( iCurrentCount == iCmpCount )

        {

        value = ETrue;

        if ( iCountType == CCFCount::ECountTypeRemain )

            {

            Finished();

            }

        }

    else if ( iCurrentCount > iCmpCount )

        {

        if ( iCmpCount == KInitialCount

            || iCountType != CCFCount::ECountTypeRemain )

            {

            Finished();

            }

        }

    return value;

    }

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

// CCFCountOneShot::Finished

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

//

void CCFCountOneShot::Finished()

    {

    FUNC_LOG;

    iFinished = ETrue;

    Deactivate();

    }