/*

* Copyright (c) 2009 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.IO;

using System.Text;

using System.Threading;

using System.Collections;

using SymbianUtils;

using SymbianUtils.Tracer;

using SymbolLib.Generics;

using SymbolLib.Sources.Symbol.File;

using SymbolLib.Sources.Symbol.Engine;

using SymbolLib.Sources.Symbol.Symbol;

using SymbolLib.Sources.Symbol.Collection;

namespace SymbolLib.Sources.Symbol.Parser

{

    #region SymbolCollectionCreator interface

    internal interface SymbolCollectionCreator

    {

        SymbolsForBinary CreateCollection( string aHostFileName );

    }

    #endregion

    #region SymbolEntryCreator interface

    internal interface SymbolEntryCreator

    {

        SymbolSymbol CreateSymbol();

    }

    #endregion

	internal class SymbolFileParser : AsyncTextFileReader

	{

        #region Delegates & events

        public delegate void CollectionCreatedHandler( SymbolsForBinary aCollection );

        public event CollectionCreatedHandler CollectionCreated;

        public delegate bool CollectionCompletedHandler( SymbolsForBinary aCollection );

        public event CollectionCompletedHandler CollectionCompleted;

        public delegate void SymbolCreatedHandler( SymbolSymbol aSymbol );

        public event SymbolCreatedHandler SymbolCreated;

        #endregion

		#region Constructors

		internal SymbolFileParser( SymbolCollectionCreator aCollectionCreator, SymbolEntryCreator aEntryCreator, string aFileName, ITracer aTracer )

		:	base( aFileName, aTracer )

		{

            iCollectionCreator = aCollectionCreator;

            iEntryCreator = aEntryCreator;

		}

		#endregion

        #region Constants

        public const bool KCollectionCompletedAndAbortParsing = false;

        public const bool KCollectionCompletedAndContinueParsing = true;

        #endregion

        #region Parsing API

        public void Read( TSynchronicity aSynchronicity )

        {

            base.StartRead( aSynchronicity );

        }

		#endregion

        #region Properties

        public bool ContainedAtLeastOneCollectionFileName

        {

            get { return iContainedAtLeastOneCollectionFileName; }

        }

        #endregion

        #region From AsyncTextReader

        protected override bool ImmediateAbort()

        {

            return iImmediateAbort;

        }

        protected override void HandleReadStarted()

        {

#if PROFILING

            System.DateTime startTime = DateTime.Now;

            using ( System.IO.StreamReader reader = new StreamReader( this.FileName ) )

            {

                string line = reader.ReadLine();

                while ( line != null )

                {

                    line = reader.ReadLine();

                }

            }

            System.DateTime endTime = DateTime.Now;

            long tickDuration = ( ( endTime.Ticks - startTime.Ticks ) / 100 );

            System.Diagnostics.Debug.WriteLine( "SIMPLE READ COMPLETE - " + tickDuration.ToString( "d6" ) );

#endif

            base.HandleReadStarted();

        }

        protected override void HandleFilteredLine( string aLine )

		{

            if ( aLine != null )

            {

                int len = aLine.Length;

                if ( len > 5 && aLine.Substring( 0, 5 ) == "From " )

			    {

                    aLine = aLine.Substring( 5 ).TrimStart();

                    HandleStartOfNewCollection( aLine );

                }

                else

                {

                    HandleSymbolLine( aLine );

                }

            }

        }

		protected override void HandleReadCompleted()

		{

			try

			{

                OnCollectionCompleted( iCurrentCollection );

			}

			finally

			{

                base.HandleReadCompleted();

			}

		}

		protected override void HandleReadException( Exception aException )

		{

            base.HandleReadException( aException );

            //

            System.Windows.Forms.MessageBox.Show( aException.StackTrace, aException.Message );

		}

		#endregion

		#region Internal methods

        private void OnCollectionCreated( SymbolsForBinary aCollection )

        {

            if ( CollectionCreated != null && aCollection != null )

            {

                CollectionCreated( aCollection );

            }

        }

        private void OnCollectionCompleted( SymbolsForBinary aCollection )

        {

            if ( CollectionCompleted != null && aCollection != null )

            {

                // If returns immediate abort then we will stop parsing

                // straight away.

                iImmediateAbort = ( CollectionCompleted( aCollection ) == KCollectionCompletedAndAbortParsing );

            }

        }

        private void HandleStartOfNewCollection( string aHostFileName )

        {

            // Current collection is now complete

            OnCollectionCompleted( iCurrentCollection );

            // We will create the new collection once we see the first symbol

            iCurrentCollection = null;

            // Cache the name of the new collection

            iCurrentCollectionHostFileName = aHostFileName;

            // We've seen at least one "From" line.

            iContainedAtLeastOneCollectionFileName = true;

        }

        private void HandleSymbolLine( string aLine )

        {

            try

            {

                // If we have not yet made a collection for this symbol, then do so now

                CreateNewCollection();

                SymbolSymbol entry = iEntryCreator.CreateSymbol();

                bool entryOk = entry.Parse( aLine );

                if ( entryOk && SymbolCreated != null )

                {

                    // Notify that we created a symbol

                    SymbolCreated( entry );

                }

            }

            catch( GenericSymbolicCreationException )

            {

#if TRACE

                System.Diagnostics.Debug.WriteLine( "SymbolParseException: " + aLine );

#endif

            }

        }

        private void CreateNewCollection()

        {

            if ( iCurrentCollection == null )

            {

                System.Diagnostics.Debug.Assert( !string.IsNullOrEmpty( iCurrentCollectionHostFileName ) );

                // Combine symbol file drive letter with binary name from the symbol file itself.

                string hostBinaryFileName = Path.GetPathRoot( base.FileName );

                if ( iCurrentCollectionHostFileName.StartsWith( @"\" ) )

                {

                    iCurrentCollectionHostFileName = iCurrentCollectionHostFileName.Substring( 1 );

                }

                hostBinaryFileName = Path.Combine( hostBinaryFileName, iCurrentCollectionHostFileName );

                iCurrentCollection = iCollectionCreator.CreateCollection( hostBinaryFileName );

                OnCollectionCreated( iCurrentCollection );

                iCurrentCollectionHostFileName = string.Empty;

            }

        }

        #endregion

		#region Data members

        private SymbolsForBinary iCurrentCollection = null;

        private readonly SymbolEntryCreator iEntryCreator;

        private readonly SymbolCollectionCreator iCollectionCreator;

        private bool iImmediateAbort = false;

        private string iCurrentCollectionHostFileName = string.Empty;

        private bool iContainedAtLeastOneCollectionFileName = false;

        #endregion

	}

}