/*

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

using SymbianDebugLib.Engine;

using SymbianStackLib.AddressInfo;

using SymbianStackLib.Algorithms;

using SymbianStackLib.Data.Output;

using SymbianStackLib.Data.Source;

using SymbianStackLib.Data.Source.Primer;

using SymbianStackLib.Prefixes;

using SymbianStructuresLib.Arm.Registers;

using SymbianStructuresLib.CodeSegments;

using SymbianUtils;

using SymbianUtils.Tracer;

namespace SymbianStackLib.Engine

{

	public sealed class StackEngine : ITracer

    {

        #region Delegates & events

        public enum TEvent

        {

            EStackBuildingStarted = 0,

            EStackBuildingProgress,

            EStackBuildingComplete

        }

        public enum TMessageType

        {

            ETypeWarning = 0,

            ETypeError

        }

        public delegate void StackEngineEventHandler( TEvent aEvent, StackEngine aEngine );

        public event StackEngineEventHandler EventHandler;

        public delegate void StackEngineExceptionHandler( Exception aException, StackEngine aEngine );

        public event StackEngineExceptionHandler ExceptionHandler;

        public delegate void StackEngineMessageHandler( TMessageType aType, string aMessage, StackEngine aEngine );

        public event StackEngineMessageHandler MessageHandler;

        #endregion

        #region Constructors

        public StackEngine( DbgEngine aDebugEngine )

        {

            // Construction order important - must make primer after data source

            iPrefixes = new StackPrefixManager( this );

            iPrimer = new StackEnginePrimer( this );

            //

            iDebugEngine = aDebugEngine;

        }

		#endregion

		#region API

        public void Reconstruct( TSynchronicity aSynchronicity )

        {

            StackAlgorithmManager algorithmManager = new StackAlgorithmManager( this );

            algorithmManager.EventHandler += new StackAlgorithmManager.AlgorithmEventHandler( AlgorithmManager_EventHandler );

            algorithmManager.ExceptionHandler += new StackAlgorithmManager.AlgorithmExceptionHandler( AlgorithmManager_ExceptionHandler );

            algorithmManager.Reconstruct( aSynchronicity );

        }

        public void ReconstructAsync()

        {

            Reconstruct( TSynchronicity.EAsynchronous );

        }

        public void ReconstructSync()

        {

            Reconstruct( TSynchronicity.ESynchronous );

        }

		#endregion

		#region Properties

        public int Progress

        {

            get { return iProgress; }

        }

        public bool Verbose

        {

            get

            {

                bool ret = iVerbose;

                if ( System.Diagnostics.Debugger.IsAttached )

                {

                    ret = true;

                }

                return ret; 

            }

            set { iVerbose = value; }

        }

        public DbgEngine DebugEngine

        {

            get { return iDebugEngine; }

        }

        public StackEnginePrimer Primer

        {

            get { return iPrimer; }

        }

        public StackPrefixManager Prefixes

        {

            get { return iPrefixes; }

        }

        public StackAddressInfo AddressInfo

        {

            get { return iAddressInfo; }

        }

        public StackSourceData DataSource

        {

            get { return iDataSource; }

            set { iDataSource = value; }

        }

        public StackOutputData DataOutput

        {

            get { return iDataOutput; }

        }

        public ArmRegisterCollection Registers

        {

            get { return iRegisters; }

            set

            {

                iRegisters = value;

                // Update SP in the address info area if not already set

                if ( iAddressInfo.HaveSetStackPointer == false && iRegisters.Contains( TArmRegisterType.EArmReg_SP ) )

                {

                    iAddressInfo.Pointer = iRegisters[ TArmRegisterType.EArmReg_SP ].Value;

                }

            }

        }

        public CodeSegDefinitionCollection CodeSegments

        {

            get { return iCodeSegments; }

            set { iCodeSegments = value; }

        }

        #endregion

        #region Event handlers

        private void AlgorithmManager_ExceptionHandler( StackAlgorithmManager aAlgManager, Exception aException )

        {

            if ( ExceptionHandler != null )

            {

                ExceptionHandler( aException, this );

            }

        }

        private void AlgorithmManager_EventHandler( StackAlgorithmManager aAlgManager, StackAlgorithmManager.TEvent aEvent )

        {

            if ( EventHandler != null )

            {

                switch ( aEvent )

                {

                case StackAlgorithmManager.TEvent.EAlgorithmStarted:

                    EventHandler( TEvent.EStackBuildingStarted, this );

                    break;

                case StackAlgorithmManager.TEvent.EAlgorithmProgress:

                    iProgress = aAlgManager.Progress;

                    EventHandler( TEvent.EStackBuildingProgress, this );

                    break;

                case StackAlgorithmManager.TEvent.EAlgorithmComplete:

                    // Stop listening to algorithm manager events now that the reconstruction

                    // process is complete.

                    aAlgManager.EventHandler -= new StackAlgorithmManager.AlgorithmEventHandler( AlgorithmManager_EventHandler );

                    aAlgManager.ExceptionHandler -= new StackAlgorithmManager.AlgorithmExceptionHandler( AlgorithmManager_ExceptionHandler );

                    // Get rid of alg manager

                    aAlgManager.Dispose(); 

                    // Report that we're done!

                    EventHandler( TEvent.EStackBuildingComplete, this );

                    break;

                }

            }

        }

        #endregion

		#region Internal properties

		#endregion

        #region Internal methods

        internal void ReportMessage( TMessageType aType, string aMessage )

        {

            if ( MessageHandler != null )

            {

                MessageHandler( aType, aMessage, this );

            }

        }

        #endregion

        #region From ITracer

        public void Trace( string aMessage )

        {

            iDebugEngine.Trace( aMessage );

        }

        public void Trace( string aFormat, params object[] aParams )

        {

            iDebugEngine.Trace( aFormat, aParams );

        }

        #endregion

        #region From System.Object

        public override string ToString()

        {

            StringBuilder ret = new StringBuilder();

            // CodeSegs

            foreach ( CodeSegDefinition entry in CodeSegments )

            {

                ret.Append( Prefixes.CodeSegment );

                ret.Append( entry.ToString() );

                ret.Append( System.Environment.NewLine );

            }

            // Current SP

            if ( AddressInfo.Pointer != 0 )

            {

                ret.AppendLine( Prefixes.Pointer + "0x" + AddressInfo.Pointer.ToString("x8") );

            }

            // Stack data

            ret.AppendLine( DataSource.ToString() );

            //

            return ret.ToString();

        }

        #endregion

        #region Data members

        private readonly StackEnginePrimer iPrimer;

        private readonly StackPrefixManager iPrefixes;

        private readonly DbgEngine iDebugEngine;

        private bool iVerbose = false;

        private int iProgress = 0;

        private StackOutputData iDataOutput = new StackOutputData();

        private StackSourceData iDataSource = new StackSourceData();

        private StackAddressInfo iAddressInfo = new StackAddressInfo();

        private ArmRegisterCollection iRegisters = new ArmRegisterCollection();

        private CodeSegDefinitionCollection iCodeSegments = new CodeSegDefinitionCollection();

		#endregion

    }

}