/*

* 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 SymbianDebugLib.Engine;

using SymbianDebugLib.PluginAPI.Types;

using SymbianDebugLib.PluginAPI.Types.Symbol;

using SymbianStructuresLib.Uids;

using SymbianUtils.DataBuffer;

using SymbianStructuresLib.CodeSegments;

using SymbianStructuresLib.Debug.Symbols;

using SymbianUtils;

using SymbianUtils.Range;

using CrashItemLib.Crash;

using CrashItemLib.Crash.Base;

using CrashItemLib.Crash.Messages;

using CrashItemLib.Crash.Processes;

using CrashItemLib.Crash.Symbols;

namespace CrashItemLib.Crash.CodeSegs

{

    public class CICodeSeg : CIElement

    {

        #region Constructors

        public CICodeSeg( CIProcess aProcess )

            : this( aProcess, new CodeSegDefinition() )

		{

		}

        public CICodeSeg( CIProcess aProcess, CodeSegDefinition aCodeSegDef )

            : base( aProcess.Container )

        {

            iOwningProcess = aProcess;

            iCodeSegDef = aCodeSegDef;

        }

        #endregion

        #region API

        public bool Contains( uint aAddress )

        {

            bool ret = Range.Contains( aAddress );

            return ret;

        }

        internal void Resolve( DbgEngineView aDebugEngineView )

        {

            base.Trace( "[CICodeSeg] Resolve() - START - this: {0}", this );

            ResetState();

            // Check whether we have a symbol already loaded for the code segment's base address

            uint baseAddress = this.Base;

            //

            SymbolCollection col = null;

            Symbol symbol = aDebugEngineView.Symbols.Lookup( baseAddress, out col );

            base.Trace( "[CICodeSeg] Resolve() - symbol: {0}, symbolCollection: {1}", symbol, col );

            //

            if ( symbol != null )

            {

                // This must be valid if we found a symbol

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

            }

            else

            {

                // Symbol engine is not aware of the code segment's base address, but we can check by name

                // as well...

                col = aDebugEngineView.Symbols[ iCodeSegDef ];

            }

            // Update state

            IsResolved = ( col != null );

            AssociatedSymbolCollection = col;

            base.Trace( "[CICodeSeg] Resolve() - END - this: {0}, resolved: {1}, iCodeSegDef.FileName: {2}", this, this.IsResolved, iCodeSegDef.FileName );

        }

        #endregion

        #region Properties

        public override string Name

        {

            get { return iCodeSegDef.FileName; }

            set 

            {

                iCodeSegDef.FileName = value;

            }

        }

        public uint Base

        {

            get { return iCodeSegDef.Base; }

            set { iCodeSegDef.Base = value; }

        }

        public uint Limit

        {

            get { return iCodeSegDef.Limit; }

            set

            {

                iCodeSegDef.Limit = value; 

            }

        }

        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 = iCodeSegDef.Size - 1;

                return ret;

            }

        }

        public uint Checksum

        {

            get { return iCodeSegDef.Checksum; }

            set { iCodeSegDef.Checksum = value; }

        }

        public bool IsResolved

        {

            get { return iIsResolved; }

            private set

            { 

                iIsResolved = value;

                base.Trace( "[CICodeSeg] Resolve() - this: {0}, resolved: {1}", this, iIsResolved );

            }

        }

        public bool IsMismatched

        {

            get { return MismatchAddress != KNoSymbolicMismatchAddress; }

        }

        public bool IsSpeculative

        {

            get { return !IsExplicit; }

        }

        public bool IsExplicit

        {

            get { return iIsExplicit; }

            internal set { iIsExplicit = value; }

        }

        public uint MismatchAddress

        {

            get { return iMismatchAddress; }

            private set { iMismatchAddress = value; }

        }

        public AddressRange Range

        {

            get

            {

                // We do this so that calling Range.ToString() won't include a file name!

                AddressRange ret = new AddressRange( iCodeSegDef );

                return ret;

            }

        }

        public CIProcess OwningProcess

        {

            get 

            {

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

                return iOwningProcess; 

            }

        }

        public SymbolCollection AssociatedSymbolCollection

        {

            get { return iAssociatedSymbolCollection; }

            private set

            {

                iAssociatedSymbolCollection = value;

                if ( iAssociatedSymbolCollection != null )

                {

                    bool misMatch = ( iAssociatedSymbolCollection.BaseAddress != this.Base );

                    if ( misMatch )

                    {

                        MismatchAddress = iAssociatedSymbolCollection.BaseAddress;

                    }

                }

            }

        }

        #endregion

        #region Operators

        public static implicit operator CodeSegDefinition( CICodeSeg aCodeSeg )

        {

            return aCodeSeg.iCodeSegDef;

        }

        #endregion

        #region Internal constants

        private const uint KNoSymbolicMismatchAddress = 0;

        #endregion

        #region Internal methods

        private void ResetState()

        {

            IsResolved = false;

            MismatchAddress = 0;

        }

        private Symbol BaseAddressSymbolAndCollection( DbgViewSymbol aSymbolView, out SymbolCollection aCollection )

        {

            Symbol ret = aSymbolView.Lookup( this.Base, out aCollection );

            return ret;

        }

        #endregion

        #region From CIElement

        internal override void OnFinalize( CIElementFinalizationParameters aParams )

        {

            try

            {

                base.OnFinalize( aParams );

            }

            finally

            {

                Resolve( aParams.DebugEngineView );

            }

        }

        #endregion

        #region From System.Object

        public override string ToString()

        {

            StringBuilder ret = new StringBuilder();

            ret.AppendFormat( "{0:x8}-{1:x8} {2}", this.Base, this.Limit, this.Name );

            return ret.ToString();

        }

        #endregion

        #region Data members

        private readonly CIProcess iOwningProcess;

        private bool iIsResolved = false;

        private bool iIsExplicit = false;

        private uint iMismatchAddress = KNoSymbolicMismatchAddress;

        private CodeSegDefinition iCodeSegDef = new CodeSegDefinition();

        private SymbolCollection iAssociatedSymbolCollection = null;

        #endregion

    }

}