/*
* 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 SymbianDebugLib.Entity;
using SymbianDebugLib.PluginAPI;
using SymbianSymbolLib.SourceManagement.Provisioning;
using SymbianSymbolLib.SourceManagement.Source;
using SymbianUtils;

namespace SymbianSymbolLib.DbgEnginePlugin
{
    internal class SymbolPrimer : DbgPluginPrimer, IEnumerable<SymSource>
    {
        #region Constructors
        public SymbolPrimer( SymbolPlugin aPlugin )
            : base( aPlugin )
		{
            // If we've been created then presumably this is the reason...
            ProvisioningManager.PrepareToCreateSources();
        }
		#endregion

        #region From DbgPluginPrimer
        public override void Add( DbgEntity aEntity )
        {
            SymSourceProvider provider = null;
            //
            if ( aEntity.FSEntity.IsFile )
            {
                if ( aEntity.Exists && aEntity.FSEntity.IsValid )
                {
                    provider = ProvisioningManager.GetProvider( aEntity.FSEntity.FullName );
                }
                //
                if ( provider != null )
                {
                    using ( SymSourceCollection 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 ( SymSource 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 = SymSource.TTimeToRead.EReadWhenNeeded;
                            }
                        }

                        // Ownership is transferred
                        iSources.AddRange( sources );
                        sources.Clear();
                    }
                }
                else
                {
                    throw new NotSupportedException( "Specified file type is not supported" );
                }
            }
            else
            {
                throw new ArgumentException( "SymbianSymbolLib does not support directory entities" );
            }
        }

        public override void Prime( TSynchronicity aSynchronicity )
        {
            SymbolPlugin plugin = this.Plugin;

            // Wipe any state ready for new priming attempt
            base.OnPrepareToPrime();
            if ( base.ResetEngineBeforePriming )
            {
                plugin.Clear();
            }

            // Tell the plugin which sources we are reading
            plugin.StoreSourcesThatWillBePrimed( this );
  
            // Listen to soure events so that we can report progress
            SourceEventsSubscribe();

            // Report the "priming started event"
            base.ReportEvent( TPrimeEvent.EEventPrimingStarted, null );

            // Now we can start the sources running.
            foreach ( SymSource source in iSources )
            {
                // If the source wants to read it's data immediately, then activated
                // it right now...
                if ( source.TimeToRead == SymSource.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 );
                }
            }
        }

        protected override int Count
        {
            get { return iSources.Count; }
        }
        #endregion
        
        #region API
        internal void Skip( SymSource aSource )
        {
            System.Diagnostics.Debug.Assert( aSource.TimeToRead == SymSource.TTimeToRead.EReadWhenNeeded );
            bool primeCompleted = base.AddToCompleted( aSource );
            CheckForCompletion( primeCompleted );
        }
        #endregion

        #region Properties
        internal SymbolPlugin Plugin
        {
            get { return base.Engine as SymbolPlugin; }
        }

        internal SymSourceManager SourceManager
        {
            get { return Plugin.SourceManager; }
        }

        internal SymSourceProviderManager ProvisioningManager
        {
            get { return Plugin.ProvisioningManager; }
        }
        #endregion

        #region Internal methods
        private void SourceEventsSubscribe()
        {
            SourceEventsUnsubscribe();
            //
            foreach ( SymSource source in iSources )
            {
                source.EventHandler += new SymSource.EventHandlerFunction( Source_EventHandler );
            }
        }

        private void SourceEventsUnsubscribe()
        {
            foreach ( SymSource source in iSources )
            {
                source.EventHandler -= new SymSource.EventHandlerFunction( Source_EventHandler );
            }
        }

        private void Source_EventHandler( SymSource.TEvent aEvent, SymSource aSource, object aData )
        {
            bool primeCompleted = false;

            // Map source event onto a primer event
            if ( aEvent == SymSource.TEvent.EReadingProgress )
            {
                base.SaveLatestProgress( aSource, (int) aData );
            }
            
            // If all sources are complete, then are we also done?
            if ( aEvent == SymSource.TEvent.EReadingComplete )
            {
                // We don't need to listen to this source anymore
                aSource.EventHandler -= new SymSource.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 );
        }

        private void CheckForCompletion( bool aAmIComplete )
        {
            // Report any progress
            base.ReportProgressIfNeeded( aAmIComplete );

            // Tidy up and report completion
            if ( aAmIComplete )
            {
                base.OnPrimeComplete();
            }
        }
        #endregion

        #region From IEnumerable<SymSource>
        public IEnumerator<SymSource> GetEnumerator()
        {
            return iSources.GetEnumerator();
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return iSources.GetEnumerator();
        }
        #endregion

        #region Data members
        private SymSourceCollection iSources = new SymSourceCollection();
        #endregion
    }
}