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

namespace CrashItemLib.Crash.Registers
{
    #region Attributes
    [CIDBAttributeColumn( "Name", 0 )]
    [CIDBAttributeColumn( "Value", 1 )]
    [CIDBAttributeColumn( "Symbol", 2, true )]
    #endregion
    public class CIRegisterList : CIElement, IARCBackingStore, IEnumerable<CIRegister>
	{
		#region Constructors
        public CIRegisterList( CIContainer aContainer, TArmRegisterBank aBank )
            : base( aContainer )
		{
            iCollection = new ArmRegisterCollection( aBank );
            iCollection.Tag = this;
            iCollection.BackingStore = this;

            // Restrict children
            base.AddSupportedChildType( typeof( CIRegister ) );
            base.AddSupportedChildType( typeof( CrashItemLib.Crash.Messages.CIMessage ) );
        }

        /// <summary>
        /// Internal constructor called by CIRegisterListForThread which sets a thread up as a parent
        /// of the register list.
        /// </summary>
        internal CIRegisterList( CIContainer aContainer, CIElement aParent, TArmRegisterBank aBank )
            : base( aContainer, aParent )
        {
            iCollection = new ArmRegisterCollection( aBank );
            iCollection.Tag = this;
            iCollection.BackingStore = this;

            // Restrict children
            base.AddSupportedChildType( typeof( CIRegister ) );
            base.AddSupportedChildType( typeof( CrashItemLib.Crash.Messages.CIMessage ) );
        }
        #endregion

        #region API
        public CIRegister Add( TArmRegisterType aType, uint aValue )
        {
            // Will cause a call back to create the entries in iRegisters...
            ArmRegister entry = iCollection.Add( aType, aValue );
            //
            System.Diagnostics.Debug.Assert( entry.Tag != null && entry.Tag is CIRegister );
            System.Diagnostics.Debug.Assert( iCollection.Count == base.Count );
            //
            CIRegister ret = (CIRegister) entry.Tag;
            return ret;
        }

        public void Add( ArmRegisterCollection aArmRegisterCollection )
        {
            // Will cause a call back to create the entries in iRegisters...
            iCollection.Copy( aArmRegisterCollection );
            System.Diagnostics.Debug.Assert( iCollection.Count == base.Count );
        }

        public bool Contains( TArmRegisterType aType )
        {
            System.Diagnostics.Debug.Assert( iCollection.Count == base.Count );
            return iCollection.Contains( aType );
        }

        public void Remove( TArmRegisterType aType )
        {
            iCollection.Remove( aType );
        }

        public override void Clear()
        {
            // This calls IARCBackingStore.ARCBSClear(), which in turn calls base.Clear().
            iCollection.Clear();
        }
        #endregion

        #region Properties
        public override int Count
        {
            get
            {
                int ret = base.Count;
                System.Diagnostics.Debug.Assert( iCollection.Count == ret );
                return iCollection.Count; 
            }
        }

        public bool IsCurrentProcessorMode
        {
            get
            {
                bool ret = false;
                //
                if ( Contains( TArmRegisterType.EArmReg_CPSR ) )
                {
                    CIRegister cpsr = this[ TArmRegisterType.EArmReg_CPSR ];
                    TArmRegisterBank currentBank = ArmRegisterBankUtils.ExtractBank( cpsr.Value );
                    //
                    ret = ( currentBank == Bank );
                }
                //
                return ret;
            }
        }

        public override string Name
        {
            get { return BankName; }
        }

        public TArmRegisterBank Bank
        {
            get { return iCollection.Bank; }
        }

        public string BankName
        {
            get { return ArmRegisterBankUtils.BankAsStringLong( Bank ); }
        }

        public string BankAbbreviation
        {
            get { return ArmRegisterBankUtils.BankAsString( Bank ); }
        }

        public CIThread OwningThread
        {
            get
            {
                CIThread ret = base.Parent as CIThread;
                return ret;
            }
        }

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

        public CIRegister[] Registers
        {
            get
            {
                CIElementList<CIRegister> registers = base.ChildrenByType<CIRegister>();
                return registers.ToArray();
            }
        }

        public CIRegister this[ TArmRegisterType aType ]
        {
            get
            {
                System.Diagnostics.Debug.Assert( iCollection.Count == base.Count );
                ArmRegister reg = iCollection[ aType ];
                System.Diagnostics.Debug.Assert( reg.Tag != null && reg.Tag is CIRegister );
                CIRegister ret = (CIRegister) reg.Tag;
                return ret;
            }
        }

        public CIRegister this[ string aName ]
        {
            get
            {
                System.Diagnostics.Debug.Assert( iCollection.Count == base.Count );
                ArmRegister reg = iCollection[ aName ];
                CIRegister ret = (CIRegister) reg.Tag;
                return ret;
            }
        }
        #endregion

        #region Operators
        public static implicit operator ArmRegisterCollection( CIRegisterList aSelf )
        {
            return aSelf.Collection;
        }
        #endregion

        #region Internal methods
        internal ArmRegisterCollection Collection
        {
            get { return iCollection; }
        }
        #endregion

        #region IARCBackingStore Members
        void IARCBackingStore.ARCBSClear()
        {
            base.Clear();
        }

        ArmRegister IARCBackingStore.ARCBSCreate( TArmRegisterType aType, string aName, uint aValue )
        {
            // Go via factory to deal with special registers...
            CIRegister reg = Factory.CIRegisterFactory.New( aType, aValue, aName, this );
            base.AddChild( reg );

            // Set up two-way association
            ArmRegister ret = reg.Register;
            ret.Tag = reg;
            return ret;
        }

        void IARCBackingStore.ARCBSRemove( ArmRegister aRegister )
        {
            CIRegister reg = aRegister.Tag as CIRegister;
            if ( reg != null )
            {
                base.RemoveChild( reg );
            }
        }
        #endregion

        #region From IEnumerable<CIRegister>
        public new IEnumerator<CIRegister> GetEnumerator()
        {
            foreach ( CIElement element in base.Children )
            {
                if ( element is CIRegister )
                {
                    CIRegister reg = (CIRegister) element;
                    yield return reg;
                }
            }
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            foreach ( CIElement element in base.Children )
            {
                if ( element is CIRegister )
                {
                    CIRegister reg = (CIRegister) element;
                    yield return reg;
                }
            }
        }
        #endregion

        #region From System.Object
        public override string ToString()
        {
            return ArmRegisterBankUtils.BankAsString( Bank );
        }
        #endregion

        #region From CIElement
        public override void PrepareRows()
        {
            DataBindingModel.ClearRows();
           
            // Our data binding model is based upon the register object, rather
            // than any key-value-pair properties.
            foreach ( CIRegister reg in this )
            {
                DataBindingModel.Add( reg );
            }
        }
        #endregion

        #region Data members
        private readonly ArmRegisterCollection iCollection;
        #endregion
    }
}