/*
* 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.Token;
using SymBuildParsingLib.Tree;
using SymBuildParsingLib.Common.Objects;
using SymbianTree;

namespace SymBuildParsingLib.Parser.Framework.Utils
{
	public class SymFunctionParser : SymTokenBalancer
	{
		#region Observer interface
		public delegate void ArgumentAvailable( SymArgument aArgument, SymToken aDelimitingToken );
		#endregion

		#region Events
		public event ArgumentAvailable EventArgumentAvailableHandler;
		#endregion

		#region Constructors & destructor
		public SymFunctionParser()
		{
		}
		#endregion

		#region API
		public virtual void RegisterFunctionParserTokens()
		{
			// Base class registration
			RegisterBalancerTokens();

			// These are the important tokens relating to function arguments
			SymToken bracketTokenOpening = new SymToken( "(", SymToken.TClass.EClassSymbol, SymToken.TType.ETypeUnidentified );
			SymToken bracketTokenClosing = new SymToken( ")", SymToken.TClass.EClassSymbol, SymToken.TType.ETypeUnidentified );
			SymToken squareBracketTokenOpening = new SymToken( "[", SymToken.TClass.EClassSymbol, SymToken.TType.ETypeUnidentified );
			SymToken squareBracketTokenClosing = new SymToken( "]", SymToken.TClass.EClassSymbol, SymToken.TType.ETypeUnidentified );
			SymToken templateBracketTokenOpening = new SymToken( "<", SymToken.TClass.EClassSymbol, SymToken.TType.ETypeUnidentified );
			SymToken templateBracketTokenClosing = new SymToken( ">", SymToken.TClass.EClassSymbol, SymToken.TType.ETypeUnidentified );

			// We want to track levels for square brackets and template arguments in order to ensure we balance correctly.
			// We don't want to remove any redundancy here as these may have special meaning.
			RegisterOpeningToken( squareBracketTokenOpening, squareBracketTokenClosing, true, true, TLevelExpectations.ELevelExpectationsAboveLevelNumber, 0, TAssociatedBehaviour.EBehaviourNone );
			RegisterClosingToken( squareBracketTokenClosing, squareBracketTokenOpening, true, true, TLevelExpectations.ELevelExpectationsAboveLevelNumber, 0, TAssociatedBehaviour.EBehaviourNone );
			RegisterOpeningToken( templateBracketTokenOpening, templateBracketTokenClosing, true, true, TLevelExpectations.ELevelExpectationsAboveLevelNumber, 0, TAssociatedBehaviour.EBehaviourNone );
			RegisterClosingToken( templateBracketTokenClosing, templateBracketTokenOpening, true, true, TLevelExpectations.ELevelExpectationsAboveLevelNumber, 0, TAssociatedBehaviour.EBehaviourNone );

			// Define our argument separation token(s).
			TAssociatedBehaviour flags = TAssociatedBehaviour.EBehaviourNone;
			flags |= TAssociatedBehaviour.EBehaviourCreateSubTree;
			flags |= TAssociatedBehaviour.EBehaviourRemoveReduntantBracketing;
			//
			SymToken commaDelimiterToken = new SymToken( ",", SymToken.TClass.EClassSymbol, SymToken.TType.ETypeUnidentified );
			RegisterArgumentSeparatorToken( commaDelimiterToken, new SymTokenBalancerMatchCriteria( SymToken.NullToken(), false, true, TLevelExpectations.ELevelExpectationsAtLevel, 1, flags ) );
			RegisterArgumentSeparatorToken( commaDelimiterToken, new SymTokenBalancerMatchCriteria( SymToken.NullToken(), true, true, TLevelExpectations.ELevelExpectationsAboveLevelNumber, 1, TAssociatedBehaviour.EBehaviourNone ) );
		}

		public virtual SymArgument MakeArgument()
		{
			SymNode levelNodeToObtainArgumentsFrom = CurrentNode;

			// Try to work out whether we have a leve node at the current
			// scope which should be preferred t
			object levelNodeObject = levelNodeToObtainArgumentsFrom.ChildByType( typeof(SymTokenBalancerMarkerLevelNode) );
			if	( levelNodeObject != null )
			{
				levelNodeToObtainArgumentsFrom = (SymNode) levelNodeObject;
			}

			return MakeArgument( levelNodeToObtainArgumentsFrom );
		}

		public virtual SymArgument MakeArgument( SymNode aLevelToMakeArgumentsFrom )
		{
			SymArgument argument = new SymArgument();

			// Convert (recursively) any emitted elements to real tokens
			if	( aLevelToMakeArgumentsFrom is SymTokenBalancerMarkerLevelNode )
			{
				SymTokenBalancerMarkerLevelNode levelNode = (SymTokenBalancerMarkerLevelNode) aLevelToMakeArgumentsFrom;
				levelNode.ConvertEmittedElementsToRealTokenNodes( true /*recurse*/ );
			}

			// Now actually obtain the argument tokens
			int count = aLevelToMakeArgumentsFrom.ChildCount;
			int i = 0;
			//
			while( i < count )
			{
				SymNode n = aLevelToMakeArgumentsFrom[ 0 ];

				// We always remove any other nodes, irrespective of their type.
				// This is to ensure that the document tree does not get cluttered
				// with redundant argument token info.
				n.Remove();

				// Now we decide what to do...
				if	( n is SymTokenBalancerMarkerArgumentNode )
				{
					// We've reached the argument itself. This is the
					// signal to stop processing. We remove the argument node
					// since its not relevant to the production of the tree.
					break;
				}
				else if ( n is SymTokenBalancerMarkerLevelNode )
				{
					// Create a new sub-argument node and copy over the 
					// children.
					SymTokenBalancerMarkerLevelNode levelNode = (SymTokenBalancerMarkerLevelNode) n;
					SymArgumentSubLevel subLevel = levelNode.AsArgumentSubLevel( true );
					argument.CurrentNode.Add( subLevel );
				}
				else if ( n is SymTokenBalancerNodeEmittedElement )
				{
					System.Diagnostics.Debug.Assert( false ); // shouldn't get here anymore!
				}
				else if	( n is SymNodeToken )
				{
					// Node is implicitly removed since it transfers
					// from one tree to another.
					argument.CurrentNode.Add( n );
				}

				count = aLevelToMakeArgumentsFrom.ChildCount;
			}
			//
			SymTokenUtils.RemoveWhiteSpace( argument, true );
			return argument;
		}

		public string MakeFunctionName()
		{
			StringBuilder name = new StringBuilder();

			// Pull out all the level one tokens from the balancer. These form
			// the function/define name.
			foreach( SymNode n in DocumentTree )
			{
				if	( n is SymTokenBalancerMarkerNode )
				{
					// Not part of the name
					break;
				}
				else if ( n is SymTokenBalancerNodeEmittedElement )
				{
					// Not part of the name - also, this is indicator to stop iterating!
					break;
				}
				else if ( n is SymNodeToken )
				{
					SymNodeToken tokenNode = (SymNodeToken) n;
					name.Append( tokenNode.Token.Value );
				}
			}

			return name.ToString();
		}
		#endregion

		#region API - registration
		public void RegisterArgumentSeparatorToken( SymToken aToken, SymTokenBalancerMatchCriteria aCriteria )
		{
			SymToken copy = new SymToken( aToken );
			copy.Tag = aCriteria;
			//
			if	( IsTokenExactMatch( copy, iArgumentSeparators ) == false )
			{
				iArgumentSeparators.Append( copy );
			}
		}
		#endregion

		#region From SymTokenBalancer
		public override bool OfferToken( SymToken aToken )
		{
			bool consumed = false;
			int currentLevelNumber = CurrentLevelNumber;

			// Check for bracket matches
			SymTokenBalancerMatchCriteria tokenExtendedInfo;
			if	( IsArgumentSeparatorMatch( aToken, out tokenExtendedInfo, currentLevelNumber ) )
			{
				ArgumentStarted( aToken, tokenExtendedInfo );
				consumed = true;
			}
			
			// If it wasn't an arg token or it was, but it wasn't at the 
			// correct (expected) level, then give it to the base class
			// to handle.
			if	( consumed == false )
			{
				consumed = base.OfferToken( aToken );
			}
			//
			return consumed;
		}
		#endregion

		#region Notification framework
		protected virtual void NotifyArgumentAvailable( SymArgument aArgument, SymToken aDelimitingToken )
		{
			if	( EventArgumentAvailableHandler != null )
			{
				EventArgumentAvailableHandler( aArgument, aDelimitingToken );
			}
		}
		#endregion

		#region New internal framework
		protected virtual void ArgumentStarted( SymToken aToken, SymTokenBalancerMatchCriteria aCriteria )
		{
			System.Diagnostics.Debug.Write( aToken.Value );

			int currentLevelNumber = CurrentLevelNumber;

			// Perform any base class end level behaviour
			PerformEndLevelBehaviour( CurrentNode, aCriteria );

			// Add the emit node (the rest of the code will work out whether it needs to quote it when the final
			// tree is formed).
			SymTokenBalancerNodeEmittedElement argEmitElement = new SymTokenBalancerNodeEmittedElement( aToken, aCriteria );
			DocumentTree.CurrentNode.Add( argEmitElement );

			// Always add the argument node
			SymTokenBalancerMarkerArgumentNode argNode = new SymTokenBalancerMarkerArgumentNode( aCriteria );
			DocumentTree.CurrentNode.Add( argNode );

			if	( aCriteria.IsAssociatedBehaviourCreateSubTree )
			{
				// Make a new argument definition based upon the tokens we have in
				// the main document tree.
				SymArgument argument = MakeArgument( DocumentTree.CurrentNode );

				// Then notify the observer
				NotifyArgumentAvailable( argument, aToken );
			}
		}
		#endregion

		#region Internal utility methods
		protected bool IsArgumentSeparatorMatch( SymToken aToken, out SymTokenBalancerMatchCriteria aCriteria, int aLevelNumber )
		{
			aCriteria = null;
			bool matchFound = false;
			//
			int index = iArgumentSeparators.IndexOf( aToken );
			while( index >= 0 && matchFound == false )
			{
				SymToken token = iArgumentSeparators[ index ];
				System.Diagnostics.Debug.Assert ( token.Tag != null && token.Tag is SymTokenBalancerMatchCriteria );
				SymTokenBalancerMatchCriteria criteria = (SymTokenBalancerMatchCriteria) token.Tag;

				if	( criteria.Matches( aLevelNumber ) )
				{
					aCriteria = criteria;
					matchFound = true;
				}
				else
				{
					index = iArgumentSeparators.IndexOf( aToken, index+1 );
				}
			}

			return matchFound;
		}

		#endregion

		#region Data members
		private SymTokenContainer iArgumentSeparators = new SymTokenContainer();
		#endregion
	}
}