/*

* 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 SymbianUtils.Range;

using SymbianUtils.DataBuffer;

using SymbianUtils.DataBuffer.Entry;

using SymbianUtils.DataBuffer.Primer;

using SymbianStackLib.Engine;

using SymbianStackLib.Data.Source;

using SymbianStackLib.Data.Output;

using SymbianStackLib.Data.Output.Entry;

using SymbianStructuresLib.Uids;

using SymbianStructuresLib.Arm.Registers;

using CrashItemLib.Crash;

using CrashItemLib.Crash.Base;

using CrashItemLib.Crash.Registers;

using CrashItemLib.Crash.Threads;

using CrashItemLib.Crash.Processes;

using CrashItemLib.Crash.CodeSegs;

using CrashItemLib.Crash.Messages;

namespace CrashItemLib.Crash.Stacks

{

	public class CIStack : CIElement, IEnumerable<CIStackEntry>

    {

        #region Static constructors

        public static CIStack NewStandAlone( CIRegisterList aRegisters, byte[] aData, uint aAddressOfFirstByte, AddressRange aRange )

        {

            CIStack ret = new CIStack( aRegisters, aData, aAddressOfFirstByte, aRange );

            return ret;

        }

        internal static CIStack NewThreadStack( CIThread aThread, CIRegisterList aRegisters, byte[] aData, uint aAddressOfFirstByte, AddressRange aRange )

        {

            CIStack ret = new CIStack( aRegisters, aData, aAddressOfFirstByte, aRange );

            return ret;

        }

        #endregion

        #region Constructors

        private CIStack( CIRegisterList aRegisters, byte[] aData, uint aAddressOfFirstByte, AddressRange aRange )

            : base( aRegisters.Container )

        {

            base.AddSupportedChildType( typeof( CIStackEntry ) );

            base.AddSupportedChildType( typeof( CIMessage ) );

            iRegisters = aRegisters;

            iStackAddressRange = aRange;

            // Prepare data

            DataBufferPrimer primer = new DataBufferPrimer( iStackData );

            primer.Prime( aData, aAddressOfFirstByte );

        }

        #endregion

        #region API

        #endregion

        #region Properties

        public bool IsStackOutputAvailable

        {

            get { return iStackOutput != null; }

        }

        public bool IsThreadAvailable

        {

            get { return OwningThread != null; }

        }

        public bool IsProcessAvailable

        {

            get { return OwningProcess != null; }

        }

        public bool IsOverflow

        {

            get

            {

                bool ret = false;

                //

                bool pointerAvailable = this.Registers.Contains( TArmRegisterType.EArmReg_SP );

                if ( pointerAvailable )

                {

                    CIRegister regSP = this.Pointer;

                    AddressRange stackRange = this.Range;

                    //

                    ret = ( regSP <= stackRange.Min );

                }

                //

                return ret;

            }

        }

        public TArmRegisterBank Type

        {

            get { return Registers.Bank; }

        }

        public uint Base

        {

            // NB: CIStack stores addresses differently to the stack

            // engine, but these are correct so no need to panic.

            get

            {

                return iStackAddressRange.Min; 

            }

        }

        public uint Limit

        {

            // NB: CIStack stores addresses differently to the stack

            // engine, but these are correct so no need to panic.

            get

            {

                return iStackAddressRange.Max;

            }

        }

        public uint Size

        {

            get

            {

                // The address range contains all-inclusive values.

                //

                // E.g. a range of 0x00 -> 0x10 would include the values...:

                //

                //   0x00, 01, 02, 03, 04, 05, 06, 07, 08, 09, 0A, 0B, 0C, 0D, 0E, 0F, 0x10

                //

                // ...and therefore AddressRange.Size would return 17.

                //

                // Symbian OS treats the range as non-inclusive, so the value is one too large.

                // Hence we subtract one

                uint ret = iStackAddressRange.Size - 1;

                return ret;

            }

        }

        public int EntryCount

        {

            get { return iStackOutput.Count; }

        }

        public string Algorithm

        {

            get

            {

                string ret = "Unknown Algorithm";

                if ( iStackOutput != null )

                {

                    ret = iStackOutput.AlgorithmName;

                }

                return ret;

            }

        }

        public byte[] RawStackData

        {

            get { return iStackData.ToArray(); }

        }

        public int RawDataLength

        {

            get { return iStackData.Count; }

        }

        public AddressRange RawDataRange

        {

            get { return iStackData.Range; }

        }

        public CIRegister Pointer

        {

            get

            {

                CIRegister ret = Registers[ TArmRegisterType.EArmReg_SP ];

                return ret;

            }

        }

        public uint PointerValue

        {

            get

            {

                uint ret = 0;

                // We do it this way so as to avoid calling operator[] on the 

                // register list if the register does not exist. The default behaviour

                // of the register list class is to create a new register in such a situation

                // and we don't really want to do that.

                CIRegisterList regs = this.Registers;

                if ( regs.Contains( TArmRegisterType.EArmReg_SP ) )

                {

                    ret = this.Pointer.Value;

                }

                //

                return ret;

            }

        }

        public AddressRange Range

        {

            get { return iStackAddressRange; }

            set

            {

                iStackAddressRange = value;

            }

        }

        public CIThread OwningThread

        {

            get { return iRegisters.OwningThread; }

        }

        public CIProcess OwningProcess

        {

            get 

            {

                CIProcess ret = null;

                //

                if ( OwningThread != null )

                {

                    ret = OwningThread.OwningProcess;

                }

                //

                return ret; 

            }

        }

        public CICodeSegList CodeSegments

        {

            get

            {

                CICodeSegList list = null;

                CIProcess process = OwningProcess;

                if ( process != null )

                {

                    list = process.CodeSegments;

                }

                return list;

            }

        }

        public CIRegisterList Registers

        {

            get { return iRegisters; }

        }

        public StackOutputData RawOutputData

        {

            get { return iStackOutput; }

        }

        internal StackSourceData RawSourceData

        {

            get { return iStackData; }

        }

        #endregion

        #region Internal methods

        private void CreateEntries()

        {

            if ( iStackOutput != null )

            {

                int count = iStackOutput.Count;

                //

                for ( int i = 0; i < count; i++ )

                {

                    StackOutputEntry dataOutputEntry = iStackOutput[ i ];

                    //

                    CIStackEntry entry = new CIStackEntry( this, dataOutputEntry );

                    base.AddChild( entry );

                }

            }

        }

        #endregion

        #region From CIElement

        internal override void OnFinalize( CIElementFinalizationParameters aParams )

        {

            try

            {

                base.OnFinalize( aParams );

            }

            finally

            {

                CIStackBuilder builder = new CIStackBuilder( this, aParams.DebugEngine );

                builder.Build( TSynchronicity.ESynchronous );

                //

                iStackOutput = builder.StackEngine.DataOutput;

                //

                CreateEntries();

            }

        }

        #endregion

        #region From IEnumerable<CIStackEntry>

        public new IEnumerator<CIStackEntry> GetEnumerator()

        {

            CIElementList<CIStackEntry> entries = base.ChildrenByType<CIStackEntry>();

            return entries.GetEnumerator();

        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()

        {

            CIElementList<CIStackEntry> entries = base.ChildrenByType<CIStackEntry>();

            return entries.GetEnumerator();

        }

        #endregion

        #region From System.Object

        public override string ToString()

        {

            StringBuilder ret = new StringBuilder();

            if ( OwningThread != null )

            {

                ret.Append( "[Stack] " );

                ret.Append( OwningThread.ToString() );

                ret.Append( " " );

            }

            else

            {

            }

            //

            ret.Append( Registers.BankName );

            return ret.ToString();

        }

        #endregion

        #region Data members

        private readonly CIRegisterList iRegisters;

        private StackSourceData iStackData = new StackSourceData();

        private AddressRange iStackAddressRange = new AddressRange();

        private StackOutputData iStackOutput = null;

        #endregion

    }

}