/*

* 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.Threading;

using System.Collections;

using SymBuildParsingLib.Utils;

using SymBuildParsingLib.Lexer;

using SymBuildParsingLib.Token;

namespace SymBuildParsingLib.Grouper

{

	public class SymGrouper

	{

		#region Enumerations

		public enum TEvent

		{

			EEventGroupingStarted = 0,

			EEventGroupingPaused,

			EEventGroupingTokenReady,

			EEventGroupingComplete

		};

		#endregion

		#region Observer interface

		public delegate void GrouperObserver( SymGrouper aGrouper, TEvent aEvent, SymToken aToken );

		#endregion

		#region Events

		public event GrouperObserver GrouperObservers;

		#endregion

		#region Constructors & destructor

		public SymGrouper( SymLexer aLexer )

		{

			// The mastermind implements all the logic for grouping token runs into

			// more sophisticated/logical token groupings.

			iMastermind.MastermindObservers += new SymGrouperMastermind.MastermindObserver( MastermindObserver );

			// Observe the lexer for tokens

			aLexer.LexerObservers += new SymLexer.LexerObserver( LexerTokenHandler );

			// Prepare worker thread

			ThreadStart threadStart = new ThreadStart( DoGrouping );

			iWorkerThread = new Thread( threadStart );

			iWorkerThread.Name = "SymGrouperWorkerThread";

			iWorkerThread.IsBackground = true;

			iWorkerThread.Start();

		}

		#endregion

		#region Internal methods

		private void ReportEvent( TEvent aEvent, SymToken aToken )

		{

			if	( GrouperObservers != null )

			{

				GrouperObservers( this, aEvent, aToken );

			}

		}

		#endregion

		#region Internal threading related

		private void DoGrouping()

		{

			ReportEvent( TEvent.EEventGroupingStarted, SymToken.NullToken() );

			bool lexerFinished = false;

			do

			{

				// Count how many tokens we have...

				lock( this )

				{

					iMastermind.PerformGrouping();

					lexerFinished = iLexerFinished;

				}

				// Wait until there are more items to process

				if	( lexerFinished == false )

				{

					ReportEvent( TEvent.EEventGroupingPaused, SymToken.NullToken() );

					iSemaphore.Wait();

					ReportEvent( TEvent.EEventGroupingStarted, SymToken.NullToken() );

				}

			} 

			while ( lexerFinished == false );

			ReportEvent( TEvent.EEventGroupingComplete, SymToken.NullToken() );

		}

		#endregion

		#region Event handlers

		private void LexerTokenHandler( SymLexer aLexer, SymLexer.TEvent aEvent, SymToken aToken )

		{

			if	( aEvent == SymLexer.TEvent.EEventLexingToken )

			{

				// Store the token

				lock( this )

				{

					iMastermind.EnqueueLexedToken( aToken );

				}

				// and signal the worker thread if it is waiting...

				if	( iSemaphore.Count == 0 )

				{

					iSemaphore.Signal();

				}

			}

			else if ( aEvent == SymLexer.TEvent.EEventLexingComplete )

			{

				lock( this )

				{

					iLexerFinished = true;

				}

				// and signal the worker thread if it is waiting...

				if	( iSemaphore.Count == 0 )

				{

					iSemaphore.Signal();

				}

			}

		}

		private void MastermindObserver( SymGrouperMastermind.TEvent aEvent, SymToken aGroupedToken )

		{

			// We've received a token from the grouper. Pass it on to our observer to handle.

			if	( aEvent == SymGrouperMastermind.TEvent.EEventGroupTokenReady )

			{

				ReportEvent( TEvent.EEventGroupingTokenReady, aGroupedToken );

			}

		}

		#endregion

		#region Data members

		private Thread iWorkerThread;

		private SymGrouperMastermind iMastermind = new SymGrouperMastermind();

		private SymSemaphore iSemaphore = new SymSemaphore( 0, 1 );

		private bool iLexerFinished = false;

		#endregion

	}

}