/*

* 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 <liwservicehandler.h>

#include <liwvariant.h>

#include "hnsimplecondition.h"

#include "hnsimpleconditionequal.h"

#include "hnsimpleconditiondifferent.h"

#include "hnsimpleconditiongreater.h"

#include "hnsimpleconditionhas.h"

#include "hnsimpleconditionhasnot.h"

#include "hnsimpleconditionsmaller.h"

#include "hnliwutils.h"

#include "hnglobals.h"

#include "hnconvutils.h"

#include "hnstringhandler.h"

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

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

//

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

//

CHnSimpleCondition* CHnSimpleCondition::NewL( TDesC8 & aElement )

    {

    CHnSimpleCondition* self = CHnSimpleCondition::CreateImplementationL( aElement );

    CleanupStack::PushL(self);

    self->ConstructL( aElement );

    CleanupStack::Pop(self);

    return self;

    }

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

//

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

//

CHnSimpleCondition* CHnSimpleCondition::CreateImplementationL(

        TDesC8 & aElement )

    {

    TPtrC8 buffer = aElement;

    CHnSimpleCondition* ret = NULL;

    if ( buffer.Find( HnLogicalRelations::KLogicalGreater8 )!= KErrNotFound )

        {

        ret =  new( ELeave ) CHnSimpleConditionGreater();

        }

    else if ( buffer.Find( HnLogicalRelations::KLogicalDifferent8 ) != 

        KErrNotFound )

        {

        ret = new( ELeave ) CHnSimpleConditionDifferent();

        }

    else if ( buffer.Find( HnLogicalRelations::KLogicalEqual8 ) != 

        KErrNotFound )

        {

        ret = new( ELeave ) CHnSimpleConditionEqual();

        }

    else if ( buffer.Find( HnLogicalRelations::KLogicalLess8 )!= 

        KErrNotFound )

        {

        ret = new( ELeave ) CHnSimpleConditionSmaller();

        }

    else if ( buffer.Find( HnLogicalRelations::KLogicalHas8 )!= 

        KErrNotFound )

        {

        ret = new( ELeave ) CHnSimpleConditionHas();

        }

    else if ( buffer.Find( HnLogicalRelations::KLogicalHasNot8 )!= 

        KErrNotFound )

        {

        ret = new( ELeave ) CHnSimpleConditionHasNot();

        }

    else

        {

        User::Leave( KErrGeneral );

        }

    return ret;

    }

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

//

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

//

CHnSimpleCondition::CHnSimpleCondition()

    {

    }

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

//

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

//

CHnSimpleCondition::~CHnSimpleCondition()

    {

    iReferenceRight.Close();

    iReferenceLeft.Close();

    }

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

//

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

//

void CHnSimpleCondition::RemoveQuotes( RBuf8 & aValue )

    {

    TInt quoPos = aValue.Locate('\'');

    if( quoPos == 0 )

        {

        aValue.Delete( 0 , 1 );

        aValue.Delete( aValue.Length() - 1, 1 );

        }

    }

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

//

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

//

void CHnSimpleCondition::ConstructL( TDesC8 & aElement )

    {

    TPtrC8 buffer = aElement;

    TInt pos = GetPositionL( buffer );

    ASSERT( pos );

    RBuf8 tempbuf;

    CleanupClosePushL( tempbuf );

    tempbuf.CreateL( buffer.Right( buffer.Length() - pos - SignLength() ) );

    iReferenceRight.Close();

    iReferenceRight.CreateL( tempbuf );

    iReferenceRight.Trim();

    CHnSimpleCondition::RemoveQuotes( iReferenceRight );

    tempbuf.Close();

    tempbuf.CreateL( buffer.Left( pos ) );

    iReferenceLeft.Close();

    iReferenceLeft.CreateL( tempbuf );

    iReferenceLeft.Trim();

    CHnSimpleCondition::RemoveQuotes( iReferenceLeft );

    CleanupStack::PopAndDestroy( &tempbuf );

    }

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

//

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

//

void CHnSimpleCondition::NormalizeVariantTypeDesL( TLiwVariant* aVar )

    {

    if( aVar->TypeId() == LIW::EVariantTypeDesC8 )

        {

        TPtrC8 left;

        aVar->Get( left );

        HBufC * data = HnConvUtils::Str8ToStrFastLC( left );

        aVar->SetL( TLiwVariant( data ) );

        CleanupStack::PopAndDestroy( data );

        }

    }

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

//

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

//

TLiwVariant* CHnSimpleCondition::CheckTypes( TLiwVariant* aVarLeft,

        TLiwVariant* aVarRight, LIW::TVariantTypeId aType1, 

        LIW::TVariantTypeId aType2 )

    {

    LIW::TVariantTypeId varLeftId = aVarLeft->TypeId();

    LIW::TVariantTypeId varRightId = aVarRight->TypeId();

    if (varLeftId == aType1 && varRightId == aType2)

        {

        return aVarLeft;

        }

    else if (varLeftId == aType2 && varRightId == aType1)

        {

        return aVarRight;

        }

    return NULL;

    }

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

//

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

//

void CHnSimpleCondition::NegotiateListL( TLiwVariant & aVar )

    {

    ASSERT( aVar.TypeId() == LIW::EVariantTypeList );

    CLiwList* temp = CLiwDefaultList::NewL();

    temp->PushL();

    aVar.Get( *temp );

    aVar.SetL( TLiwVariant( TInt32(temp->Count()) ) );

    CleanupStack::PopAndDestroy( temp );

    }

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

//

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

//

void CHnSimpleCondition::NegotiateMapL( TLiwVariant & aVar  )

    {

    ASSERT( aVar.TypeId() == LIW::EVariantTypeMap );

    CLiwDefaultMap* temp = CLiwDefaultMap::NewL();

    temp->PushL();

    aVar.Get( *temp ); 

    aVar.SetL( TLiwVariant( TInt32(temp->Count()) ) );

    CleanupStack::PopAndDestroy( temp );

    }

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

//

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

//

void CHnSimpleCondition::NegotiateTUintL( TLiwVariant & aVar )

    {

    ASSERT ( aVar.TypeId() == LIW::EVariantTypeDesC );

    TPtrC temp;

    TUint integer;

    aVar.Get(temp);

    TLex val( temp );

    val.Val(integer);

    aVar.Set( integer );

    }

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

//

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

//

void CHnSimpleCondition::NegotiateTBoolL( TLiwVariant & aVar )

    {    

    ASSERT( aVar.TypeId() == LIW::EVariantTypeDesC );

    TPtrC ptr;

    aVar.Get( ptr );

    if ( !HnStringHandler::CompareIgnoreCaseL( ptr, KStringTrue ) )

        {

        aVar.Set( ETrue );

        }

    else

          {

          aVar.Set( EFalse );

           }

    }

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

//

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

//

void CHnSimpleCondition::NegotiateTInt32L( TLiwVariant & aVar )

    {

    ASSERT( aVar.TypeId() == LIW::EVariantTypeDesC

            || aVar.TypeId() == LIW::EVariantTypeTUint );

    if ( aVar.TypeId() == LIW::EVariantTypeDesC )

        {

        TPtrC temp;

        TInt32 integer;

        aVar.Get(temp);

        TLex val( temp );

        val.Val(integer);

        aVar.Set( integer );

        }

    else if ( aVar.TypeId() == LIW::EVariantTypeTUint )

        {

        TUint unsignedValue( 0U );

        aVar.Get( unsignedValue );

        if( unsignedValue <= static_cast<TUint>( KMaxTInt32 ) )

            {

            aVar.Set( static_cast<TInt32>( unsignedValue ) );

            }

        }

    }

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

//

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

//

void CHnSimpleCondition::NegotiateTInt64L( TLiwVariant & aVar )

    {

    ASSERT(aVar.TypeId() == LIW::EVariantTypeDesC );

    TPtrC temp;

    TInt64 integer;

    aVar.Get(temp);

    TLex val( temp );

    val.Val(integer);

    aVar.Set( integer );

    }

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

//

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

//

void CHnSimpleCondition::NegotiateTypesL( TLiwVariant* aVarLeft, 

        TLiwVariant* aVarRight )

    {

    NormalizeVariantTypeDesL( aVarLeft );

    NormalizeVariantTypeDesL( aVarRight );

    if (aVarLeft->TypeId() != aVarRight->TypeId())

        {

        TLiwVariant* chosen( NULL );

        chosen = CheckTypes( aVarLeft, aVarRight, LIW::EVariantTypeList, LIW::EVariantTypeDesC );

        if ( chosen )

            {

            NegotiateListL( *chosen );

            return;

            }

        chosen = CheckTypes( aVarLeft, aVarRight, LIW::EVariantTypeMap, LIW::EVariantTypeDesC );

        if ( chosen )

            {

            NegotiateMapL( *chosen );

            return;

            }

        chosen = CheckTypes( aVarLeft, aVarRight, LIW::EVariantTypeDesC, LIW::EVariantTypeTInt32 );

        if ( chosen )

            {

            NegotiateTInt32L( *chosen );

            return;

            }

        chosen = CheckTypes( aVarLeft, aVarRight, LIW::EVariantTypeDesC, LIW::EVariantTypeTUint );

        if ( chosen )

            {

            NegotiateTUintL( *chosen );

            return;

            }

        chosen = CheckTypes( aVarLeft, aVarRight, LIW::EVariantTypeDesC, LIW::EVariantTypeTInt64 );

        if ( chosen )

            {

            NegotiateTInt64L( *chosen );

            return;

            }

        chosen = CheckTypes( aVarLeft, aVarRight, LIW::EVariantTypeDesC, LIW::EVariantTypeTBool );

        if ( chosen )

            {

            NegotiateTBoolL( *chosen );

            return;

            }

        chosen = CheckTypes( aVarLeft, aVarRight, LIW::EVariantTypeTUint, LIW::EVariantTypeTInt32 );

        if ( chosen )

            {

            NegotiateTInt32L( *chosen );

            return;

            }

        }

    }

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

// 

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

//

TBool CHnSimpleCondition::ResultL( const CLiwGenericParamList& aQueryResults, 

        TInt aPos )

    {

    TBool ret( EFalse );

    TLiwVariant varLeft;

    varLeft.PushL();

    TInt err1 = HnLiwUtils::GetVariantL( aQueryResults, iReferenceLeft, aPos, varLeft );

    TLiwVariant varRight;

    varRight.PushL();

    TInt err2 = HnLiwUtils::GetVariantL( aQueryResults, iReferenceRight, aPos , varRight );

    if ( err1 == KErrNone && err2 == KErrNone )

    	{

    	NegotiateTypesL( &varLeft, &varRight);

    	ret = CheckCondition( varLeft, varRight );

    	}

    CleanupStack::PopAndDestroy( &varRight );

    CleanupStack::PopAndDestroy( &varLeft );

    return ret;

    }