/*

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

using SymbianUtils;

using SymbianDebugLib.Engine;

using SymbianStackLib.Engine;

using SymbianStackLib.Exceptions;

using CrashItemLib.Engine.Operations;

using CrashItemLib.Crash;

using CrashItemLib.Crash.Base;

using CrashItemLib.Crash.Symbols;

using CrashItemLib.Crash.Registers;

using CrashItemLib.Crash.Processes;

using CrashItemLib.Crash.CodeSegs;

using CrashItemLib.Crash.Messages;

using CrashItemLib.Engine;

namespace CrashItemLib.Crash.Stacks

{

	internal class CIStackBuilder

    {

        #region Constructors

        public CIStackBuilder( CIStack aStack, DbgEngine aDebugEngine )

        {

            iStack = aStack;

            iStackEngine = new StackEngine( aDebugEngine );

            iStackEngine.AddressInfo.Pointer = aStack.PointerValue;

            iStackEngine.AddressInfo.Range = aStack.Range;

            iStackEngine.Registers = aStack.Registers;

            iStackEngine.DataSource = aStack.RawSourceData;

            // Get the code segments for the process

            bool isThreadStack = aStack.IsThreadAvailable;

            if ( isThreadStack )

            {

                CIProcess process = OwningProcess;

                System.Diagnostics.Debug.Assert( process != null );

                // Seed stack engine with relevant code segments

                iStackEngine.CodeSegments = process.CodeSegments;

            }

        }

        #endregion

        #region API

        public void Build( TSynchronicity aSynchronicity )

        {

            StackEventsSubscribe();

            iStackEngine.Reconstruct( aSynchronicity );

        }

        #endregion

        #region Properties

        public bool IsReady

        {

            get { return iIsReady; }

            private set

            {

                lock ( this )

                {

                    iIsReady = value;

                }

            }

        }

        public CIProcess OwningProcess

        {

            get

            {

                CIProcess ret = iStack.OwningProcess;

                return ret;

            }

        }

        public StackEngine StackEngine

        {

            get { return iStackEngine; }

        }

        #endregion

        #region Event handlers

        private void StackEngine_EventHandler( StackEngine.TEvent aEvent, StackEngine aEngine )

        {

            if ( aEvent == StackEngine.TEvent.EStackBuildingComplete )

            {

                StackEventsUnsubscribe();

                IsReady = true;

            }

        }

        private void StackEngine_ExceptionHandler( Exception aException, StackEngine aEngine )

        {

            // Operation failed, but we must mark ourselves as ready or else UI clients will block forever...

            IsReady = true;

            // We'll deal with the public exceptions ourselves. Any kind of exception we cannot handle

            // will just get treated as a generic error.

            string msg = string.Empty;

            bool recognized = false;

            //

            if ( aException is StackAddressException )

            {

                recognized = true;

                StackAddressException exception = (StackAddressException) aException;

                switch ( exception.Type )

                {

                case StackAddressException.TType.ETypePointerIsNull:

                    msg = LibResources.CIStackBuilder_AddressInfoException_PointerMissing;

                    break;

                case StackAddressException.TType.ETypePointerOutOfBounds:

                    msg = LibResources.CIStackBuilder_AddressInfoException_PointerOutOfBounds;

                    break;

                case StackAddressException.TType.ETypeBaseAddressBeforeTopAddress:

                    msg = LibResources.CIStackBuilder_AddressInfoException_BaseAddressBeforeTopAddress;

                    break;

                case StackAddressException.TType.ETypeTopAddressAfterBaseAddress:

                    msg = LibResources.CIStackBuilder_AddressInfoException_TopAddressAfterBaseAddress;

                    break;

                default:

                    recognized = false;

                    break;

                }

            }

            // Not recognized? Unfortunately have to leak the original underlying .NET exception details

            if ( recognized == false )

            {

                msg = aException.Message;

            }

            if ( string.IsNullOrEmpty( msg ) == false )

            {

                // Treat exceptions as fatal errors

                CIMessageError error = new CIMessageError( iStack.Container, LibResources.CIStackBuilder_Error_Title );

                error.AddLine( msg );

                iStack.AddChild( error );

            }

        }

        private void StackEngine_MessageHandler( StackEngine.TMessageType aType, string aMessage, StackEngine aEngine )

        {

            switch ( aType )

            {

            default:

                break;

            case StackEngine.TMessageType.ETypeError:

                {

                CIMessageError error = new CIMessageError( iStack.Container, LibResources.CIStackBuilder_Error_Title );

                error.AddLine( aMessage );

                iStack.AddChild( error );

                break;

                }

            case StackEngine.TMessageType.ETypeWarning:

                {

                CIMessageWarning warning = new CIMessageWarning( iStack.Container, LibResources.CIStackBuilder_Warning_Title );

                warning.AddLine( aMessage );

                iStack.AddChild( warning );

                break;

                }

            }

        }

        #endregion

        #region Internal methods

        private void StackEventsSubscribe()

        {

            StackEngine.MessageHandler += new StackEngine.StackEngineMessageHandler( StackEngine_MessageHandler );

            StackEngine.EventHandler += new StackEngine.StackEngineEventHandler( StackEngine_EventHandler );

            StackEngine.ExceptionHandler += new StackEngine.StackEngineExceptionHandler( StackEngine_ExceptionHandler );

        }

        private void StackEventsUnsubscribe()

        {

            StackEngine.MessageHandler -= new StackEngine.StackEngineMessageHandler( StackEngine_MessageHandler );

            StackEngine.EventHandler -= new StackEngine.StackEngineEventHandler( StackEngine_EventHandler );

            StackEngine.ExceptionHandler -= new StackEngine.StackEngineExceptionHandler( StackEngine_ExceptionHandler );

        }

        #endregion

        #region From System.Object

        public override string ToString()

        {

            StringBuilder ret = new StringBuilder();

            ret.AppendFormat( "CIStackBuilder_{0}_{1}", iStack.Id, iStack.Name );

            return ret.ToString();

        }

        #endregion

        #region Data members

        private readonly CIStack iStack;

        private readonly StackEngine iStackEngine;

        private bool iIsReady = false;

        #endregion

    }

}