/*

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

using SymBuildParsingLib.Lexer;

using SymBuildParsingLib.Utils;

namespace SymBuildParsingLib.Lexer

{

	public class SymLexer : ISymLexerPositionObserver

	{

		#region Enumerations

		public enum TEvent

		{

			EEventLexingStarted = 0,

			EEventLexingNewLine,

			EEventLexingToken,

			EEventLexingComplete

		};

		#endregion

		#region Observer interface

		public delegate void LexerObserver( SymLexer aLexer, TEvent aEvent, SymToken aToken );

		#endregion

		#region Events

		public event LexerObserver LexerObservers;

		#endregion

		#region Constructors & destructor

		public SymLexer( string aFileName )

		{

			iStream = new SymStream( aFileName );

			//

			PrepareDefaultWorkers();

		}

		#endregion

		#region API

		public void Lex()

		{

			StartWorkerThread();

		}

		internal void RegisterWorker( SymLexerWorker aWorker )

		{

			iWorkers.Add( aWorker );

		}

		internal void FlushToken( SymToken aToken )

		{

			ReportEvent( TEvent.EEventLexingToken, aToken );

		}

		#endregion

		#region Properties

		public string FileName

		{

			get { return iStream.FileName; }

		}

		internal SymStream Stream

		{

			get { return iStream; }

		}

		internal SymTextPosition CurrentPosition

		{

			get { return iPositionProvider.CurrentPosition; }

		}

		#endregion

		#region Internal threading related

		private void DoLexing()

		{

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

			while( !Stream.EOF )

			{

				char character = Stream.ReadChar();

				ProcessCharacter( character );

			}

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

		}

		private void StartWorkerThread()

		{

			lock( this )

			{

				if	( iWorkerThread == null )

				{

					ThreadStart threadStart = new ThreadStart( DoLexing );

					iWorkerThread = new Thread( threadStart );

					iWorkerThread.Name = "SymLexerWorkerThread";

					iWorkerThread.IsBackground = true;

					iWorkerThread.Priority = ThreadPriority.BelowNormal;

					iWorkerThread.Start();

				}

			}

		}

		#endregion

		#region Internal methods

		private void PrepareDefaultWorkers()

		{

			SymLexerWorkerLine workerLine = new SymLexerWorkerLine( this );

			RegisterWorker( workerLine);

			iPositionProvider = workerLine;

			//

			SymLexerWorkerWord workerWord = new SymLexerWorkerWord( this );

			RegisterWorker( workerWord );

		}

		private void ProcessCharacter( char aCharacter )

		{

			int count = iWorkers.Count;

			//

			for( int i=0; i<count; i++ )

			{

				SymLexerWorker worker = (SymLexerWorker) iWorkers[ i ];

				bool consumed = worker.ProcessCharacter( aCharacter );

				//

				if	( consumed )

				{

					break;

				}

			}

		}

		private void ReportEvent( TEvent aEvent, SymToken aToken )

		{

			if	( LexerObservers != null )

			{

				LexerObservers( this, aEvent, aToken );

			}

		}

		#endregion

		#region ISymLexerPositionObserver Members

		public void HandleEndOfLineDetected( SymTextPosition aEOLPosition )

		{

			// Report to children

			int count = iWorkers.Count;

			for( int i=0; i<count; i++ )

			{

				SymLexerWorker worker = (SymLexerWorker) iWorkers[ i ];

				worker.StartedNewLine( aEOLPosition );

			}

			// Add a token for the new line - do this after reporting the

			// event to the children so that they can flush any data

			// they have before we append the new line.

			SymToken token = new SymToken( "", SymToken.TClass.EClassNewLine, aEOLPosition );

			FlushToken( token );

			// Report new line event

			ReportEvent( TEvent.EEventLexingNewLine, token );

		}

		#endregion

		#region Data members

		private SymStream iStream;

		private Thread iWorkerThread;

		private ISymLexerPositionProvider iPositionProvider;

		private ArrayList iWorkers = new ArrayList( 4 );

		#endregion

	}

}