/*

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

using System.Collections.Generic;

using System.IO;

using System.Reflection;

using CrashItemLib.Crash.Base;

using CrashItemLib.Crash.Events;

using CrashItemLib.Crash.Header;

using CrashItemLib.Crash.InfoHW;

using CrashItemLib.Crash.InfoSW;

using CrashItemLib.Crash.Messages;

using CrashItemLib.Crash.Source;

using CrashItemLib.Crash.Summarisable;

using CrashItemLib.Crash.Symbols;

using CrashItemLib.Crash.Traces;

using CrashItemLib.Crash.Reports;

using CrashItemLib.Crash.Registers;

using CrashItemLib.Engine;

using SymbianDebugLib.Engine;

namespace CrashItemLib.Crash.Container

{

    public sealed class CIContainer : CIElement, ICISymbolManager

    {

        #region Enumerations

        internal enum TCIElementEventType

        {

            ECIEventChildAdded = 0,

            ECIEventChildRemoved,

        }

        public enum TStatus

        {

            EStatusDefault = 0,

            EStatusErrorContainer

        }

        #endregion

        #region Delegates & events

        internal delegate void ElementEventHandler( CIContainer aContainer, CIElement aElement, TCIElementEventType aType );

        internal event ElementEventHandler ElementEvents;

        #endregion

        #region Static constructors

        internal static CIContainer New( CIEngine aEngine, CISource aSource )

        {

            CIContainer ret = new CIContainer( aEngine, aSource );

            return ret;

        }

        public static CIContainer NewErrorContainer( CIEngine aEngine, CISource aSource )

        {

            CIContainer ret = new CIContainer( aEngine, aSource );

            ret.Status = TStatus.EStatusErrorContainer;

            return ret;

        }

        #endregion

        #region Constructors

        private CIContainer( CIEngine aEngine, CISource aSource )

            : base( KRootElementId )

		{

            iEngine = aEngine;

            // Immediately set up container association (to point to ourself) 

            // just incase...

            base.Container = this;

            // And indicate, that since we *are* the container, we want all our children

            // to automatically be "in it" too.

            base.IsInContainer = true;

            // Add source descriptor

            CISourceElement source = new CISourceElement( this, aSource );

            AddChild( source );

            // Add other mandatory elements

            AddMandatoryElements();

		}

		#endregion

        #region API

        public IEnumerable<CISummarisableEntity> GetSummarisableEnumerator()

        {

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

            return list;

        }

        #endregion

        #region Constants

        public const int KRootElementId = CIElementIdProvider.KInitialStartingValue;

        #endregion

        #region Properties

        public object Tag

		{

			get { return iTag; }

			set { iTag = value; }

		}

        public TStatus Status

        {

            get { return iStatus; }

            set { iStatus = value; }

        }

        public string[] FileNames

        {

            get

            {

                List<string> files = new List<string>();

                if ( iFileNames != null )

                {

                    files.AddRange( iFileNames );

                }

                return files.ToArray();

            }

        }

        public override CIEngine Engine

        {

            get { return iEngine; }

        }

        public CISummarisableEntity PrimarySummary

        {

            get

            {

                CISummarisableEntity ret = null;

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

                // that relates to a crash.

                CISummarisableEntityList summaries = Summaries;

                foreach ( CISummarisableEntity entity in summaries )

                {

                    bool isCrash = entity.IsAbnormalTermination;

                    if ( isCrash )

                    {

                        // Prefer threads to raw stack items.

                        if ( ret != null )

                        {

                            // If the 'best match' so far is just a stack, then replace it with whatever

                            // we've just found. This means we could replace a raw stack with another raw

                            // stack. We could never replace a thread entity with a stack entity though.

                            if ( ret.IsAvailable( CISummarisableEntity.TElement.EElementThread ) == false )

                            {

                                ret = entity;

                            }

                        }

                        else

                        {

                            ret = entity;

                        }

                    }

                }

                return ret;

            }

        }

        #endregion

        #region Mandatory elements

        public CIHeader Header

        {

            get { return (CIHeader) ChildByType( typeof( CIHeader ) ); }

        }

        public CIEventList Events

        {

            get { return (CIEventList) ChildByType( typeof( CIEventList ) ); }

        }

        public CITraceData Traces

        {

            get { return (CITraceData) ChildByType( typeof( CITraceData ) ); }

        }

        public CISourceElement Source

        {

            get { return (CISourceElement) ChildByType( typeof( CISourceElement ) ); }

        }

        public CISymbolDictionary Symbols

        {

            get { return (CISymbolDictionary) ChildByType( typeof( CISymbolDictionary ) ); }

        }

        public CIMessageDictionary Messages

        {

            get { return (CIMessageDictionary) ChildByType( typeof( CIMessageDictionary ) ); }

        }

        public CISummarisableEntityList Summaries

        {

            get { return (CISummarisableEntityList) ChildByType( typeof( CISummarisableEntityList ) ); }

        }

        public CIRegisterListCollection Registers

        {

            get

            {

                return (CIRegisterListCollection) ChildByType( typeof( CIRegisterListCollection ) );

            }

        }

        public CIReportInfo ReportInfo

        {

            get { return (CIReportInfo) ChildByType( typeof( CIReportInfo ) ); }

        }

        #endregion

        #region Internal methods

        internal void RunFinalizers( CIElementFinalizationParameters aParams )

        {

            Queue<CIElement> mustBeCalledLast = new Queue<CIElement>();

            base.DoFinalize( aParams, mustBeCalledLast, false );

            // Now call the elements that are to be finalized last

            while ( mustBeCalledLast.Count > 0 )

            {

                CIElement child = mustBeCalledLast.Dequeue();

                child.DoFinalize( aParams, mustBeCalledLast, true );

            }

        }

        internal int GetNextElementId()

        {

            return Engine.GetNextElementId();

        }

        private void AddMandatoryElements()

        {

            Type attribType = typeof( CIElementAttributeMandatory );

            Type[] types = Assembly.GetExecutingAssembly().GetTypes();

            //

            foreach( Type t in types)

            {

                // Get all the constructors for the type

                if ( !t.IsAbstract && typeof( CIElement ).IsAssignableFrom( t ) )

                {

                    ConstructorInfo[] ctors = t.GetConstructors( BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public );

                    foreach ( ConstructorInfo ctor in ctors )

                    {

                        // If the specified ctor is decorated with the "mandatory" attribute

                        // then it must be a mandatory class, so new an instance up...

                        object[] attribs = ctor.GetCustomAttributes( attribType, false );

                        if ( attribs.Length > 0 )

                        {

                            // Check that it has the expected signature.

                            // We expect mandatory constructors to take only a single parameter

                            // which is the container itself, i.e. this object

                            ParameterInfo[] parameters = ctor.GetParameters();

                            if ( parameters.Length == 1 && parameters[ 0 ].ParameterType == this.GetType() )

                            {

                                CIElement element = ctor.Invoke( new object[] { this } ) as CIElement;

                                if ( element != null )

                                {

                                    element.Parent = this;

                                    AddChild( element );

                                }

                            }

                        }

                    }

                }

            }

            //

            AddChild( new CISymbolDictionary( this ) );

        }

        private void CacheFileNames( DbgEngine aDebugEngine )

        {

            if ( iFileNames == null )

            {

                iFileNames = new List<string>();

                CISourceElement source = Source;

                foreach ( FileInfo file in source.AllFiles )

                {

                    iFileNames.Add( file.FullName );

                }

                // Meta-data files

                SymbianUtils.FileSystem.FSEntity[] entities = aDebugEngine.FileSystemEntities;

                foreach ( SymbianUtils.FileSystem.FSEntity e in entities )

                {

                    if ( e.IsFile )

                    {

                        FileInfo file = ( (SymbianUtils.FileSystem.FSEntityFile) e ).File;

                        iFileNames.Add( file.FullName );

                    }

                }

            }

        }

        #endregion

        #region Internal container event propagation

        internal void OnContainerElementRegistered( CIElement aElement )

        {

            if ( ElementEvents != null )

            {

                ElementEvents( this, aElement, TCIElementEventType.ECIEventChildAdded );

            }

        }

        internal void OnContainerElementUnregistered( CIElement aElement )

        {

            if ( ElementEvents != null )

            {

                ElementEvents( this, aElement, TCIElementEventType.ECIEventChildRemoved );

            }

        }

        #endregion

        #region From ICISymbolManager

        public CISymbolDictionary SymbolDictionary

        {

            get { return this.Symbols; }

        }

        #endregion

        #region From CIElement

        /// <summary>

        /// Ensure that we only allow single instances of some objects to be added

        /// as direct children.

        /// </summary>

        public override void AddChild( CIElement aChild )

        {

            bool exception = false;

            //

            if ( aChild is CIEventList && Events != null )

            {

                exception = true;

            }

            else if ( aChild is CISymbolDictionary && Symbols != null )

            {

                exception = true;

            }

            else if ( aChild is CIMessageDictionary && Messages != null )

            {

                exception = true;

            }

            else if ( aChild is CISourceElement && Source != null )

            {

                exception = true;

            }

            else if ( aChild is CISummarisableEntityList && Summaries != null )

            {

                exception = true;

            }

            else if ( aChild is CIHeader && Header != null )

            {

                exception = true;

            }

            else if ( aChild is CIReportInfo && ReportInfo != null )

            {

                exception = true;

            }

            else

            {

                // These aren't mandatory, but there should only be one...

                int count = -1;

                if ( aChild is CIInfoHW )

                {

                    count = base.ChildrenByType<CIInfoHW>().Count;

                }

                else if ( aChild is CIInfoSW )

                {

                    count = base.ChildrenByType<CIInfoSW>().Count;

                }

                if ( count > 1 )

                {

                    throw new ArgumentException( "An instance of the specified object has already been added to the container" );

                }

            }

            if ( exception )

            {

                throw new ArgumentException( "Can only add a single instance of " + aChild.GetType() + " to the container" );

            }

            base.AddChild( aChild );

        }

        /// <summary>

        /// Called by CIElement when an object is *directly* added

        /// as a child of the container.

        /// </summary>

        protected override void OnElementAddedToSelf( CIElement aElement )

        {

            // The master switch that ensures all elements and their children

            // are flagged as in the container.

            aElement.IsInContainer = true;

        }

        internal override void OnFinalize( CIElementFinalizationParameters aParams )

        {

            base.OnFinalize( aParams );

            // Cache file names

            CacheFileNames( aParams.DebugEngine );

        }

        #endregion

        #region Data members

        private readonly CIEngine iEngine;

        private object iTag = null;

        private TStatus iStatus = TStatus.EStatusDefault;

        private List<string> iFileNames = null;

		#endregion

    }

}