/*

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

using System.Collections.Generic;

using SymbianUtils;

using SymbianUtils.Range;

using SymbianStructuresLib.Uids;

using SymbianStructuresLib.CodeSegments;

using SymbianStructuresLib.Debug.Common.FileName;

using SymbianStructuresLib.Debug.Symbols;

using SymbianDebugLib.Engine;

using SymbianDebugLib.PluginAPI.Types;

using SymbianDebugLib.PluginAPI.Types.Symbol;

using CrashItemLib.Crash;

using CrashItemLib.Crash.Base;

using CrashItemLib.Crash.Base.DataBinding;

using CrashItemLib.Crash.Threads;

using CrashItemLib.Crash.CodeSegs;

using CrashItemLib.Crash.Container;

using CrashItemLib.Crash.Symbols;

using CrashItemLib.Crash.Summarisable;

namespace CrashItemLib.Crash.Processes

{

    #region Attributes

    [CIDBAttributeColumn( "Name", 0 )]

    [CIDBAttributeColumn( "Value", 1, true )]

    #endregion

    public class CIProcess : CIElement, ICISymbolManager

	{

		#region Constructors

        public CIProcess( CIContainer aContainer )

            : base( aContainer )

		{

            base.AddChild( new CISymbolDictionary( aContainer ) );

		}

		#endregion

        #region API

        public CIThread CreateThread()

        {

            CIThread ret = new CIThread( this );

            base.AddChild( ret );

            return ret;

        }

        public CICodeSeg CreateCodeSeg( string aName, uint aBase, uint aLimit )

        {

            CICodeSeg ret = CreateCodeSeg( aName, aBase, aLimit, true );

            return ret;

        }

        #endregion

        #region Properties

        [CIDBAttributeCell( "UIDs", 5 )]

        public UidType Uids

        {

            get { return iUids; }

        }

        [CIDBAttributeCell( "Generation", 3 )]

        public int Generation

        {

            get { return iGeneration; }

            set { iGeneration = value; }

        }

        [CIDBAttributeCell( "Priority", 4, 0 )]

        public int Priority

        {

            get { return iPriority; }

            set { iPriority = value; }

        }

        [CIDBAttributeCell( "SID", 2, "x8", 0u )]

        public uint SID

        {

            get

            {

                uint ret = iSID;

                //

                if ( ret == 0 && iUids.MostSignificant != 0 )

                {

                    ret = iUids.MostSignificant;

                }

                //

                return ret; 

            }

            set 

            { 

                iSID = value;

                // Keep UID3 in line with SID

                if ( Uids[ 2 ] != value )

                {

                    Uids[ 2 ] = value;

                }

            }

        }

        [CIDBAttributeCell( "Name", 1 )]

        public override string Name

        {

            get { return iName; }

            set 

            { 

                iName = value; 

                // Make sure it ends in .exe

                if ( !iName.ToLower().EndsWith( KProcessExtension ) )

                {

                    iName += KProcessExtension;

                }

            }

        }

        public CICodeSegList CodeSegments

        {

            get

            {

                CIElementList<CICodeSeg> codeSegs = base.ChildrenByType<CICodeSeg>();

                // Sort them

                Comparison<CICodeSeg> comparer = delegate( CICodeSeg aLeft, CICodeSeg aRight )

                {

                    return string.Compare( aLeft.Name, aRight.Name, true );

                };

                codeSegs.Sort( comparer );

                CICodeSegList ret = new CICodeSegList( this, codeSegs );

                return ret; 

            }

        }

        public CIThread[] Threads

        {

            get

            {

                CIElementList<CIThread> list = base.ChildrenByType<CIThread>();

                CIThread[] ret = list.ToArray();

                return ret;

            }

        }

        public CIThread[] ThreadsWhichExitedAbnormally

        {

            get

            {

                // We use an anonymous delegate (predicate in this case) to search through

                // all the direct children of this object that have crashed.

                CIElementList<CIThread> threads = base.ChildrenByType<CIThread>( 

                    delegate(CIThread aThread )

                    {

                        return aThread.IsAbnormalTermination;

                    }

                );

                return threads.ToArray();

            }

        }

        public CIThread PrimaryThread

        {

            get

            {

                CIThread ret = null;

                //

                CIElementList<CIThread> threads = this.ChildrenByType<CIThread>();

                if ( threads.Count == 1 )

                {

                    ret = threads[ 0 ];

                }

                else

                {

                    // Assumption: The main thread (at least in symbian OS) is the thread which has

                    // the closest id to that of the process itself.

                    CIElementId minDelta = int.MaxValue;

                    foreach ( CIThread thread in this.GetEnumeratorThreads() )

                    {

                        CIElementId delta = thread.Id - this.Id;

                        //

                        if ( delta < minDelta )

                        {

                            ret = thread;

                        }

                        if ( delta == 1 )

                        {

                            // Optimisation

                            break;

                        }

                    }

                }

                //

                return ret;

            }

        }

        public CIThread FirstCrashedThread

        {

            get

            {

                CIThread  ret = null;

                // Try the primary thread first

                CIThread primary = PrimaryThread;

                if ( primary != null && primary.IsAbnormalTermination )

                {

                    ret = primary;

                }

                else

                {

                    // The primary summary is the first summary we can locate

                    // that relates to a crash.

                    foreach ( CIThread thread in this.GetEnumeratorThreads() )

                    {

                        bool isCrash = thread.IsAbnormalTermination;

                        if ( isCrash )

                        {

                            // Try to find corresponding summarisable entry

                            ret = thread;

                            break;

                        }

                    }

                }

                //

                return ret;

            }

        }

        public CISymbolDictionary Symbols

        {

            get { return base.ChildByType( typeof( CISymbolDictionary ) ) as CISymbolDictionary; }

        }

        public bool IsAbnormalTermination

        {

            get

            {

                bool ret = false;

                //

                foreach ( CIThread thread in this.GetEnumeratorThreads() )

                {

                    if ( thread.IsAbnormalTermination )

                    {

                        ret = true;

                        break;

                    }

                }

                //

                return ret;

            }

        }

        #endregion

        #region Enumerators

        public IEnumerable<CIThread> GetEnumeratorThreads()

        {

            return Threads;

        }

        public IEnumerable<CICodeSeg> GetEnumeratorCodeSegs()

        {

            return CodeSegments;

        }

        #endregion

        #region Internal constants

        private const string KProcessExtension = ".exe";

        private const string KUnknownProcessName = "UnknownProcess.exe";

        private const int KBaseOperationMultiplier = 5;

        #endregion

        #region Internal methods

        private CICodeSeg CreateCodeSeg( string aName, uint aBase, uint aLimit, bool aExplict )

        {

            CICodeSeg ret = new CICodeSeg( this );

            ret.Name = aName;

            ret.Base = aBase;

            ret.Limit = aLimit;

            ret.IsExplicit = aExplict;

            // Primary store is the child nodes

            base.AddChild( ret );

            base.Trace( "[CIProcess] CreateCodeSeg() - this: {0}, ret: {1}", this, ret );

            return ret;

        }

        private void EnsureCodeSegmentExistsForSymbol( CIElementFinalizationParameters aParams, CISymbol aSymbol )

        {

            if ( !aSymbol.IsNull )

            {

                Symbol symbol = aSymbol;

                SymbolCollection collection = symbol.Collection;

                //

                string binaryInDevice = PlatformFileNameConstants.Device.KPathWildcardSysBin;

                binaryInDevice += Path.GetFileName( collection.FileName.EitherFullNameButDevicePreferred );

                //

                CICodeSegList codeSegs = CodeSegments;

                bool alreadyExists = codeSegs.Contains( binaryInDevice );

                if ( !alreadyExists )

                {

                    // Assume no match found - create implicit/speculative code segment

                    AddressRange newCodeSegRange = collection.SubsumedPrimaryRange;

                    CICodeSeg newCodeSeg = CreateCodeSeg( binaryInDevice, newCodeSegRange.Min, newCodeSegRange.Max, false );

                    base.Trace( "[CIProcess] EnsureCodeSegmentExistsForSymbol() - creating implicitly identified code seg: " + newCodeSeg.ToString() + " for symbol: " + aSymbol.ToString() );

                    // Resolve it

                    newCodeSeg.Resolve( aParams.DebugEngineView );

                }

            }

        }

        private void DiscardImplicitCodeSegments()

        {

            // Go through each child and see if it's a code seg. If it is, and if 

            // it is implicit, throw it away

            int childCount = base.Count;

            for( int i=childCount-1; i>=0; i-- )

            {

                CIElement element = base[ i ];

                if ( element is CICodeSeg )

                {

                    CICodeSeg cs = (CICodeSeg) element;

                    //

                    if ( !cs.IsExplicit )

                    {

                        base.Trace( string.Format( "[CIProcess] DiscardImplicitCodeSegments() - dicarded: {0}", cs ) );

                        base.RemoveChild( cs );

                    }

                }

            }

        }

        private void CreateImplicitCodeSegments( CIElementFinalizationParameters aParams )

        {

            CIElementList<CISymbol> children = base.ChildrenByType<CISymbol>( TChildSearchType.EEntireHierarchy );

            base.Trace( string.Format( "[CIProcess] CreateImplicitCodeSegments() - children count: {1}, {0}", this, children.Count ) );

            //

            foreach ( CISymbol symbol in children )

            {

                EnsureCodeSegmentExistsForSymbol( aParams, symbol );

            }

        }

        #endregion

        #region From CIElement

        internal override void DoFinalize( CIElementFinalizationParameters aParams, Queue<CIElement> aCallBackLast, bool aForceFinalize )

        {

            base.Trace( string.Format( "[CIProcess] DoFinalize() - START - {0}", this ) );

            // The process' children need to use a process-relative debug engine view in order that they

            // can correctly resolve any RAM-loaded code.

            // Therefore, rather than use the so-called "global" debug engine view (which only has

            // XIP visibility) we create a process-specific set of finalization parameters (for use with 

            // the process' children) which contain a process-relative view of the world.

            using ( CIElementFinalizationParameters processRelativeParameters = new CIElementFinalizationParameters( aParams.Engine, this.Name, this.CodeSegments ) )

            {

                // Discard any implicit code segments. These are created automagically when an XIP symbol

                // is found. We'll re-create them anyway in a moment after the symbols have been updated.

                base.Trace( string.Format( "[CIProcess] DoFinalize() - discarding implicit XIP CodeSegs... - {0}", this ) );

                DiscardImplicitCodeSegments();

                base.Trace( string.Format( "[CIProcess] DoFinalize() - discarded implicit XIP CodeSegs - {0}", this ) );

                // Tell our children

                base.DoFinalize( processRelativeParameters, aCallBackLast, aForceFinalize );

                // Finally, re-create implicit XIP codesegments

                base.Trace( string.Format( "[CIProcess] DoFinalize() - creating implicit XIP CodeSegs... - {0}", this ) );

                CreateImplicitCodeSegments( aParams );

                base.Trace( string.Format( "[CIProcess] DoFinalize() - created implicit XIP CodeSegs - {0}", this ) );

            }

            //

            base.Trace( string.Format( "[CIProcess] DoFinalize() - END - {0}", this ) );

        }

        #endregion

        #region From System.Object

        public override string ToString()

        {

            return Name;

        }

        #endregion

        #region From ICISymbolManager

        public CISymbolDictionary SymbolDictionary

        {

            get { return this.Symbols; }

        }

        #endregion

        #region Data members

        private uint iSID = 0;

        private int iPriority = 0;

        private int iGeneration = 1;

        private UidType iUids = new UidType();

        private string iName = KUnknownProcessName;

        #endregion

    }

}