#define SHOW_TOKENS/*
* 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.Collections;
using System.Threading;
using System.Reflection;
using SymBuildParsingLib.Tree;
using SymBuildParsingLib.Utils;
using SymBuildParsingLib.Grouper;
using SymBuildParsingLib.Lexer;
using SymBuildParsingLib.Token;
using SymBuildParsingLib.Parser.Framework.Workers;
using SymBuildParsingLib.Parser.Framework.Document;
using SymbianTree;

namespace SymBuildParsingLib.Parser.Framework.Parser
{
	public abstract class SymParserBase
	{
		#region Event enumerations
		public enum TEvent
		{
			EEventStaringLexing = 0,
			EEventStaringGrouping,
			EEventParsingComplete
		};
		#endregion

		#region Observer interface
		public delegate void ParserObserver( SymParserBase aParser, TEvent aEvent );
		#endregion

		#region Events
		public event ParserObserver ParserObservers;
		#endregion

		#region Constructors and destructor
		public SymParserBase( SymParserDocument aDocument )
		{
			// Store the document and initialise the document's 
			// parser reference
			iDocument = aDocument;
			iDocument.Context.Parser = this;

			// The lexer reads the tokens from the stream and performs minimal
			// (very basic) grouping.
			iLexer = new SymLexer( iDocument.Context.FileName );

			// We observe the lexer in order to know when all the input data
			// has been consumed from the source file.
			iLexer.LexerObservers += new SymLexer.LexerObserver( HandleLexerEvent );

			// The grouper performs more sophisticated grouping based upon
			// simple C++/C rules. It observes the lexer for tokens.
			iGrouper = new SymGrouper( iLexer );

			// We observe the grouper in order to obtain the grouped tokens
			// which we will parse to form the tree.
			iGrouper.GrouperObservers += new SymGrouper.GrouperObserver( HandleGrouperEvent );

			// Create the thread for the parser
			iWorkerThread = new Thread( new System.Threading.ThreadStart( BuildParserTree ) );
			PrepareWorkerThread();

			// Create any initial required workers
			PrepareInitialWorkers();
		}
		#endregion

		#region API
		public void Parse()
		{
			// Starting the lexer will implicitly start the grouper
			// as the grouper is already awaiting the lexer's output
			// tokens. Tokens will arrive into the iGroupedTokens data
			// member. This call is asynchronous.
			iLexer.Lex();
		}
		#endregion

		#region Clone API
		public SymParserBase CarbonCopy( object[] aArguments )
		{
			// NB. Should use object.Clone with custom IClonable charactersitics?
			System.Type type = this.GetType();
			object objectInstance = Activator.CreateInstance( type, aArguments );
			//
			if	( !(objectInstance is SymParserBase) )
			{
				throw new Exception( "Unexpected object type during Carbon Copy operation" );
			}
			//
			SymParserBase parser = (SymParserBase) objectInstance;
			return parser;
		}
		#endregion

		#region Abstract API
		protected virtual void PrepareInitialWorkers()
		{
		}

		protected virtual void HandleParserToken( SymToken aToken )
		{
			// Try to dish the token out to the workers. Give
			// the token to the highest priority worker initially.
			// Keep trying to offer it until one of the workers
			// consumes it.
			int count = iWorkers.Count;
			for( int i=0; i<count; i++ )
			{
				SymParserWorker worker = (SymParserWorker) iWorkers[ i ];
				SymParserWorker.TTokenConsumptionType consumptionType = worker.OfferToken( aToken );
				//
				if	( consumptionType == SymParserWorker.TTokenConsumptionType.ETokenConsumed )
				{
					break;
				}
			}
		}
		#endregion

		#region Abstract properties
		protected abstract string ParserName { get; }
		#endregion

		#region Properties
		public string FileName
		{
			get { return iLexer.FileName; }
		}

		public SymParserDocument Document
		{
			get { return iDocument; }
		}
		#endregion

		#region Worker related
		public int WorkerCount
		{
			get { return iWorkers.Count; }
		}

		public void QueueWorker( SymParserWorker aWorker )
		{
			// Insert into sorted order
			int count = iWorkers.Count;
			for( int i=0; i<count; i++ )
			{
				SymParserWorker worker = (SymParserWorker) iWorkers[ i ];
				int existingPriority = worker.Priority;
				//
				if	( aWorker.Priority >= existingPriority )
				{
					iWorkers.Insert( i, aWorker );
					return;
				}
			}

			// First entry - just append it...
			iWorkers.Add( aWorker );
		}
		#endregion

		#region Internal Properties
		protected SymTokenContainer GroupedTokens
		{
			get { return iGroupedTokens; }
		}
		#endregion

		#region Internal methods
		private void BuildParserTree()
		{
			// Pull a token from the source buffer
			do
			{
				int tokenCount = 0;
				//
				do
				{
					SymToken token = null;

					// Try to get the head token (if there is one)
					lock( iGroupedTokens )
					{
						tokenCount = iGroupedTokens.Count;
						if	( tokenCount > 0 )
						{
							token = iGroupedTokens.PopHead();
						}
					}

					// Then process it
					if	( token != null )
					{
#if SHOW_TOKENS
						System.Diagnostics.Debug.WriteLine( "BuildParserTree() - next token is: [" + token.Value + "]");
#endif
						HandleParserToken( token );
					}
				} 
				while ( tokenCount > 0 );

				// We've processed all the tokens we had so far... put us to sleep
				//System.Diagnostics.Debug.WriteLine( "Parser.BuildParserTree() - no more tokens - waiting on semaphore..." );
				iSemaphore.Wait();
				//System.Diagnostics.Debug.WriteLine( "Parser.BuildParserTree() - AWAKE!" );
			}
			while( true );

		}

		private void PrepareWorkerThread()
		{
			System.Random randomNumberGen = new Random( System.Environment.TickCount );
			int uniquePostfix = randomNumberGen.Next();
			//
			string workerThreadName = ParserName + uniquePostfix.ToString("d8");
			iWorkerThread.Name = workerThreadName;
			iWorkerThread.IsBackground = true;
			iWorkerThread.Start();
		}
		private void ReportEvent( TEvent aEvent )
		{
			if	( ParserObservers != null )
			{
				ParserObservers( this, aEvent );
			}
		}
		private void NewGroupedTokenArrived( SymToken aToken )
		{
			lock( this )
			{
				iGroupedTokens.Append( aToken );
				//
				if	( iSemaphore.Count == 0 )
				{
					iSemaphore.Signal();
				}
			}
		}
		#endregion

		#region Event handlers
		private void HandleLexerEvent( SymLexer aLexer, SymLexer.TEvent aEvent, SymToken aToken )
		{
			switch( aEvent )
			{
				case SymLexer.TEvent.EEventLexingStarted: 
					ReportEvent( TEvent.EEventStaringLexing );
					break;
				case SymLexer.TEvent.EEventLexingNewLine: 
					break;
				case SymLexer.TEvent.EEventLexingComplete: 
					break;
				default:
					break;
			}
		}

		private void HandleGrouperEvent( SymGrouper aGrouper, SymGrouper.TEvent aEvent, SymToken aGroupedToken )
		{
			switch( aEvent )
			{
				case SymGrouper.TEvent.EEventGroupingStarted: 
					ReportEvent( TEvent.EEventStaringGrouping );
					break;
				case SymGrouper.TEvent.EEventGroupingPaused:
					break;
				case SymGrouper.TEvent.EEventGroupingComplete: 
					ReportEvent( TEvent.EEventParsingComplete );
					break;
				case SymGrouper.TEvent.EEventGroupingTokenReady:
					NewGroupedTokenArrived( aGroupedToken );
					break;
				default:
					break;
			}
		}
		#endregion

		#region Data members
		private readonly Thread iWorkerThread;
		private readonly SymGrouper iGrouper;
		private readonly SymLexer iLexer;
		private readonly SymParserDocument iDocument;
		private SymTokenContainer iGroupedTokens = new SymTokenContainer();
		private ArrayList iWorkers = new ArrayList( 4 );
		private SymSemaphore iSemaphore = new SymSemaphore( 0, 1 );
		#endregion
	}
}