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

using System;
using SymBuildParsingLib.Tree;
using SymBuildParsingLib.Token;
using SymBuildParsingLib.Utils;
using SymBuildParsingLib.Parser.Framework.Document;
using SymBuildParsingLib.Parser.Framework.Nodes;
using SymbianTree;

namespace SymBuildParsingLib.Parser.PreProcessor.Nodes
{
	public class SymNodePreProcessorCondition : SymNodeCondition
	{
		#region Constructors & destructor
		public SymNodePreProcessorCondition( SymNodeCondition.TType aType )
		: base( aType )
		{
		}

		public SymNodePreProcessorCondition( string aName )
		: base( aName )
		{
		}
		#endregion

		#region From SymNodeCondition
		public override void Evaluate( SymParserDocumentContext aContext )
		{
			IsEvaluated = false;

			if	( Type == TType.ETypeIf || Type == TType.ETypeElseIf )
			{
				// Evaluate the expression, taking into account the current #define'd 
				// values. Prepares a new document with these expressions evaluated.
				SymTokenDocument evalDoc = new SymTokenDocument();
				EvaluateDefineNodes( BalancedArguments, evalDoc, aContext );
				string expression = evalDoc.ChildrenAsString( false, true );
				EvaluationResult = SymExpressionEvaluator.EvaluateAsBoolean( expression );
			}
			else if ( Type == TType.ETypeIfdef || Type == TType.ETypeIfndef )
			{
				// Convert the tree to a flat expression
				string symbol = BalancedArguments.ChildrenAsString( true, true );

				// Check if the symbol is defined
				if ( Type == TType.ETypeIfdef )
				{
					EvaluationResult = aContext.DefineDirectory.IsDefined( symbol );
				}
				else if ( Type == TType.ETypeIfndef )
				{
					EvaluationResult = !aContext.DefineDirectory.IsDefined( symbol );
				}
			}
			else if ( Type == TType.ETypeElse )
			{
				// Else statements always evaluate to true. We let the parent
				// conditional expression node decide whether or not this item should
				// 'fire'
				EvaluationResult = true;
			}

			IsEvaluated = true;
		}
		#endregion

		#region Properties
		#endregion

		#region Internal methods
		private void EvaluateDefineNodes( SymNode aNode, SymTokenDocument aDocument, SymParserDocumentContext aContext )
		{
			foreach( SymNode n in aNode )
			{
				if	( n is SymTokenBalancerMarkerLevelNode )
				{
					bool added = false;
					//
					SymTokenBalancerMarkerLevelNode levelNode = (SymTokenBalancerMarkerLevelNode) n;
					if	( levelNode.IsFunction )
					{
						SymNodeToken functionNameNode = levelNode.FunctionName;
						//
						if	( functionNameNode.Token.Equals( iDefinedNodeToken ) )
						{
							SymTokenContainer defineName = levelNode.ChildTokens;
							string flattened = defineName.CoalescedTokenValue;
							
							// Get definition result
							bool isDefined = aContext.DefineDirectory.IsDefined( flattened );
							SymToken isDefinedToken = new SymToken( isDefined.ToString().ToLower(), SymToken.TClass.EClassAlphaNumeric, SymToken.TType.ETypeAlphaNumericNormal );

							// Remove already added "defined" text node from output document
							if	( aDocument.CurrentNode.LastChild is SymNodeToken )
							{
								SymNodeToken last = (SymNodeToken) aDocument.CurrentNode.LastChild;
								if	( last.Token.Equals( iDefinedNodeToken ) )
								{
									last.Remove();
								}
							}

							// Add result
							aDocument.CurrentNode.Add( new SymNodeToken( isDefinedToken ) );
							added = true;
						}
					}

					if	( added == false )
					{
						if	( levelNode.HasPrevious && levelNode.Previous is SymTokenBalancerNodeEmittedElement )
						{
							levelNode.EmittedElementPrevious.AddToDocumentIfEmittable( aDocument );
						}

						SymNode newLevelNode = new SymNodeAddAsChild();
						aDocument.CurrentNode.Add( newLevelNode );
						aDocument.CurrentNode = newLevelNode;
						EvaluateDefineNodes( n, aDocument, aContext );
						aDocument.MakeParentCurrent();

						if	( levelNode.HasNext && levelNode.Next is SymTokenBalancerNodeEmittedElement )
						{
							levelNode.EmittedElementNext.AddToDocumentIfEmittable( aDocument );
						}
					}
				}
				else if ( n is SymNodeToken )
				{
					SymNodeToken node = (SymNodeToken) n;
					SymNodeToken copy = new SymNodeToken( node.Token );
					aDocument.CurrentNode.Add( copy );
				}
				else if	( n is SymTokenBalancerNodeEmittedElement )
				{
					// Handled when the level marker is reached
				}
			}
		}
		#endregion

		#region Data members
		private static SymToken iDefinedNodeToken = new SymToken( "defined", SymToken.TClass.EClassAlphaNumeric, SymToken.TType.ETypeAlphaNumericNormal );
		#endregion
	}
}