/*
* 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.Collections.Generic;
using System.Text;
using SymbianDebugLib.Engine;
using SymbianStackLib.Data.Output.Entry;
using SymbianStackLib.Engine;
using SymbianStackLib.Interfaces;
using SymbianUtils;
using SymbianUtils.PluginManager;
using SymbianUtils.Range;

namespace SymbianStackLib.Algorithms
{
    internal sealed class StackAlgorithmManager : DisposableObject, IStackAlgorithmObserver, IStackAlgorithmManager
    {
        #region Delegates & events
        public enum TEvent
        {
            EAlgorithmStarted = 0,
            EAlgorithmProgress,
            EAlgorithmComplete
        }

        public delegate void AlgorithmEventHandler( StackAlgorithmManager aAlgManager, TEvent aEvent );
        public event AlgorithmEventHandler EventHandler;

        public delegate void AlgorithmExceptionHandler( StackAlgorithmManager aAlgManager, Exception aException );
        public event AlgorithmExceptionHandler ExceptionHandler;
        #endregion

        #region Constructors
        public StackAlgorithmManager( StackEngine aEngine )
		{
            iEngine = aEngine;
            
            // Make the view name based upon the stack address range
            AddressRange range = aEngine.AddressInfo.Range;
            StringBuilder viewName = new StringBuilder();
            viewName.AppendFormat( "StackReconstructor_{0}_{1}", range, DateTime.Now.Ticks );
            iView = iEngine.DebugEngine.CreateView( viewName.ToString(), iEngine.CodeSegments );
        }
		#endregion

		#region API
        public void Reconstruct( TSynchronicity aSynchronicity )
        {
            iSynchronicity = aSynchronicity;
            try
            {
                PrepareForExecution();
                ExecuteHeadAlgorithm();
            }
            catch ( Exception e )
            {
                // The only reason an exception should occur is if none of the algorithms indicate that
                // they are ready to process stack data (probably because symbols were not provided). 
                //
                // In this situation, we must report the exception to our event handler
                if ( ExceptionHandler != null && EventHandler != null )
                {
                    // Make sure we sent the 'start' and 'end' events as well - we cannot send
                    // these events twice so it's okay to try to send them (will be ignored if
                    // already sent).
                    ReportEvent( TEvent.EAlgorithmStarted );
                    
                    // Now report the exception
                    ExceptionHandler( this, e );

                    // Indicate completion since we're not going to be able to do anything anymore
                    ReportEvent( TEvent.EAlgorithmComplete );
                }
                else
                {
                    // No exception handler so just rethrow...
                    throw e;
                }
            }
        }
		#endregion

		#region Properties
        public int Progress
        {
            get
            {
                // Scale the progress back to a fraction of the total
                lock ( this )
                {
                    int totalProgressSoFar = iProgressValueCompleted + iProgressValueCurrent;
                    float prog = ( (float) totalProgressSoFar ) / ( (float) iProgressValueMax );
                    prog *= 100.0f;
                    return (int) prog;
                }
            }
        }
        #endregion

        #region From IStackAlgorithmObserver
        public void StackBuildingStarted( StackAlgorithm aAlg )
        {
            Trace( "[SBAlgManager] StackBuildingStarted() - aAlg: {0}", aAlg );
            ReportEvent( TEvent.EAlgorithmStarted );
        }

        public void StackBuldingProgress( StackAlgorithm aAlg, int aPercent )
        {
            Trace( "[SBAlgManager] StackBuldingProgress() - aAlg: {0}, aPercent: {1}", aAlg, aPercent );
            lock ( this )
            {
                iProgressValueCurrent = aPercent;
            }
            //
            ReportEvent( TEvent.EAlgorithmProgress );
        }

        public void StackBuildingComplete( StackAlgorithm aAlg )
        {
            // If the algorithm is still queued then everything went okay. If not, then we
            // had an exception and we should therefore ignore the completion as the algorithm
            // terminated unexpectedly.
            bool stillExists = iExecutionQueue.Contains( aAlg );
            Trace( "[SBAlgManager] StackBuildingComplete() - aAlg: {0}, stillExists: {1}", aAlg, stillExists );
            if ( stillExists )
            {
                iExecutionQueue.Clear();
                ReportEvent( TEvent.EAlgorithmComplete );
            }
        }

        public void StackBuildingElementConstructed( StackAlgorithm aAlg, StackOutputEntry aEntry )
        {
            lock ( this )
            {
                iEngine.DataOutput.InsertAsFirstEntry( aEntry );
            }
        }

        public void StackBuildingException( StackAlgorithm aAlg, Exception aException )
        {
            Trace( "[SBAlgManager] STACK ALG EXCEPTION: " + aException.Message );
            Trace( "[SBAlgManager] {0}", aException.StackTrace );

            StackAlgorithm alg = CurrentAlgorithm;

            // If we're executing using the fallback entry, then we're in trouble. 
            // There is nothing we can do besides report the problem upwards.
            if ( iExecutionQueue.Count == 1 )
            {
                if ( ExceptionHandler != null )
                {
                    ExceptionHandler( this, aException );
                }
            }
            else
            {
                // Report event
                string message = string.Format( LibResources.StackAlgorithmManager_FailedAlgorithmWarning + System.Environment.NewLine + "{1}", 
                                                alg.Name, aException.Message.ToString() 
                                                );
                iEngine.ReportMessage( StackEngine.TMessageType.ETypeWarning, message );

                // The primary algorithm has failed, let's roll back to the secondary
                // by dumping the primary algorithm and starting again.
                iExecutionQueue.Dequeue();
                iEngine.DataOutput.Clear();

                // Reset progress.
                iProgressValueCompleted += 100;
                iProgressValueCurrent = 0;

                // Start next algorithm...
                ExecuteHeadAlgorithm();
            }
        }
        #endregion

        #region From IStackAlgorithmManager
        public StackEngine Engine
        {
            get { return iEngine; }
        }

        public DbgEngineView DebugEngineView
        {
            get { return iView; }
        }

        public void Trace( string aMessage )
        {
            iEngine.Trace( aMessage );
        }

        public void Trace( string aFormat, params object[] aParams )
        {
            iEngine.Trace( aFormat, aParams );
        }
        #endregion

        #region From DisposableObject
        protected override void CleanupManagedResources()
        {
            try
            {
                base.CleanupManagedResources();
            }
            finally
            {
                if ( iMasterAlgorithmTable != null )
                {
                    iMasterAlgorithmTable.Dispose();
                    iMasterAlgorithmTable = null;
                }
                
                if ( iView != null )
                {
                    iView.Dispose();
                    iView = null;
                }
            }
        }
        #endregion

        #region Internal properties
        private StackAlgorithm CurrentAlgorithm
        {
            get
            {
                if ( iExecutionQueue.Count == 0 )
                {
                    throw new Exception( "No stack algorithms available" );
                }
                //
                return iExecutionQueue.Peek();
            }
        }
		#endregion

        #region Internal methods
        private void PrepareForExecution()
        {
            Trace( "[SBAlgManager] PrepareForExecution() - START" );

            // Validate address info
            iEngine.AddressInfo.Validate();

            // Clear data output
            iEngine.DataOutput.Clear();

            // Reset master list
            IStackAlgorithmManager manager = (IStackAlgorithmManager) this;
            IStackAlgorithmObserver observer = (IStackAlgorithmObserver) this;
            iMasterAlgorithmTable.Load( new object[] { manager, observer } );
            SortAlgorithms();

            // Build list of algorithms we'll try to use
            PrepareExecutionQueue();

            // Work out maximum progress value for this operation
            int numberOfPendingAlgs = iExecutionQueue.Count;
            iProgressValueMax = numberOfPendingAlgs * 100;

            // Reset current progress
            iProgressValueCurrent = 0;
            iProgressValueCompleted = 0;

            Trace( "[SBAlgManager] PrepareForExecution() - END" );
        }

        private void PrepareExecutionQueue()
        {
            iExecutionQueue.Clear();
            
            // Find most appropriate algorithm...
            StackAlgorithm primary = FindPrimaryAlgorithm();
            if ( primary != null )
            {
                iExecutionQueue.Enqueue( primary );

                // Find backup algorithms
                EnqueueBackupAlgorithms( primary );
            }
            else
            {
                throw new Exception( "No valid stack algorithms available" );
            }
        }

        private StackAlgorithm FindPrimaryAlgorithm()
        {
            StackAlgorithm ret = null;
            //
            foreach ( StackAlgorithm alg in iMasterAlgorithmTable )
            {
                if ( alg.IsAvailable() )
                {
                    ret = alg;
                    break;
                }
            }
            //
            Trace( "[SBAlgManager] FindPrimaryAlgorithm() - ret: {0}", ret );
            return ret;
        }

        private void EnqueueBackupAlgorithms( StackAlgorithm aExclude )
        {
            foreach ( StackAlgorithm alg in iMasterAlgorithmTable )
            {
                string name = alg.Name;
                bool available = alg.IsAvailable();
                Trace( "[SBAlgManager] EnqueueBackupAlgorithms() - name: {0}, available: {1}", name, available );

                if ( available && name != aExclude.Name )
                {
                    iExecutionQueue.Enqueue( alg );
                }
            }
        }

        private void ExecuteHeadAlgorithm()
        {
            Trace( "[SBAlgManager] ExecuteHeadAlgorithm() - iSynchronicity: {0}", iSynchronicity );
            StackAlgorithm alg = CurrentAlgorithm;
            alg.BuildStack( iSynchronicity );
        }

        private void SortAlgorithms()
        {
            Comparison<StackAlgorithm> sorter = delegate( StackAlgorithm aLeft, StackAlgorithm aRight )
            {
                int ret = 1;
                //
                if ( aLeft == null )
                {
                    ret = -1;
                }
                else if ( aRight == null )
                {
                }
                else
                {
                    ret = aLeft.Priority.CompareTo( aRight.Priority );
                }
                //
                return ret;
            };
            iMasterAlgorithmTable.Sort( sorter );
        }

        private void ReportEvent( TEvent aEvent )
        {
            // Ensure we only report significant events once
            if ( EventHandler != null )
            {
                switch ( aEvent )
                {
                case TEvent.EAlgorithmStarted:
                    if ( ( iFlags & TFlags.EFlagsReportedStarted ) != TFlags.EFlagsReportedStarted )
                    {
                        iFlags |= TFlags.EFlagsReportedStarted;
                        EventHandler( this, aEvent );
                    }
                    break;
                case TEvent.EAlgorithmComplete:
                    if ( ( iFlags & TFlags.EFlagsReportedComplete ) != TFlags.EFlagsReportedComplete )
                    {
                        iFlags |= TFlags.EFlagsReportedComplete;
                        EventHandler( this, aEvent );
                    }
                    break;
                default:
                    EventHandler( this, aEvent );
                    break;
                }
            }
        }
        #endregion

        #region Internal enumerations
        [Flags]
        private enum TFlags
        {
            EFlagsNone = 0,
            EFlagsReportedStarted = 1,
            EFlagsReportedComplete = 2
        }
        #endregion

        #region Data members
        private readonly StackEngine iEngine;
        private DbgEngineView iView;
        private PluginManager<StackAlgorithm> iMasterAlgorithmTable = new PluginManager<StackAlgorithm>( 2 );
        
        // Transient variables
        private TSynchronicity iSynchronicity = TSynchronicity.EAsynchronous;
        private Queue<StackAlgorithm> iExecutionQueue = new Queue<StackAlgorithm>();
        private int iProgressValueMax = 0;
        private int iProgressValueCompleted = 0;
        private int iProgressValueCurrent = 0;
        private TFlags iFlags = TFlags.EFlagsNone;
        #endregion
    }
}