/*

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

using System.Text;

using System.IO;

using SymbianUtils;

using SymbianUtils.Tracer;

using SymbianUtils.FileTypes;

using SymbianStructuresLib.Debug.Symbols;

using SymbianStructuresLib.CodeSegments;

using SymbianDebugLib.Entity;

using SymbianDebugLib.PluginAPI;

using SymbianCodeLib.SourceManagement.Source;

using SymbianCodeLib.SourceManagement.Provisioning;

namespace SymbianCodeLib.DbgEnginePlugin

{

    internal class CodePrimer : DbgPluginPrimer

    {

        #region Constructors

        public CodePrimer( CodePlugin aPlugin )

            : base( aPlugin )

		{

		}

		#endregion

        #region From DbgPluginPrimer

        public override void Add( DbgEntity aEntity )

        {

            CodeSourceProvider provider = null;

            //

            if ( aEntity.FSEntity.IsFile )

            {

                if ( aEntity.Exists && aEntity.FSEntity.IsValid )

                {

                    provider = ProvisioningManager.GetProvider( aEntity.FSEntity.FullName );

                }

                //

                if ( provider != null )

                {

                    using ( CodeSourceCollection sources = provider.CreateSources( aEntity.FullName ) )

                    {

                        // Make sure the time to read attribute is setup in alignment with

                        // whether the entity was explicitly added by the user or found implicitly

                        // by scanning.

                        if ( aEntity.WasAddedExplicitly == false )

                        {

                            foreach ( CodeSource source in sources )

                            {

                                // This means, don't read this source until it is actually

                                // referenced by the client. I.e. until the client activates

                                // a code segment that refers to this 

                                source.TimeToRead = CodeSource.TTimeToRead.EReadWhenNeeded;

                            }

                        }

                        // Ownership is transferred

                        iSources.AddRange( sources );

                        sources.Clear();

                    }

                }

                else

                {

                    throw new NotSupportedException( "Specified file type is not supported" );

                }

            }

            else

            {

                throw new ArgumentException( "SymbianCodeLib does not support directory entities" );

            }

        }

        public override void Prime( TSynchronicity aSynchronicity )

        {

            CodePlugin plugin = this.Plugin;

            // Wipe any state ready for new priming attempt

            base.OnPrepareToPrime();

            if ( base.ResetEngineBeforePriming )

            {

                plugin.Clear();

            }

            // Report the "priming started event" prior to adding the sources

            base.ReportEvent( TPrimeEvent.EEventPrimingStarted, null );

            // Any sources already registered with the source manager at the start of a new

            // priming request are assumed to already be complete.

            RecordAlreadyCompletedSources();

            // Initially, whilst adding the sources to the source manager, we'll

            // operate synchronously. This prevents us from triggering the read

            // operation in the SourceAdded callback below.

            iSynchronicity = TSynchronicity.ESynchronous;

            // Listen to source manager events in case any new sources are

            // created whilst reading those we already know about.

            CodeSourceManager sourceManager = this.SourceManager;

            sourceManager.SourceAdded += new CodeSourceManager.SourceEventHandler( SourceManager_SourceAdded );

            sourceManager.SourceRemoved += new CodeSourceManager.SourceEventHandler( SourceManager_SourceRemoved );

            // Tell the source manager which sources we are reading. This also will

            // call our event handler (added above) so that we can observe source events.

            CodeSourceCollection sources = iSources;

            iSources = new CodeSourceCollection();

            sourceManager.AddRange( sources );

            // If we're operating asynchronously, then the loop below will potentially

            // complete quite quickly. This means that any (new/additional) sources which 

            // are created (asynchronously) whilst reading is underway will not themselves 

            // be read. 

            // 

            // Therefore, we store the synchronisation mode as a data member, and when

            // 'SourceAdded' is called, if operating asynchronously, we'll also initiate

            // a read operation for the source (as soon as it is added).

            //

            // If we're operating synchronously, then this isn't important. Because we're

            // behaving synchronously, the loop below will only process one source at a

            // time (before waiting) and therefore even if that source adds new/additional

            // sources to the source manager, we'll catch them as soon as we move the

            // next iteration around the loop.

            iSynchronicity = aSynchronicity;

            // TODO: possibly re-write this so that it uses two separate code paths

            // for synchronous and asynchronous priming? By trying to use one path

            // this code looks rather complex and isn't terribly robust.

            try

            {

                // Now we can start the sources running.

                int count = iSourcesYetToBePrimed.Count;

                while ( count > 0 )

                {

                    // Get the head source and remove it from the pending list

                    CodeSource source = iSourcesYetToBePrimed[ 0 ];

                    iSourcesYetToBePrimed.Remove( source );

                    // If the source wants to read it's data immediately, then activated

                    // it right now...

                    if ( source.TimeToRead == CodeSource.TTimeToRead.EReadWhenPriming )

                    {

                        source.Read( aSynchronicity );

                    }

                    else

                    {

                        // This source will read it's data on it's own terms so skip

                        // it to ensure that we can track when all the other sources 

                        // (that do actually read their files now..) are ready.

                        Skip( source );

                    }

                    count = iSourcesYetToBePrimed.Count;

                }

            }

            catch( Exception e )

            {

                // If priming failed, report completion before rethrowing...

                OnPrimeComplete();

                throw e;

            }

       }

        protected override void OnPrimeComplete()

        {

            System.Diagnostics.Debug.Assert( iSourcesYetToBePrimed.Count == 0 );

            try

            {

                SourceManager.SourceAdded -= new CodeSourceManager.SourceEventHandler( SourceManager_SourceAdded );

                SourceManager.SourceRemoved -= new CodeSourceManager.SourceEventHandler( SourceManager_SourceRemoved );

                //

                base.OnPrimeComplete();

            }

            finally

            {

                SourceEventsUnsubscribe();

            }

        }

        protected override int Count

        {

            get

            {

                int count = SourceManager.Count;

                return count; 

            }

        }

        #endregion

        #region API

        #endregion

		#region Properties

        internal CodePlugin Plugin

        {

            get { return base.Engine as CodePlugin; }

        }

        internal CodeSourceManager SourceManager

        {

            get { return Plugin.SourceManager; }

        }

        internal CodeSourceProviderManager ProvisioningManager

        {

            get { return Plugin.ProvisioningManager; }

        }

        #endregion

        #region Event handlers

        private void SourceManager_SourceAdded( CodeSource aSource )

        {

            base.Engine.Trace( "[CodePrimer] SourceManager_SourceAdded - aSource: {0}, time to read: {1}", aSource, aSource.TimeToRead );

            aSource.EventHandler += new CodeSource.EventHandlerFunction( Source_EventHandler );

            bool needToSave = true;

            // If we're in async mode and the source wants to be read immediately

            // then kick it off. If we're operating in sync mode, then this will

            // be done as part of the loop within 'Prime'.

            if ( iSynchronicity == TSynchronicity.EAsynchronous )

            {

                if ( aSource.TimeToRead == CodeSource.TTimeToRead.EReadWhenPriming )

                {

                    aSource.Read( iSynchronicity );

                }

                else

                {

                    // This source will read it's data on it's own terms so skip

                    // it to ensure that we can track when all the other sources 

                    // (that do actually read their files now..) are ready.

                    Skip( aSource );

                }

                // We don't need to add it to the 'yet to be primed' list because

                // it's either been 'read' or then it only supports read-on-demand.

                needToSave = false;

            }

            if ( needToSave )

            {

                lock ( iSourcesYetToBePrimed )

                {

                    iSourcesYetToBePrimed.Add( aSource );

                }

            }

            base.Engine.Trace( string.Format( "[SourceManager_SourceAdded] {0}, srcCount: {1}, yetToBePrimed: {2}", aSource.URI, SourceManager.Count, iSourcesYetToBePrimed.Count ) );

        }

        private void SourceManager_SourceRemoved( CodeSource aSource )

        {

            base.Engine.Trace( string.Format( "[SourceManager_SourceRemoved] START - {0}, srcCount: {1}, yetToBePrimed: {2}", aSource.URI, SourceManager.Count, iSourcesYetToBePrimed.Count ) );

            aSource.EventHandler -= new CodeSource.EventHandlerFunction( Source_EventHandler );

            base.RemoveFromCompleted( aSource );

            lock ( iSourcesYetToBePrimed )

            {

                iSourcesYetToBePrimed.Remove( aSource );

            }

            // Check for completion since removing a source might mean that we've now

            // reached completed state (if it was the last one that we were waiting for)

            bool amComplete = base.IsComplete;

            if ( amComplete )

            {

                CheckForCompletion( amComplete );

            }

            base.Engine.Trace( string.Format( "[SourceManager_SourceRemoved] END - {0}, srcCount: {1}, yetToBePrimed: {2}, amComplete: {3}", aSource.URI, SourceManager.Count, iSourcesYetToBePrimed.Count, amComplete ) );

        }

        private void Source_EventHandler( CodeSource.TEvent aEvent, CodeSource aSource, object aData )

        {

            bool primeCompleted = false;

            // Map source event onto a primer event

            if ( aEvent == CodeSource.TEvent.EReadingProgress )

            {

                base.SaveLatestProgress( aSource, (int) aData );

            }

            // If all sources are complete, then are we also done?

            if ( aEvent == CodeSource.TEvent.EReadingComplete )

            {

                // We don't need to listen to this source anymore

                aSource.EventHandler -= new CodeSource.EventHandlerFunction( Source_EventHandler );

                // Source is 100% complete now.

                base.SaveLatestProgress( aSource, 100 );

                // It's complete, so record as such so that we can tell when all the sources

                // are now ready.

                primeCompleted = base.AddToCompleted( aSource );

            }

            CheckForCompletion( primeCompleted );

        }

        #endregion

        #region Internal methods

        private void Skip( CodeSource aSource )

        {

            System.Diagnostics.Debug.Assert( aSource.TimeToRead == CodeSource.TTimeToRead.EReadWhenNeeded );

            bool primeCompleted = base.AddToCompleted( aSource );

            CheckForCompletion( primeCompleted );

        }

        private void SourceEventsUnsubscribe()

        {

            foreach ( CodeSource source in SourceManager )

            {

                source.EventHandler -= new CodeSource.EventHandlerFunction( Source_EventHandler );

            }

        }

        private void CheckForCompletion( bool aAmIComplete )

        {

            // Report any progress

            base.ReportProgressIfNeeded( aAmIComplete );

            // Tidy up and report completion

            if ( aAmIComplete )

            {

                OnPrimeComplete();

            }

        }

        private void RecordAlreadyCompletedSources()

        {

            CodeSourceManager sourceManager = this.SourceManager;

            foreach ( CodeSource source in sourceManager )

            {

                base.AddToCompleted( source );

            }

        }

        #endregion

        #region Data members

        private TSynchronicity iSynchronicity = TSynchronicity.ESynchronous;

        private CodeSourceCollection iSources = new CodeSourceCollection();

        private CodeSourceCollection iSourcesYetToBePrimed = new CodeSourceCollection();

        #endregion

    }

}