/*

* 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 SymBuildParsingLib.Tree;

using SymBuildParsingLib.Token;

using SymBuildParsingLib.Parser.Framework;

using SymBuildParsingLib.Parser.Framework.Utils;

using SymBuildParsingLib.Parser.Framework.Workers;

using SymBuildParsingLib.Parser.PreProcessor.Nodes;

using SymBuildParsingLib.Common.Objects;

using SymbianTree;

namespace SymBuildParsingLib.Parser.PreProcessor.Workers

{

	public sealed class SymPreProcessorWorkerDefine : SymParserWorkerConsumer

	{

		#region Constructors & destructor

		public SymPreProcessorWorkerDefine( SymParserWorkerContext aContext )

			: base( aContext, SymToken.TClass.EClassNewLine )

		{

			iFunctionParser.RegisterFunctionParserTokens();

			// Set up event handlers

			iFunctionParser.EventArgumentAvailableHandler += new SymBuildParsingLib.Parser.Framework.Utils.SymFunctionParser.ArgumentAvailable( FunctionParserEventArgumentAvailableHandler );

			iFunctionParser.EventLevelStarted += new SymBuildParsingLib.Token.SymTokenBalancer.LevelChangeEventHandler( TokenBalancerEventLevelStarted );

			iFunctionParser.EventLevelFinished += new SymBuildParsingLib.Token.SymTokenBalancer.LevelChangeEventHandler( TokenBalancerEventLevelFinished );

			iFunctionParser.EventLevelsBalanced += new SymBuildParsingLib.Token.SymTokenBalancer.LevelsBalancedEventHandler( TokenBalancerEventLevelsBalanced );

			iFunctionParser.EventLevelsImbalanced += new SymBuildParsingLib.Token.SymTokenBalancer.LevelsImbalancedEventHandler( TokenBalancerEventLevelsImbalanced );

		}

		#endregion

		#region Internal enumerations

		private enum TState

		{

			EStateInitialWhiteSpace = 0,

			EStateDefineName,

			EStateDefineArguments,

			EStateMiddleWhiteSpace,

			EStateDefineValue

		}

		#endregion

		#region From SymParserWorker

		public override SymParserWorker.TTokenConsumptionType OfferToken( SymToken aToken )

		{

			SymParserWorker.TTokenConsumptionType ret = SymParserWorker.TTokenConsumptionType.ETokenNotConsumed;

			//

			while( ret == SymParserWorker.TTokenConsumptionType.ETokenNotConsumed )

			{

				TState currentState = State;

				switch( State )

				{

					case TState.EStateInitialWhiteSpace:

						ret = OnStateInitialWhiteSpace( aToken );

						break;

					case TState.EStateDefineName:

						ret = OnStateDefineName( aToken );

						break;

					case TState.EStateDefineArguments:

						ret = OnStateDefineArguments( aToken );

						break;

					case TState.EStateMiddleWhiteSpace:

						ret = OnStateMiddleWhiteSpace( aToken );

						break;

					case TState.EStateDefineValue:

						ret = OnStateDefineValue( aToken );

						break;

					default:

						break;

				}

				TState newState = State;

				bool statesDidNotChange = ( currentState == newState );

				if	( statesDidNotChange )

				{

					// If the state handlers didn't want the token, then we 

					// offer it to the base class instead

					if	( ret == SymParserWorker.TTokenConsumptionType.ETokenNotConsumed )

					{

						ret = base.OfferToken( aToken );

					}

				}

			}

			return ret;

		}

		#endregion

		#region From SymParserWorkerConsumer

		protected override void HandleTerminatingConditionMatch( SymToken aToken )

		{

			switch( State )

			{

			case TState.EStateInitialWhiteSpace:

				break;

			case TState.EStateDefineName:

				MakeDefineName();

				break;

			case TState.EStateDefineArguments:

				break;

			case TState.EStateMiddleWhiteSpace:

				break;

			case TState.EStateDefineValue:

				MakeDefineValue();

				break;

			default:

				break;

			}

			// Do we have a valid define?

			if	( iDefine.IsValid )

			{

				SymNodePreProcessorDefine defineNode = new SymNodePreProcessorDefine();

				defineNode.DefineDefinition = iDefine;

				//

				WorkerContext.CurrentNode.Add( defineNode );

				WorkerContext.DefineDirectory.Add( iDefine );

			}

		}

		#endregion

		#region Internal properties

		private TState State

		{

			get { return iState; }

			set { iState = value; }

		}

		#endregion

		#region Internal state handlers

		private SymParserWorker.TTokenConsumptionType OnStateInitialWhiteSpace( SymToken aToken )

		{

			SymParserWorker.TTokenConsumptionType ret = SymParserWorker.TTokenConsumptionType.ETokenNotConsumed;

			//

			if	( aToken.Class == SymToken.TClass.EClassWhiteSpace )

			{

				// Skip leading whitespace

				ret = SymParserWorker.TTokenConsumptionType.ETokenConsumed;

			}

			else

			{

				// Change state

				State = TState.EStateDefineName;

				ResetTokenContainer();

			}

			//

			return ret;

		}

		private SymParserWorker.TTokenConsumptionType OnStateDefineName( SymToken aToken )

		{

			SymParserWorker.TTokenConsumptionType ret = SymParserWorker.TTokenConsumptionType.ETokenNotConsumed;

			//

			if	( aToken.Class == SymToken.TClass.EClassWhiteSpace )

			{

				// Got some whitespace - so we're going to bail

				MakeDefineName();

				State = TState.EStateMiddleWhiteSpace;

			}

			else if ( aToken.Class == SymToken.TClass.EClassNewLine || aToken.Class == SymToken.TClass.EClassContinuation )

			{

				// Do nothing - new line is handled by base class (so we must not consume it)

				// and continuations are ignored.

			}

			else

			{

				// Keep reading tokens until we hit some whitespace

				bool consumed = iFunctionParser.OfferToken( aToken );

				if	( consumed == true )

				{

					ret = SymParserWorker.TTokenConsumptionType.ETokenConsumed;

				}

			}

			//

			return ret;

		}

		private SymParserWorker.TTokenConsumptionType OnStateDefineArguments( SymToken aToken )

		{

			SymParserWorker.TTokenConsumptionType ret = SymParserWorker.TTokenConsumptionType.ETokenNotConsumed;

			//

			if	( aToken.Class == SymToken.TClass.EClassWhiteSpace && iFunctionParser.CurrentLevelNumber == 0 )

			{

				// Got some whitespace - so we're going to bail

				MakeDefineArgument();

				State = TState.EStateMiddleWhiteSpace;

			}

			else if ( aToken.Class == SymToken.TClass.EClassNewLine || aToken.Class == SymToken.TClass.EClassContinuation )

			{

				// Do nothing - new line is handled by base class (so we must not consume it)

				// and continuations are ignored.

			}

			else

			{

				// Keep reading tokens until we hit some whitespace

				bool consumed = iFunctionParser.OfferToken( aToken );

				if	( consumed == true )

				{

					ret = SymParserWorker.TTokenConsumptionType.ETokenConsumed;

				}

			}

			//

			return ret;

		}

		private SymParserWorker.TTokenConsumptionType OnStateMiddleWhiteSpace( SymToken aToken )

		{

			SymParserWorker.TTokenConsumptionType ret = SymParserWorker.TTokenConsumptionType.ETokenNotConsumed;

			//

			if	( aToken.Class == SymToken.TClass.EClassWhiteSpace )

			{

				// Skip leading whitespace

				ret = SymParserWorker.TTokenConsumptionType.ETokenConsumed;

			}

			else

			{

				// Change state

				State = TState.EStateDefineValue;

				ResetTokenContainer();

			}

			//

			return ret;

		}

		private SymParserWorker.TTokenConsumptionType OnStateDefineValue( SymToken aToken )

		{

			SymParserWorker.TTokenConsumptionType ret = SymParserWorker.TTokenConsumptionType.ETokenNotConsumed;

			//

			if	( aToken.Class != SymToken.TClass.EClassNewLine )

			{

				iTokens.Append( aToken );

				ret = SymParserWorker.TTokenConsumptionType.ETokenConsumed;

			}

			//

			return ret;

		}

		#endregion

		#region Internal token balancer/function parser event handlers

		private void FunctionParserEventArgumentAvailableHandler( SymArgument aArgument, SymToken aDelimitingToken )

		{

			MakeDefineArgument( aArgument );

		}

		private void TokenBalancerEventLevelStarted( int aLevelCount, SymNode aOldLevel, SymNode aNewLevel )

		{

			switch( State )

			{

			case TState.EStateDefineName:

				MakeDefineName();

				State = TState.EStateDefineArguments;

				break;

			case TState.EStateDefineArguments:

				break;

			case TState.EStateDefineValue:

			case TState.EStateInitialWhiteSpace:

			case TState.EStateMiddleWhiteSpace:

			default:

				System.Diagnostics.Debug.Assert( false );

				break;

			}

		}

		private void TokenBalancerEventLevelFinished( int aLevelCount, SymNode aOldLevel, SymNode aNewLevel )

		{

			switch( State )

			{

				case TState.EStateDefineName:

					MakeDefineName();

					State = TState.EStateDefineArguments;

					break;

				case TState.EStateDefineArguments:

					if	( aLevelCount == 0 )

					{

						MakeDefineArgument();

						State = TState.EStateMiddleWhiteSpace;

					}

					break;

				case TState.EStateDefineValue:

				case TState.EStateInitialWhiteSpace:

				case TState.EStateMiddleWhiteSpace:

				default:

					System.Diagnostics.Debug.Assert( false );

					break;

			}

		}

		private void TokenBalancerEventLevelsBalanced()

		{

		}

		private void TokenBalancerEventLevelsImbalanced()

		{

			//TODO

		}

		#endregion

		#region Internal temp buffer related methods

		public void ResetTokenContainer()

		{

			iTokens.Reset();

			iFunctionParser.Reset();

		}

		public void AddToken( SymToken aToken )

		{

			iTokens.Append( aToken );

		}

		#endregion

		#region Misc internal helpers

		private void MakeDefineName()

		{

			iDefine.Name = iFunctionParser.MakeFunctionName();

		}

		private void MakeDefineArgument()

		{

			SymArgument argument = iFunctionParser.MakeArgument();

			MakeDefineArgument( argument );

		}

		private void MakeDefineArgument( SymArgument aArgument )

		{

			// Convert generic argument into define-specific argument

			SymDefineArgument defineArgument = new SymDefineArgument( aArgument );

			iDefine.AddArgument( defineArgument );

		}

		private void MakeDefineValue()

		{

			iDefine.Value = iTokens;

			iTokens = new SymTokenContainer();

		}

		#endregion

		#region Data members

		private TState iState = TState.EStateInitialWhiteSpace;

		private SymDefineDefinition iDefine = new SymDefineDefinition();

		private SymTokenContainer iTokens = new SymTokenContainer();

		private SymFunctionParser iFunctionParser = new SymFunctionParser();

		#endregion

	}

}