/*
* 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 CrashItemLib.Crash;
using CrashItemLib.Crash.Base;
using CrashItemLib.Crash.Processes;
using CrashItemLib.Crash.Registers;
using CrashItemLib.Crash.Stacks;
using CrashItemLib.Crash.CodeSegs;
using CrashItemLib.Crash.Threads;
using CrashItemLib.Crash.Messages;
using SymbianStructuresLib.Arm.Registers;

namespace CrashItemLib.Crash.Summarisable
{
	public class CISummarisableEntity : CIElement
    {
        #region Enumerations
        public enum TContext
        {
            /// <summary>
            /// A thread-specific entity, the normal case when the crash occurs within a Symbian
            /// OS kernel or user side thread context.
            /// </summary>
            EContextTypeThread = 0,

            /// <summary>
            /// An exception mode entity. For example, an object that represents the associated
            /// stack et al for an IRQ handler or FIQ handler crash.
            /// </summary>
            EContextTypeException
        }

        public enum TElement
        {
            EElementThread = 0,
            EElementProcess,
            EElementCodeSegments,
            EElementStack,
            EElementRegisters
        }
        #endregion

        #region Constructors
        /// <summary>
        /// Preferred constructor that is called by CISummarisableEntityList during finalization.
        /// This constructor is used to create a summary wrapper for any stack-level objects that
        /// were created during container preparation. Those stack objects may be stand-alone exception
        /// mode stacks (IRQ, FIQ, ABT, UND et al) or then they may be associated with a specific
        /// Symbian OS thread (user or supervisor).
        /// </summary>
        /// <param name="aStack"></param>
        internal CISummarisableEntity( CIStack aStack )
            : base( aStack.Container )
        {
            // NB: If the stack has an associated register list,
            // and the register list's owner is a thread, then we
            // automatically know we're dealing with a thread-based stack.
            AddChild( aStack );
        }

        /// <summary>
        /// Fall back constructor which is called when the thread in question has no associated
        /// stack. This means that stack data is unavailable and therefore stack reconstruction is
        /// obviously impossible. However, the thread (and by implication the process) may well still
        /// contain useful information.
        /// </summary>
        /// <param name="aThread"></param>
        internal CISummarisableEntity( CIThread aThread )
            : base( aThread.Container )
        {
            AddChild( aThread );
        }
		#endregion

        #region API
        public bool IsAvailable( TElement aElement )
        {
            bool ret = false;
            //
            switch ( aElement )
            {
            case TElement.EElementThread:
                ret = ( Thread != null );
                break;
            case TElement.EElementProcess:
                ret = ( Process != null );
                break;
            case TElement.EElementCodeSegments:
                ret = ( CodeSegments != null );
                break;
            case TElement.EElementStack:
                ret = ( Stack != null );
                break;
            case TElement.EElementRegisters:
                ret = ( Registers != null );
                break;
            }
            //
            return ret;
        }

        public CIMessageDictionary GetMessages()
        {
            CIElementList<CIMessage> list = base.ChildrenByType<CIMessage>( TChildSearchType.EEntireHierarchy );
            CIMessageDictionary ret = new CIMessageDictionary( list );
            return ret;
        }
        #endregion

        #region Properties
        public TContext Context
        {
            get
            {
                TContext ret = TContext.EContextTypeException;
                //
                if ( IsAvailable( TElement.EElementThread ) )
                {
                    ret = TContext.EContextTypeThread;
                }
                //
                return ret;
            }
        }

        public bool IsAbnormalTermination
        {
            get
            {
                // A crash can be an exception stack (i.e. without a thread)
                // or then a thread that has panics/crashed in some way.
                bool ret = false;
                //
                if ( IsAvailable( TElement.EElementThread ) )
                {
                    ret = Thread.IsAbnormalTermination;
                }
                else if ( IsAvailable( TElement.EElementStack ) )
                {
                    // All stand-alone stacks are treated as crashes.
                    ret = true;
                }
                //
                return ret;
            }
        }

        public CIThread Thread
        {
            get
            {
                CIThread ret = null;
                
                // Use the stack object to find associated thread.
                CIStack stack = this.Stack;
                if ( stack != null )
                {
                    ret = stack.OwningThread;
                }

                // Did we find a thread? If not, fall back to trying our children.
                if ( ret == null )
                {
                    // Register set unavailable - check child nodes for
                    // presence of thread object. Implies no stack data for
                    // this summary wrapper object.
                    ret = base.ChildByType( typeof( CIThread ) ) as CIThread;
                }
                //
                return ret;
            }
        }

        public CIProcess Process
        {
            get
            {
                CIProcess ret = null;
                //
                if ( Thread != null )
                {
                    ret = Thread.OwningProcess;
                }
                //
                return ret;
            }
        }

        public CICodeSegList CodeSegments
        {
            get
            {
                CICodeSegList ret = null;
                //
                CIProcess process = this.Process;
                if ( process != null )
                {
                    ret = process.CodeSegments;
                }
                //
                return ret;
            }
        }

        public CIRegisterList Registers
        {
            get 
            {
                CIRegisterList ret = null;
                //
                CIStack stack = this.Stack;
                if ( stack != null )
                {
                    // Use registers associated with stack
                    ret = stack.Registers;
                }
                else
                {
                    // No stack, if we have a thread then try to
                    // find the thread register list that is current.
                    CIThread thread = this.Thread;
                    if ( thread != null )
                    {
                        ret = thread.CurrentProcessorModeRegisters;
                    }
                }
                //
                return ret;
            }
        }

        public CIStack Stack
        {
            get 
            {
                // Might return null
                CIStack ret = base.ChildByType( typeof( CIStack ) ) as CIStack;
                return ret;
            }
        }

        public TArmRegisterBank Bank
        {
            get
            {
                TArmRegisterBank ret = TArmRegisterBank.ETypeUnknown;
                //
                if ( IsAvailable( TElement.EElementStack ) )
                {
                    ret = Stack.Type;
                }
                //
                return ret;
            }
        }

        public override string Name
        {
            get
            {
                StringBuilder ret = new StringBuilder();
                //
                if ( IsAvailable( TElement.EElementThread ) )
                {
                    // Just use thread name
                    ret.Append( Thread.FullName );
                }
                else if ( IsAvailable( TElement.EElementStack ) )
                {
                    // Get associated bank type
                    TArmRegisterBank bank = Stack.Registers.Bank;
                    string type = ArmRegisterBankUtils.BankAsStringLong( bank );
                    ret.AppendFormat( "{0} mode", type );
                }
                //
                return ret.ToString();
            }
            set
            {
            }
        }
        #endregion

        #region Internal methods
        #endregion

        #region Data members
        #endregion
    }
}