/*
* Copyright (c) 2007-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: 
*
*/


#include "hnconditionfactory.h"
#include "hnsimplecondition.h"
#include "hncomplexcondition.h"
#include "hnglobals.h"

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

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CHnConditionInterface* HnConditionFactory::NewL( TXmlEngAttr aElement )
    {
    CHnConditionInterface* self = HnConditionFactory::NewLC( aElement );
    CleanupStack::Pop( self );
    return self;
    }


// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CHnConditionInterface* HnConditionFactory::NewLC( TXmlEngAttr aElement )
    {
    TPtrC8 condition = aElement.Value();
    CHnConditionInterface* self = ConstructConditionL( condition );
    CleanupStack::PushL( self );
    return self;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CHnConditionInterface* HnConditionFactory::NewL( TDesC8 & aElement )
    {
    CHnConditionInterface* self = HnConditionFactory::NewLC( aElement );
    CleanupStack::Pop( self );
    return self;
    }


// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CHnConditionInterface* HnConditionFactory::NewLC( TDesC8 & aElement )
    {
    CHnConditionInterface* self = HnConditionFactory::ConstructConditionL( aElement );
    CleanupStack::PushL( self );
    return self;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void HnConditionFactory::TrimConditionL( RBuf8 & aConditionString )
    {
    TBool ret;
    do
        {
        ret = EFalse;
        aConditionString.TrimAll();
        TInt conditionLastIndex = aConditionString.Length()-1;
        if (aConditionString[0] == EOpeningBrace 
                && aConditionString[conditionLastIndex] == EClosingBrace )
            {
            aConditionString[0] = ESpace;
            aConditionString[conditionLastIndex] = ESpace;
            
            ret = ETrue;
            
            if ( CheckBraceIntegrityL( aConditionString ) )
                {
                aConditionString[0] = EOpeningBrace;
                aConditionString[conditionLastIndex] = EClosingBrace;
                ret = EFalse;
                }
            }
        }
    while (ret);
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TBool HnConditionFactory::CheckBraceIntegrityL( TDesC8 & aConditionString )
    {
    TInt ret(KErrNone);
    TLex8 lexer( aConditionString );
    TInt lookForClosingBrace( 0 );
    while  ( !lexer.Eos() )
        {
        switch ( TUint( lexer.Get() ) )
            {
            case EOpeningBrace :
                lookForClosingBrace++;
                break;
            case EClosingBrace :
                lookForClosingBrace--;
                if (lookForClosingBrace < 0)
                    {
                    ret = KErrGeneral;
                    lexer.Inc( lexer.Remainder().Length() );
                    }
                break;             
            }
        }
    
    if (lookForClosingBrace > 0)
        {
        ret = KErrGeneral;
        }
    
    return ret;  
    }
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CHnConditionInterface* HnConditionFactory::ConstructConditionL(
        TDesC8 & aConditionString )
    {
    RBuf8 condition;
    CleanupClosePushL( condition );
    condition.CreateL( aConditionString );
    HnConditionFactory::TrimConditionL( condition );
    User::LeaveIfError( HnConditionFactory::CheckBraceIntegrityL(condition) );
    
    CHnConditionInterface* ret = NULL;
    
    if ( aConditionString.Find( HnLogicalRelations::KLogicalAnd8 ) == KErrNotFound
         && aConditionString.Find( HnLogicalRelations::KLogicalOr8 ) == KErrNotFound )
        {
        ret =  CHnSimpleCondition::NewL( condition );
        }
    else
        {
        ret = CHnComplexCondition::NewL( condition );
        }
    
    CleanupStack::PopAndDestroy( &condition );
    return ret;
    }