/*

* 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 System.Text;

using System.Collections;

using SymBuildParsingLib.Tree;

using SymBuildParsingLib.Token;

using SymBuildParsingLib.Common.Objects;

using SymbianTree;

namespace SymBuildParsingLib.Token

{

	#region SymTokenBalancerDocument

	public class SymTokenBalancerDocument : SymTokenDocument

	{

		#region Constructors & destructor

		public SymTokenBalancerDocument()

		{

		}

		#endregion

		#region Internal framework API

		protected override void ExtractToContainer( SymNode aNode, SymTokenContainer aContainer )

		{

			if	( aNode is SymTokenBalancerNodeEmittedElement )

			{

				SymTokenBalancerNodeEmittedElement node = (SymTokenBalancerNodeEmittedElement) aNode;

				node.AddToContainerIfEmittable( aContainer );

			}

		}

		protected override void ExtractToDocument( SymNode aNode, SymTokenDocument aDocument )

		{

			if	( aNode is SymTokenBalancerNodeEmittedElement )

			{

				SymTokenBalancerNodeEmittedElement node = (SymTokenBalancerNodeEmittedElement) aNode;

				node.AddToDocumentIfEmittable( aDocument );

			}

		}

		protected override bool NodeIsExtractable( SymNode aNode )

		{

			bool ret = false;

			//

			if	( aNode is SymTokenBalancerNodeEmittedElement )

			{

				SymTokenBalancerNodeEmittedElement node = (SymTokenBalancerNodeEmittedElement) aNode;

				ret = node.Emit;

			}

			//

			return ret;

		}

		#endregion

	}

	#endregion

	#region SymTokenBalancerNode

	public class SymTokenBalancerNode : SymNodeToken

	{

		#region Constructors & destructor

		public SymTokenBalancerNode( SymToken aToken )

			: base( aToken )

		{

		}

		#endregion

	}

	#endregion

	#region SymTokenBalancerMarkerNode

	public class SymTokenBalancerMarkerNode : SymNodeAddAsChild

	{

		#region Constructors & destructor

		public SymTokenBalancerMarkerNode( SymTokenBalancerMatchCriteria aMatchCriteria )

		{

			iMatchCriteria = aMatchCriteria;

		}

		#endregion

		#region Properties

		public SymTokenBalancerMatchCriteria MatchCriteria

		{

			get { return iMatchCriteria; }

		}

		#endregion

		#region Data members

		private readonly SymTokenBalancerMatchCriteria iMatchCriteria;

		#endregion

	}

	#endregion

	#region SymTokenBalancerMarkerLevelNode

	public class SymTokenBalancerMarkerLevelNode : SymTokenBalancerMarkerNode

	{

		#region Constructors & destructor

		public SymTokenBalancerMarkerLevelNode( SymTokenBalancerMatchCriteria aMatchCriteria )

			: base( aMatchCriteria )

		{

		}

		#endregion

		#region From SymNode		

		public override void Replace( SymNode aReplacement )

		{

			if	( HasPrevious && Previous is SymTokenBalancerNodeEmittedElement )

			{

				Previous.Remove();

			}

			if	( HasNext && Next is SymTokenBalancerNodeEmittedElement )

			{

				Next.Remove();

			}

			base.Replace( aReplacement );

		}

		#endregion

		#region API

		public SymArgumentSubLevel AsArgumentSubLevel( bool aRecurse )

		{

			SymArgumentSubLevel ret = new SymArgumentSubLevel( this );

			//

			if	( aRecurse )

			{

				foreach( SymNode child in ret )

				{

					if	( child is SymTokenBalancerMarkerLevelNode )

					{

						SymTokenBalancerMarkerLevelNode markerNode = (SymTokenBalancerMarkerLevelNode) child;

						SymArgumentSubLevel subLevel = markerNode.AsArgumentSubLevel( aRecurse );

						ret.InsertChild( subLevel, markerNode );

						markerNode.Remove();

					}

				}

			}

			//

			return ret;

		}

		public void ConvertEmittedElementsToRealTokenNodes( bool aRecurse )

		{

			int i = ChildCount;

			//

			while( i > 0 )

			{

				SymNode child = this[ --i ];

				//

				if	( child is SymTokenBalancerNodeEmittedElement )

				{

					SymTokenBalancerNodeEmittedElement emittedElement = (SymTokenBalancerNodeEmittedElement) child;

					if	( emittedElement.Emit )

					{

						SymNodeToken replacement = new SymNodeToken( emittedElement.Token ); 

						InsertChild( replacement, child );

					}

					child.Remove();

				}

				else if ( child is SymTokenBalancerMarkerLevelNode && aRecurse )

				{

					SymTokenBalancerMarkerLevelNode childLevel = (SymTokenBalancerMarkerLevelNode) child;

					childLevel.ConvertEmittedElementsToRealTokenNodes( aRecurse );

				}

			}

		}

		public int CountTokenByType( SymToken.TClass aClass )

		{

			int count = 0;

			//

			foreach( SymNode n in this )

			{

				if	( n is SymNodeToken )

				{

					bool isSpecial = ( n is SymTokenBalancerNode );

					//

					if	( isSpecial == false )

					{

						SymToken t = ((SymNodeToken) n).Token;

						//

						if	( t.Class == aClass )

						{

							++count;

						}

					}

				}

			}

			//

			return count;

		}

		public void Subsume()

		{

			System.Diagnostics.Debug.Assert( IsComplete );

			//

			SymTokenBalancerNodeEmittedElement previous = EmittedElementPrevious;

			SymTokenBalancerNodeEmittedElement next = EmittedElementNext;

			// Insert all my children as siblings of myself (i.e. make my parent's

			// grandchildren its direct children - i.e. promote them up the tree

			// by one level).

			SymNode parent = Parent;

			ArrayList parentsChildren = Parent.Children;

			parent.InsertChildrenFrom( this /* my children */, previous.Previous /* move them before the opening bracket */);

			// Remove the opening bracket token

			previous.Remove();

			// Remove the closing bracket token.

			next.Remove();

			// Remove the level marker token, i.e myself

			Remove();

		}

		#endregion

		#region Properties

		public bool CanBeSubsumed

		{

			get

			{

				bool canBeSubsumed = false;

				//

				if	( IsComplete )

				{

					if	( AreLocalEmittedNodesDiametricallyOposite )

					{

						bool isSimple = IsSimple;

						//

						if	( isSimple )

						{

							// Deal with the case whereby we have something like this: ([SOMETHINGELSE])

							if	( ( Parent is SymTokenBalancerMarkerLevelNode) && ChildCountLevelNodes == 0 )

							{

								// We don't have any child level nodes and our parent is a level (it always sound be in any case).

								SymTokenBalancerMarkerLevelNode parent = (SymTokenBalancerMarkerLevelNode) Parent;

								if	( parent.IsComplete )

								{

									// Check whether the parent is a function. If it is, then we don't want to subsume the children.

									bool isFunc = parent.IsFunction;

									if	( isFunc == false )

									{

										// The parent is complete, which means we can compare this level's open and closing tokens

										// with the parents.

										canBeSubsumed = ( parent.EmittedElementPrevious.Token.Equals( EmittedElementPrevious.Token ) && 

											parent.EmittedElementNext.Token.Equals( EmittedElementNext.Token ) );

									}

								}

								else

								{

									canBeSubsumed = true;

								}

							}

							else

							{

								canBeSubsumed = true;

							}

						}

						else

						{

							// Check whether our children contains at least a single argument separator node.

							// If it does, we can't allow it to be subsumed.

							if	( ChildCountArgumentNodes == 0 )

							{

								if	( Parent is SymTokenBalancerMarkerLevelNode )

								{

									SymTokenBalancerMarkerLevelNode parent = (SymTokenBalancerMarkerLevelNode) Parent;

									bool parentIsSimple = parent.IsSimple;

									canBeSubsumed = parentIsSimple;

								}

							}

						}

					}

				}

				//

				return canBeSubsumed;

			}

		}

		public bool IsFunction

		{

			get

			{

				#region Example

				//

				// [FUNC_NAME] [(] [*] [)] 

				//                  |

				//        [alpha_numeric_child]

				//

				#endregion

				bool bracketsAreCorrect = false;

				bool hasFunctionName = false;

				bool childIsValid = false;

				//

				if	( AreLocalEmittedNodesDiametricallyOposite )

				{

					// Check that the previous node is a function name

					if	( Previous.HasPrevious )

					{

						SymNode previousPrevious = Previous.Previous;

						if	( previousPrevious is SymNodeToken )

						{

							SymNodeToken nodeToken = (SymNodeToken) previousPrevious;

							hasFunctionName = (nodeToken.Token.Class == SymToken.TClass.EClassAlphaNumeric );

						}

					}

					// Check that the brackets are ( and )

					bracketsAreCorrect = ( EmittedElementPrevious.Token.Value == "(" && EmittedElementNext.Token.Value == ")" );

					// Check that the level node has but one child and that it

					// is alphanumeric in nature.

					if	( ChildCountByType( typeof(SymNodeToken) ) > 0 )

					{

						foreach( SymNode child in this )

						{

							if	( child is SymNodeToken )

							{

								SymNodeToken tokenNode = (SymNodeToken) child;

								//

								if	( tokenNode.Token.Class == SymToken.TClass.EClassAlphaNumeric )

								{

									childIsValid = true;

									break;

								}

							}

						}

					}

				}

				bool isFunction = (bracketsAreCorrect && hasFunctionName && childIsValid );

				return isFunction;

			}

		}

		public bool IsSimple

		{

			get

			{

				bool isSimple = false;

				//

				if	( IsFunction )

				{

					isSimple = false;

				}

				else if	( ChildCountNonWhiteSpace == 1 )

				{

					// My child is but a single node...

					isSimple = true;

				}

				else if ( ChildCountWhiteSpace == ChildCount )

				{

					// My children are just whitespace

					isSimple = true;

				}

				else if ( ChildCountLevelNodes == 1 )

				{

					int childCountLevelAndAssociatedEmittedNodes = ChildCountLevelAndAssociatedEmittedNodes;

					int childCount = ChildCount;

					int whiteSpaceCount = ChildCountWhiteSpace;

					//

					if	( (childCount - whiteSpaceCount) == childCountLevelAndAssociatedEmittedNodes )

					{

						// Ignoring the whitespace nodes, all we had was a single level node plus its

						// two associated emitted elements...

						isSimple = true;

					}

				}

				//

				return isSimple;

			}

		}

		public bool IsComplete

		{

			get

			{

				bool complete = false;

				// Must have a next and a previous node. Next and previous must be

				// emitted element nodes

				if	( HasNext && HasPrevious )

				{

					complete = ( Previous is SymTokenBalancerNodeEmittedElement && Next is SymTokenBalancerNodeEmittedElement );

				}

				return complete;

			}

		}

		public bool AreLocalEmittedNodesDiametricallyOposite

		{

			get

			{

				bool ret = false;

				//

				if	( IsComplete )

				{

					SymTokenBalancerNodeEmittedElement previous = (SymTokenBalancerNodeEmittedElement) Previous;

					SymTokenBalancerNodeEmittedElement next = (SymTokenBalancerNodeEmittedElement) Next;

					//

					if	( previous.MatchCriteria.DiametricToken.Equals( next.Token ) )

					{

						// Paranoid

						ret = ( next.MatchCriteria.DiametricToken.Equals( previous.Token ) );

					}

				}

				//

				return ret;

			}

		}

		public SymNodeToken FunctionName

		{

			get

			{

				if	( IsFunction == false )

				{

					throw new ArgumentException( "Level node is not a function node" );

				}

				System.Diagnostics.Debug.Assert( Previous.HasPrevious );

				System.Diagnostics.Debug.Assert( Previous.Previous is SymNodeToken );

				SymNodeToken functionNameToken = (SymNodeToken) Previous.Previous;

				return functionNameToken;

			}

		}

		public SymTokenContainer ChildTokens

		{

			get

			{

				SymTokenContainer ret = new SymTokenContainer();

				//

				foreach( SymNode c in this )

				{

					if	( c is SymNodeToken )

					{

						SymNodeToken t = (SymNodeToken) c;

						ret.Append( t.Token );

					}

				}

				//

				return ret;

			}

		}

		public int ChildCountWhiteSpace

		{

			get

			{

				return CountTokenByType( SymToken.TClass.EClassWhiteSpace );

			}

		}

		public int ChildCountNonWhiteSpace

		{

			get

			{

				return ChildCount - ChildCountWhiteSpace;

			}

		}

		public int ChildCountLevelNodes

		{

			get

			{

				int count = ChildCountByType( typeof(SymTokenBalancerMarkerLevelNode) );

				return count;

			}

		}

		public int ChildCountLevelAndAssociatedEmittedNodes

		{

			get

			{

				int count = 0;

				//

				int index = 0;

				object childLevelNodeObject = ChildByType( typeof(SymTokenBalancerMarkerLevelNode), ref index );

				while( childLevelNodeObject != null )

				{

					// Count is incremented by one each time we find a level node

					SymTokenBalancerMarkerLevelNode childLevelNode = (SymTokenBalancerMarkerLevelNode) childLevelNodeObject;

					++count;

					// It should always have a previous token.

					System.Diagnostics.Debug.Assert( childLevelNode.HasPrevious );

					if	( childLevelNode.Previous is SymTokenBalancerNodeEmittedElement )

					{

						++count;

					}

					// It may have a next node, assuming its complete...

					if	( childLevelNode.HasNext )

					{

						if	( childLevelNode.Next is SymTokenBalancerNodeEmittedElement )

						{

							++count;

						}

					}

					// Move to next child level node

					++index;

					childLevelNodeObject = ChildByType( typeof(SymTokenBalancerMarkerLevelNode), ref index );

				}

				//

				return count;

			}

		}

		public int ChildCountArgumentNodes

		{