/*

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

using System.IO;

using System.Text;

using SymbianDebugLib.PluginAPI.Types.Symbol;

using SymbianStructuresLib.Arm.Registers;

using SymbianStructuresLib.Debug.Symbols;

using SymbianStructuresLib.Debug.Symbols.Constants;

using SymbianUtils.Range;

using SymbianUtils.Utilities;

namespace SymbianStackLib.Data.Output.Entry

{

    public class StackOutputEntry

    {

        #region Constructors

        public StackOutputEntry( uint aAddress, uint aData, DbgViewSymbol aSymbolView )

            : this( aAddress, aData )

        {

            FindNearestSymbol( aSymbolView );

        }

        public StackOutputEntry( uint aAddress, uint aData )

        {

            iAddress = aAddress;

            iData = aData;

            iDataAsString = RawByteUtility.CreateCharacterisedData( aData );

        }

        internal StackOutputEntry( StackOutputEntry aCopy )

        {

            iAddress = aCopy.Address;

            iData = aCopy.Data;

            iDataAsString = aCopy.DataAsString;

            iSymbol = aCopy.Symbol;

            iFlags = aCopy.iFlags;

            iAssociatedBinary = aCopy.AssociatedBinary;

            iAssociatedRegister = aCopy.AssociatedRegister;

            iTag = aCopy.Tag;

        }

        #endregion

        #region API

        public void FindNearestSymbol( DbgViewSymbol aSymbolView )

        {

            SymbolCollection collection = null;

            iSymbol = aSymbolView.Lookup( this.Data, out collection );

            //

            if ( collection != null )

            {

                // FIXME: should this be device file name if available, and host file name if all else fails?

                AssociatedBinary = Path.GetFileName( collection.FileName.FileNameInHost );

            }

        }

        public string GetSuggestedToolTipText()

        {

            string ret = string.Empty;

            //

            if ( IsCurrentStackPointerEntry )

            {

                ret = "Current stack pointer address";

            }

            else if ( IsRegisterBasedEntry )

            {

                ret = "Value obtained from register " + AssociatedRegisterName;

            }

            else if ( Symbol != null )

            {

                ret = "From: " + Symbol.Object;

            }

            else if ( AssociatedBinary != string.Empty )

            {

                ret = "From: " + AssociatedBinary;

            }

            //

            return ret;

        }

        public void GetSuggestedColours( out Color aFore, out Color aBack )

        {

            aFore = Color.Black;

            aBack = Color.Transparent;

            //

            if ( IsRegisterBasedEntry )

            {

                aBack = Color.LightSteelBlue;

            }

            else if ( IsCurrentStackPointerEntry )

            {

                aBack = Color.Pink;

            }

            else if ( IsOutsideCurrentStackRange )

            {

                aFore = Color.DarkGray;

            }

            else if ( IsGhost )

            {

                aFore = Color.DarkGray;

            }

            else if ( Symbol != null )

            {

                aFore = Color.DarkBlue;

            }

        }

        #endregion

        #region Properties

        public uint Address

        {

            get { return iAddress; }

        }

        public AddressRange AddressRange

        {

            get { return new AddressRange( Address, Address + 3 ); }

        }

        public uint Data

        {

            get { return iData; }

        }

        public string DataAsString

        {

            get { return iDataAsString; }

        }

        public Symbol Symbol

        {

            get { return iSymbol; }

        }

        public TArmRegisterType AssociatedRegister

        {

            get { return iAssociatedRegister; }

            set { iAssociatedRegister = value; }

        }

        public string AssociatedRegisterName

        {

            get { return ArmRegister.GetTypeName( iAssociatedRegister ); }

        }

        public string AssociatedBinary

        {

            get { return iAssociatedBinary; }

            set { iAssociatedBinary = value; }

        }

        public string Object

        {

            get

            {

                string ret = AssociatedBinary;

                //

                if ( Symbol != null )

                {

                    ret = Symbol.Object;

                }

                //

                return ret;

            }

        }

        public object Tag

        {

            get { return iTag; }

            set { iTag = value; }

        }

        public uint FunctionOffset

        {

            get

            {

                uint ret = 0;

                //

                if ( iSymbol != null )

                {

                    ret = iSymbol.Offset( this.Data );

                }

                //

                return ret;

            }

        }

        #endregion

        #region Flag query properties

        public bool IsCurrentStackPointerEntry

        {

            get { return ( iFlags & TFlags.EFlagsIsCurrentStackPointerEntry ) == TFlags.EFlagsIsCurrentStackPointerEntry; }

            set

            {

                if ( value )

                {

                    iFlags |= TFlags.EFlagsIsCurrentStackPointerEntry;

                }

                else

                {

                    iFlags &= ~TFlags.EFlagsIsCurrentStackPointerEntry;

                }

            }

        }

        public bool IsOutsideCurrentStackRange

        {

            get { return ( iFlags & TFlags.EFlagsIsOutsideCurrentStackRange ) == TFlags.EFlagsIsOutsideCurrentStackRange; }

            set

            {

                if ( value )

                {

                    iFlags |= TFlags.EFlagsIsOutsideCurrentStackRange;

                }

                else

                {

                    iFlags &= ~TFlags.EFlagsIsOutsideCurrentStackRange;

                }

            }

        }

        public bool IsAccurate

        {

            get { return ( iFlags & TFlags.EFlagsIsAccurate ) == TFlags.EFlagsIsAccurate; }

            set

            {

                if ( value )

                {

                    iFlags |= TFlags.EFlagsIsAccurate;

                }

                else

                {

                    iFlags &= ~TFlags.EFlagsIsAccurate;

                }

            }

        }

        public bool IsRegisterBasedEntry

        {

            get { return ( iFlags & TFlags.EFlagsIsRegisterBasedEntry ) == TFlags.EFlagsIsRegisterBasedEntry; }

            set

            {

                if ( value )

                {

                    iFlags |= TFlags.EFlagsIsRegisterBasedEntry;

                }

                else

                {

                    iFlags &= ~TFlags.EFlagsIsRegisterBasedEntry;

                }

            }

        }

        public bool IsGhost

        {

            get { return ( iFlags & TFlags.EFlagsIsGhost ) == TFlags.EFlagsIsGhost; }

            set

            {

                if ( value )

                {

                    iFlags |= TFlags.EFlagsIsGhost;

                }

                else

                {

                    iFlags &= ~TFlags.EFlagsIsGhost;

                }

            }

        }

        #endregion

        #region From System.Object

        public override string ToString()

        {

            const int KNormalAddressWidth = 10;

            StringBuilder ret = new StringBuilder();

            if ( IsRegisterBasedEntry )

            {

                string prefix = "[ " + AssociatedRegisterName;

                prefix = prefix.PadRight( KNormalAddressWidth - 2 );

                prefix += " ]";

                ret.AppendFormat( "{0} = {1:x8} {2} ", prefix, Data, DataAsString );

            }

            else

            {

                ret.AppendFormat( "[{0:x8}] = {1:x8} {2} ", Address, Data, DataAsString );

            }

            //

            if ( iSymbol != null && !iSymbol.IsDefault )

            {

                string baseAddressOffset = Symbol.ToStringOffset( Data );

                ret.AppendFormat( "{0} {1}", baseAddressOffset, Symbol.Name );

            }

            else if ( AssociatedBinary != string.Empty )

            {

                ret.AppendFormat( "{0} {1}", SymbolConstants.KUnknownOffset, AssociatedBinary );

            }

            //

            return ret.ToString();

        }

        #endregion

        #region Internal methods

        #endregion

        #region Internal flags

        [Flags]

        private enum TFlags

        {

            EFlagsNone = 0,

            EFlagsIsCurrentStackPointerEntry = 1,

            EFlagsIsOutsideCurrentStackRange = 2,

            EFlagsIsAccurate = 4,

            EFlagsIsRegisterBasedEntry = 8,

            EFlagsIsGhost = 16

        }

        #endregion

        #region Data members

        private readonly uint iAddress;

        private readonly uint iData;

        private readonly string iDataAsString;

        private Symbol iSymbol = null;

        private TFlags iFlags = TFlags.EFlagsNone;

        private string iAssociatedBinary = string.Empty;

        private TArmRegisterType iAssociatedRegister = TArmRegisterType.EArmReg_Other;

        private object iTag = null;

        #endregion

    }

}