/*

* Copyright (c) 2009 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:  Query base class

*

*/

#include "mdequery.h"

#include "mdeorderrule.h"

#include "mdeinstanceitem.h"

#include "mdelogiccondition.h"

#include "mdenamespacedef.h"

#include "mdepanic.h"

CMdEQuery::CMdEQuery(TQueryType aType, CMdESession& aSession, CMdENamespaceDef& aNamespaceDef)

        : iQueryId( 0 ), iSession(aSession), iNamespaceDef(aNamespaceDef), iType(aType), 

          iResultMode(EQueryResultModeItem), iState(EStateNew), iError(KErrNone), 

          iObjectResult(NULL), iCountResult(0), iDistinctResults(NULL), iDestroyed(EFalse)

    {

    }

void CMdEQuery::QueryConstructL()

    {

    iConditions = CMdELogicCondition::NewL(ELogicConditionOperatorAnd);

    }

CMdEQuery::~CMdEQuery()

	{

    iDestroyed = ETrue;

	Cancel();

    // This will destroy the entire conditions tree.

   	delete iConditions;

    // Destroy all result items this query instance owns.

   	for( TInt i = iResults.Count() - 1; i >=0; i-- )

        {

        if(iResults[i].iOwned)

            {

            delete iResults[i].iItem;

            }

        }

    // Destroy object result item this query instance owns  

    if(iObjectResult.iItem)

        {

        if(iObjectResult.iOwned)

        	{

        	delete iObjectResult.iItem;

        	iObjectResult.iItem = NULL;

        	}

        }

	iCountResult = 0;

	iResults.Reset();

	iResults.Close();

	iIdResults.Reset();

	iIdResults.Close();

    iOrderRules.Close();

    iObservers.Close();

   	delete iDistinctResults;

	}

EXPORT_C TQueryType CMdEQuery::Type() const

    {

    return iType;

    }

EXPORT_C CMdENamespaceDef& CMdEQuery::NamespaceDef() const

	{

	return iNamespaceDef;

	}

EXPORT_C CMdESession& CMdEQuery::Session() const

    {

    return iSession;

    }

EXPORT_C CMdELogicCondition& CMdEQuery::Conditions() const

    {

    __ASSERT_DEBUG(iConditions , 

                    TMdEPanic::Panic(TMdEPanic::EInternal));

    return *iConditions;

    }

EXPORT_C void CMdEQuery::AppendOrderRuleL(const TMdEOrderRule& aRule)

    {

    AssertInState(EStateNew);

    iOrderRules.AppendL( aRule );

    }

EXPORT_C void CMdEQuery::InsertOrderRuleL(const TMdEOrderRule& aRule, TInt aPos)

    {

    AssertInState(EStateNew);

    User::LeaveIfError( iOrderRules.Insert(aRule, aPos) );   

    }

EXPORT_C TInt CMdEQuery::OrderRuleCount() const

    {

    return iOrderRules.Count();    

    }

EXPORT_C void CMdEQuery::RemoveOrderRule(TInt aIndex)

    {

    AssertInState(EStateNew);

    iOrderRules.Remove(aIndex);

    }

EXPORT_C TMdEOrderRule CMdEQuery::OrderRule(TInt aIndex) const

    {

    return iOrderRules[aIndex];        

    }

EXPORT_C void CMdEQuery::FindL(TUint aMaxCount, TUint aNotifyCount)

    {

    AssertNotInState(EStateError);

	// leave if query already running    

    if(iState == EStateSearching)

        {

        User::Leave(KErrNotReady);

        }

	// clear old results

	// Destroy all result items this query instance owns.

    for( TInt i = iResults.Count() - 1; i >=0; i-- )

        {

        if(iResults[i].iOwned)

            {

            delete iResults[i].iItem;

            }

        }

	iResults.Reset();

    // Destroy object result item this query instance owns  

    if( iObjectResult.iItem )

        {

        if( iObjectResult.iOwned )

        	{

        	delete iObjectResult.iItem;

        	iObjectResult.iItem = NULL;

        	}

        }

	iIdResults.Reset();

    if( iDistinctResults )

    	{    	

    	delete iDistinctResults;

    	iDistinctResults = NULL;

    	}

	iCountResult = 0;

	// end of clearing

    DoFindL(aMaxCount, aNotifyCount);

    }

EXPORT_C void CMdEQuery::Cancel()

    {

    // is query incomplete before canceling

    TBool incomplete = !IsComplete();

    if( incomplete )

    	{

    	DoCancel();

    	}

	if( iConditions )

		{		

    	iConditions->SetLocked( EFalse );

		}

    if( incomplete || IsComplete() == EFalse )

    	{

    	iState = EStateError;

    	if( !iDestroyed )

    	    {

            NotifyCompleted( KErrCancel );

    	    }

    	}

    }

EXPORT_C TBool CMdEQuery::IsComplete() const

    {

    return iState != EStateSearching ? ETrue : EFalse;

    }

EXPORT_C TInt CMdEQuery::Error() const

    {

    return iError;

    }

EXPORT_C TInt CMdEQuery::Count() const

    {

    if ( iResultMode == EQueryResultModeItem || iResultMode == EQueryResultModeObjectWithFreetexts )

        {

        return iResults.Count();

        }

    else if ( iResultMode == EQueryResultModeId )

        {

        return iIdResults.Count();

        }

    else if ( iResultMode == EQueryResultModeDistinctValues )

    	{

    	if( iDistinctResults )

    		{    		

    		return iDistinctResults->Count();

    		}

    	else

    		{

    		return 0;

    		}

    	}

    else // count query

        {

        return iCountResult;

        }

    }

EXPORT_C CMdEItem& CMdEQuery::ResultItem(TInt aIndex) const

    {

    return *iResults[aIndex].iItem;

    }

EXPORT_C TItemId CMdEQuery::ResultId(TInt aIndex) const

    {

    return iIdResults[aIndex];

    }

EXPORT_C const RArray<TItemId>& CMdEQuery::ResultIds() const

	{

	return iIdResults;

	}

EXPORT_C CMdEItem* CMdEQuery::TakeOwnershipOfResult(TInt aIndex)

    {

    // Panic if an item is taken twice.

    __ASSERT_DEBUG(iResults[aIndex].iOwned,

                    TMdEPanic::Panic(TMdEPanic::EQueryDoesntOwnResult));

    // Applies only instance ownership

    if ( iResultMode == EQueryResultModeItem || iResultMode == EQueryResultModeObjectWithFreetexts )

        {

        iResults[aIndex].iOwned = EFalse;

        return static_cast<CMdEItem*>( iResults[aIndex].iItem );

        }

    else

    	{

    	return NULL;

    	}

    }

EXPORT_C TBool CMdEQuery::OwnsResult(TInt aIndex)

    {

    return iResults[aIndex].iOwned;

    }

EXPORT_C CMdEQuery::TState CMdEQuery::State() const

    {

    return iState;

    }

void CMdEQuery::DoCancel()

    {

    SetState( EStateError );

    }

void CMdEQuery::SetState(TState aState)

    {

    if(aState == iState)

        {

        // Already in the specified state.

        return;

        }

    // It's impossible to get out of the Error state.

    AssertNotInState(EStateError);

    // It's impossible to return to the New state.

    __ASSERT_ALWAYS(aState > EStateFirst && aState < EStateLast && 

                    aState != EStateNew, 

                    TMdEPanic::Panic(TMdEPanic::EInternal));

    // Move out of the old state.

    switch(iState)

        {

        case EStateNew:

            // Moving out of the New state causes the search conditions to 

            // be locked.

            iConditions->SetLocked();

            break;    

        case EStateSearching:

            // Searching has been completed.

            break;

        case EStateCompleted:

            // Searching is been restarted.

            break;

        default:

            break;

        }

    // Set the new state.

    iState = aState;

    // Move into the new state.

    switch(iState)

        {

        case EStateSearching:

            // Searching has been started.

            break;

        case EStateCompleted:

            // Searching has been completed.

            break;

        case EStateError:

            // The query has entered the Error state.

            break;

        default:

            break;

        }    

    }

void CMdEQuery::AssertInState(TState aState)

    {

    __ASSERT_ALWAYS(aState == iState,

                    TMdEPanic::Panic(TMdEPanic::EQueryStateIllegalOperation));

    }

void CMdEQuery::AssertNotInState(TState aState)

    {

    __ASSERT_ALWAYS(aState != iState,

                    TMdEPanic::Panic(TMdEPanic::EQueryStateIllegalOperation));

    }

void CMdEQuery::NotifyNewResultsL(const RPointerArray<CMdEInstanceItem>& aNewResults)

    {

    __ASSERT_ALWAYS(iState != EStateNew && iState != EStateError,

                    TMdEPanic::Panic(TMdEPanic::EInternal));

	TInt firstNewItemIndex = iResults.Count();

	TInt i = 0;

    // Query gets ownership of the results only if don't leave.

    // If a leave occurs, the results array is restored to its original

    // condition before any new results were added.

    const TInt oldCount = iResults.Count();

    TRAPD(err, AppendResultsL(aNewResults));

    if (err != KErrNone)

        {

        // Cleanup: remove the ones that were added.

        while (iResults.Count() > oldCount)

            {

            iResults.Remove(iResults.Count() - 1);

            }

        // Leave with the same error.

        User::Leave(err);

        }

    // After this no leave can occur.

    const TInt newCount = aNewResults.Count();

    // Transfer ownership of the results to the query.

    for (i = 0; i < newCount; i++)

        {

        iResults[firstNewItemIndex + i].iOwned = ETrue;

        }

    for( TInt i = iObservers.Count() - 1; i >=0; i-- )

		{

		MMdEQueryObserver* observer = iObservers[i];

		observer->HandleQueryNewResults( *this, firstNewItemIndex, newCount );

		}

    }

void CMdEQuery::NotifyNewResultsL(const RArray<TItemId>& aNewResults)

    {

    __ASSERT_ALWAYS(iState != EStateNew && iState != EStateError,

                    TMdEPanic::Panic(TMdEPanic::EInternal));

	TInt firstNewItemIndex = iIdResults.Count();

    const TInt oldCount = iIdResults.Count();

    TRAPD(err, AppendResultsL(aNewResults));

    if (err != KErrNone)

        {

        // Cleanup: remove the ones that were added.

        while (iIdResults.Count() > oldCount)

            {

            iIdResults.Remove(iIdResults.Count() - 1);

            }

        // Leave with the same error.

        User::Leave(err);

        }

    for( TInt i = iObservers.Count() - 1; i >=0; i-- )

		{

		MMdEQueryObserver* observer = iObservers[i];

		observer->HandleQueryNewResults(*this, firstNewItemIndex, 

                                        aNewResults.Count());

		}

    }

void CMdEQuery::NotifyNewResultsL( const CDesCArray& aNewResults )

    {

	TInt firstNewItemIndex = aNewResults.Count();

	TInt oldCount = 0;

	if( iDistinctResults )

		{

		oldCount = iDistinctResults->Count();

		}

	else

		{

	    iDistinctResults = new (ELeave) CDesCArrayFlat( 8 );

		}

    TRAPD( err, AppendResultsL( aNewResults ) );

    if( err != KErrNone )

        {

        // Cleanup: remove the ones that were added.

        while( iDistinctResults->Count() > oldCount )

            {

            iDistinctResults->Delete( iDistinctResults->Count() - 1 );

            }

        // Leave with the same error.

        User::Leave(err);

        }

    for( TInt i = iObservers.Count() - 1; i >=0; i-- )

		{

		MMdEQueryObserver* observer = iObservers[i];

		observer->HandleQueryNewResults( *this, firstNewItemIndex, 

                                         aNewResults.Count() );

		}

    }

void CMdEQuery::NotifyNewResults(TUint32 aResult)

	{

    // Don't call observer here, since only one result

    iCountResult = aResult;

    }

void CMdEQuery::AppendResultsL(const RPointerArray<CMdEInstanceItem>& aNewResults)

    {

    const TInt newResultCount = aNewResults.Count();

    iResults.ReserveL( iResults.Count() + newResultCount );

	for (TInt i = 0; i < newResultCount; ++i)

        {

        // At this point the ownership isn't transferred yet.

        TResult result( aNewResults[i] );

		iResults.AppendL( result );

		}

    }

void CMdEQuery::AppendResultsL(const RArray<TItemId>& aNewResults)

    {

    const TInt newResultCount = aNewResults.Count();

    iIdResults.ReserveL( iResults.Count() + newResultCount );

	for (TInt i = 0; i < newResultCount; ++i)

        {

        // Add new results to query's list

		iIdResults.AppendL( aNewResults[i] );

		}

    }

void CMdEQuery::AppendResultsL( const CDesCArray& aNewResults )

    {

    const TInt count = aNewResults.Count();

    for ( TInt i = 0; i < count; ++i )

    	{

    	iDistinctResults->AppendL( aNewResults[i] );

    	}