/*
* 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.Text.RegularExpressions;
using System.Collections.Generic;
using SymbianUtils.Range;
using SymbianStructuresLib.Uids;
using SymbianStructuresLib.Arm.Registers;
using CrashItemLib.Crash;
using CrashItemLib.Crash.Base;
using CrashItemLib.Crash.Base.DataBinding;
using CrashItemLib.Crash.Stacks;
using CrashItemLib.Crash.ExitInfo;
using CrashItemLib.Crash.Processes;
using CrashItemLib.Crash.Registers;
using CrashItemLib.Crash.Container;
using CrashItemLib.Crash.Summarisable;

namespace CrashItemLib.Crash.Threads
{
    #region Attributes
    [CIDBAttributeColumn( "Name", 0 )]
    [CIDBAttributeColumn( "Value", 1, true )]
    #endregion
    public class CIThread : CIElement
	{
		#region Constructors
        public CIThread( CIProcess aProcess )
            : base( aProcess.Container, aProcess )
		{
            AddChild( new CIExitInfo( this ) );
            AddChild( new CIThreadRegisterListCollection( this ) );
		}
		#endregion

        #region API
        public CIStack CreateStack( CIRegisterList aRegisters, byte[] aData, uint aAddressOfFirstByte, AddressRange aRange )
        {
            // The registers given must be a child of this thread (in some way)
            System.Diagnostics.Debug.Assert( aRegisters.OwningThread == this );

            // Add it to the overall item too
            CIStack stack = CIStack.NewThreadStack( this, aRegisters, aData, aAddressOfFirstByte, aRange );
            AddChild( stack );

            return stack;
        }

        internal bool Contains( CIStack aStack )
        {
            return iStacks.ContainsKey( aStack.Type );
        }
        #endregion

        #region Properties
        [CIDBAttributeCell( "Id", 2 )]
        public override CIElementId Id
        {
            get { return base.Id; }
            set { base.Id = value; }
        }

        [CIDBAttributeCell( "Priority", 3, 0 )]
        public int Priority
        {
            get { return iPriority; }
            set { iPriority = value; }
        }

        [CIDBAttributeCell("Full Name", 1 )]
        public string FullName
        {
            get
            {
                StringBuilder ret = new StringBuilder();
                //
                if ( OwningProcess.Name.Length > 0 )
                {
                    ret.AppendFormat( "{0}[{1:x8}]{2:d4}::{3}",
                        OwningProcess.Name,
                        OwningProcess.SID,
                        OwningProcess.Generation,
                        Name
                        );
                }
                else
                {
                    ret.Append( Name );
                }
                //
                return ret.ToString();
            }
        }

        public override string Name
        {
            get
            {
                return iName;
            }
            set
            {
                iName = value;
            }
        }

        public CIProcess OwningProcess
        {
            get
            {
                CIProcess ret = (CIProcess) base.Parent;
                return ret;
            }
        }

        [CIDBAttributeCell( "Exit Info", 4 )]
        public CIExitInfo ExitInfo
        {
            get
            {
                // We ensure there is only ever one, so this is okay
                return (CIExitInfo) base.ChildByType( typeof( CIExitInfo ) );
            }
        }

        public CIStack[] Stacks
        {
            get
            {
                CIElementList<CIStack> stacks = base.ChildrenByType<CIStack>();
                return stacks.ToArray();
            }
        }

        public CISummarisableEntity Summary
        {
            get
            {
                CISummarisableEntityList list = Container.Summaries;
                CISummarisableEntity ret = list[ this ];
                return ret;
            }
        }

        public bool IsAbnormalTermination
        {
            get
            {
                bool ret = ExitInfo.IsAbnormalTermination;
                return ret;
            }
        }

        public CIRegisterList CurrentProcessorModeRegisters
        {
            get { return Registers.CurrentProcessorModeRegisters; }
        }

        public CIThreadRegisterListCollection Registers
        {
            get
            {
                // We ensure there is only ever one, so this is okay
                return (CIThreadRegisterListCollection) base.ChildByType( typeof( CIThreadRegisterListCollection ) );
            }
        }
        #endregion

        #region From CIElement
        public override void AddChild( CIElement aChild )
        {
            // We support 4 types of children at the moment.
            // Registers, stacks and exit info, messages.
            if ( aChild.GetType() == typeof( CIExitInfo ) )
            {
                if ( base.ChildrenByType<CIExitInfo>().Count != 0 )
                {
                    throw new ArgumentException( "Exit Info already associated with the thread" );
                }
            }
            else if ( aChild.GetType() == typeof( CIThreadRegisterListCollection ) )
            {
                if ( base.ChildrenByType<CIThreadRegisterListCollection>().Count != 0 )
                {
                    throw new ArgumentException( "Registers already associated with the thread" );
                }
            }
            else if ( aChild.GetType() == typeof( CIStack ) )
            {
                CIStack stack = (CIStack) aChild;

                // We must ensure we don't already have a stack of the specified mode
                // associated with the thread.
                bool exists = iStacks.ContainsKey( stack.Type );
                if ( exists )
                {
                    throw new ArgumentException( ArmRegisterBankUtils.BankAsStringLong( stack.Type ) + " mode stack already registered with thread" );
                }
                else
                {
                    iStacks.Add( stack.Type, stack );
                }
            }
            //
            base.AddChild( aChild );
        }
        #endregion

        #region Internal methods
        #endregion

        #region Internal constants
        private const string KUnknownThreadName = "UnknownThread";
        #endregion

        #region Data members
        private int iPriority = 0;
        private string iName = KUnknownThreadName;
        private Dictionary<TArmRegisterBank, CIStack> iStacks = new Dictionary<TArmRegisterBank, CIStack>();
        #endregion
    }
}