/*
* Copyright (c) 2005-2009 Nokia Corporation 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".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: 
*
*/


#include "authserver_impl.h"


using namespace AuthServer;

const CAuthExpressionImpl::TType CEvaluator::KAnd = CAuthExpressionImpl::EAnd;
const CAuthExpressionImpl::TType CEvaluator::KOr = CAuthExpressionImpl::EOr;
const TInt CEvaluator::KRPNGranularity = 4;

// -------- (de)allocation --------


CEvaluator* CEvaluator::NewL(MEvaluatorPluginInterface* aPluginInterface, MEvaluatorClientInterface* aClientInterface)
/**
	Factory function allocates and initializes new
	instance of CEvaluator.
	
	@param	aPluginInterface	Used to invoke plugins.
	@param	aClientInterface	Used to notify clients when
								an evaluation has completed.
 */
	{
	CEvaluator* ev = new(ELeave) CEvaluator(aPluginInterface, aClientInterface);
	CleanupStack::PushL(ev);
	ev->ConstructL();
	CleanupStack::Pop(ev);
	return ev;
	}


CEvaluator::CEvaluator(MEvaluatorPluginInterface* aPluginInterface, MEvaluatorClientInterface* aClientInterface)
/**
	Constructor records the supplied plugin and client interfaces.
	
	@param	aPluginInterface	Used to invoke plugins.
	@param	aClientInterface	Used to notify clients when
								an evaluation has completed.
 */
:	CActive(CActive::EPriorityStandard),
	iPluginInterface(aPluginInterface),
	iClientInterface(aClientInterface)
//	,iRpnStack(0)
	{
	CActiveScheduler::Add(this);
	}


void CEvaluator::ConstructL()
/**
	Allocate resources (i.e. RPN stack) used by
	this object throughout its lifetime.
 */
	{
	iRpnStack = new(ELeave) CArrayFixFlat<TIdentityId>(KRPNGranularity);
	}


CEvaluator::~CEvaluator()
/**
	Free any resources (i.e. RPN stack) successfully
	allocated by this object.
 */
	{
	Cancel();
	delete iRpnStack;
	}


// -------- evaluation --------


void CEvaluator::Evaluate(const CAuthExpressionImpl* aExpr)
/**
	Evaluate the current expression.  This finds
	the leftmost leaf node from the supplied expression
	and calls the appropriate plugin.
 */
	{
	__ASSERT_DEBUG(!IsActive(),
					Panic(EBusy));	
	// iterate through left branches until find
	// a leaf node
	
	while (aExpr->Type() == KAnd || aExpr->Type() == KOr)
		{
		aExpr = aExpr->Left();
		}
	
	iCurrentNode = aExpr;
	
	if (aExpr->Type() == CAuthExpressionImpl::EPluginId)
		iPluginInterface->Evaluate(aExpr->PluginId(), iIdentity, aExpr->Type(), iStatus);
	else if (aExpr->Type() == CAuthExpressionImpl::ENull)
		{
		iPluginInterface->Evaluate(0, iIdentity, aExpr->Type(), iStatus);
		}
	else /* aExpr->Type() == CAuthExpression::EPluginType */
		iPluginInterface->Evaluate(aExpr->PluginType(), iIdentity, aExpr->Type(), iStatus);
	SetActive();
	}


void CEvaluator::RunL()
/**
	Implement CActive by recording the identity
	returned by the plugin.  If the individual
	plugin failed then fail the entire evaluation.
 */
	{
	switch (iStatus.Int())
	    {
	    case KErrAuthServPluginNotActive:
	        // don't break
	    case KErrAuthServPluginCancelled:
	        iIdentity = KUnknownIdentity;
	        // don't break
	    case KErrNone:
	        EvaluatedNode(iIdentity);
    		break;
    	default: 
    	    NotifyClientFailed(iStatus.Int());
    	    break;
	    }
	}


void CEvaluator::DoCancel()
/**
	Implement CActive.  This function does not
	currently do anything.
 */
	{
	iPluginInterface->CancelEvaluate();

	NotifyClientFailed(KErrCancel);
	}

void CEvaluator::EvaluatedNode(TIdentityId aIdentity)
/**
	This function is called when the plugin has
	returned an identity.
	
	If it is a root node then complete the client request.

	If it is a left node, then push the identity on the
	RPN stack and evaluate the right node.
	
	If it is a right node then combine it with the stacked
	left result using the parent node's operator.
 */
	{
	CAuthExpressionImpl* parent = iCurrentNode->Parent();
	
	// If parent node complete client request.
	// This path is only used if the expression contains
	// a single leaf node.  If the root node is complex
	// then EvaluateCompound() calls HaveFinalResult().
	if (parent == 0)
		{
		__ASSERT_DEBUG(RpnDepth() == 0, Panic(EENRpnStackNonZero));
		NotifyClientSucceeded(aIdentity);
		}
	// if left node then push identity and evaluate sibling
	else
		{	
		if (! PushIdentity(aIdentity))
			NotifyClientFailed(KErrNoMemory);
		else
			{
			const CAuthExpressionImpl* rhsExpr = parent->Right();
			// if just evaluated RHS then compound result
			if (rhsExpr == iCurrentNode)
				{
				EvaluateCompound(parent);
				}
			else if ( 	(aIdentity == KUnknownIdentity && parent->Type() == KAnd) || 
						(aIdentity != KUnknownIdentity && parent->Type() == KOr)
					)
				{
				if (! PushIdentity(aIdentity))
					NotifyClientFailed(KErrNoMemory);
				else
					EvaluateCompound(parent);
				}
			// can't be short-circuited so evaluate RHS
			else
				{
				Evaluate(rhsExpr);
				}
			}	// else (! PushIdentity(aIdentity))
		}
	}


void CEvaluator::EvaluateCompound(const CAuthExpressionImpl* aParent)
/**
	This function is called by EvaluatedNode when
	both the left and right identities are on the
	RPN stack.
	
	Those two values are replaced with a single value
	from the combining operator.
 */
	{
	__ASSERT_DEBUG(RpnDepth() >= 2, Panic(EECRpnStackTooLow));
	TIdentityId rhs = PopIdentity();
	TIdentityId& lhs = LastIdentity();	// replace this with result
	
	switch (aParent->Type())
		{
	case KAnd:
		// unknown if left and right don't match.
		// These are both unknown for short-circuit.
		if (lhs != rhs)
			lhs = KUnknownIdentity;
		break;
	
	case KOr:
		// only take right value if left unknown.
		// Both same non-unknown for short-circuit.
		if (lhs == KUnknownIdentity)
			lhs = rhs;
		break;
	
	default:
		__ASSERT_DEBUG(EFalse, Panic(EECBadParentType));
		break;
		}
	
	// combine the parent complex node with _its_ sibling
	CAuthExpressionImpl* parent2 = aParent->Parent();

	// if parent2 is the root node, then complete the client request
	if (parent2 == 0)
		{
		__ASSERT_DEBUG(RpnDepth() == 1, Panic(EECRpnStackNotOneAtRoot));
		// reset stack after notifying client because
		// lhs is a reference to the top (only) item.
		NotifyClientSucceeded(lhs);
		}
	
	// if parent is parent2's left node then evaluate parent's right
	// sibling.  At this point parent's result is on the stack.
	else if (parent2->Left() == aParent)
		{
		// (lhs == unknown && type == AND) || (lhs != unknown && type == OR)
		if ((lhs == KUnknownIdentity) == (parent2->Type() == KAnd))
			{
			if (! PushIdentity(lhs))
				NotifyClientFailed(KErrNoMemory);
			else
				EvaluateCompound(parent2);
			}
		
		else
			Evaluate(parent2->Right());
		}
	
	// parent must have been parent2's right child so combine
	// its result with its left sibling.
	else
		{
		__ASSERT_DEBUG(parent2->Right() == aParent, Panic(EECBadRightParent));
		EvaluateCompound(parent2);
		}
	}


// -------- client notification --------


void CEvaluator::NotifyClientSucceeded(TIdentityId aIdentityId)
/**
	Notify the client that the evaluation has completed
	successfully, and free the RPNStack.
	
	@param	aIdentityId		Identified user.  This can be KUnknownIdentity.
 */
	{
	iClientInterface->EvaluationSucceeded(aIdentityId);
	ResetRpnStack();
	}


void CEvaluator::NotifyClientFailed(TInt aReason)
/**
	Notify the client that the evaluation has failed
	and free the RPN stack.
	
	@param	aReason			Symbian OS error code.
 */
	{
	iClientInterface->EvaluationFailed(aReason);
	ResetRpnStack();
	}


// -------- RPN stack --------


TBool CEvaluator::PushIdentity(TIdentityId aIdentity)
/**
	Append the supplied entity to the RPN stack.
	
	@param	aIdentity		Function to append to the RPN stack.
	@return					zero if could not append the item,
							i.e. OOM, non-zero otherwise.
 */
	{
	TRAPD(r, iRpnStack->AppendL(aIdentity));
	return r == KErrNone;
	}


TIdentityId CEvaluator::PopIdentity()
/**
	Remove the last identity from the RPN stack
	and return it.
	
	@return					The identity which was the last
							item on the RPN stack when this
							function was called.
	@pre The RPN stack contains at least one identity.
 */
	{
	TInt lastIndex = iRpnStack->Count() - 1;
	TIdentityId id = iRpnStack->At(lastIndex);
	
	// This function will not leave because the array
	// if not being grown.  It is only trapped to satisfy
	// leavescan.
	
	TRAP_IGNORE(iRpnStack->ResizeL(lastIndex));
	return id;
	}


TIdentityId& CEvaluator::LastIdentity()
/**
	Return a reference to the last item on the
	RPN stack.  This function is defined so
	ReplaceComplexIdentity() can efficiently
	put a result on the RPN stack without reallocating.
	
	@return					Reference to last item on the RPN stack.
	@pre The RPN stack contains at least one identity.
 */
	{
	TInt lastIndex = iRpnStack->Count() - 1;
	return iRpnStack->At(lastIndex);	
	}


void CEvaluator::ResetRpnStack()
/**
	Clear the RPN stack.
 */
	{
	iRpnStack->Reset();
	}


#ifdef _DEBUG


TInt CEvaluator::RpnDepth() const
/**
	Returns the depth of the RPN stack.  This is
	defined for debug builds only to ensure the
	stack depth is within an acceptable range.
 */
	{
	return iRpnStack->Count();
	}


void CEvaluator::Panic(CEvaluator::TPanic aPanic)
/**
	Halt the current thread with the category "AUTHEVAL"
	and the supplied reason.
	
	@param	aPanic			Panic reason.
 */
	{
	_LIT(KPanicCat, "AUTHEVAL");
	User::Panic(KPanicCat, aPanic);
	}


#endif	// #ifdef _DEBUG