/*
* 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.Generic;
using System.Text;

namespace SymbianStructuresLib.Arm.Registers
{
    public class ArmRegisterCollection : IEnumerable<ArmRegister>, IComparer<ArmRegister>
    {
        #region Constructors
        public ArmRegisterCollection()
            : this( TArmRegisterBank.ETypeUnknown )
        {
        }

        public ArmRegisterCollection( TArmRegisterBank aBank )
            : this( aBank, null )
        {
        }

        public ArmRegisterCollection( TArmRegisterBank aBank, ArmRegisterCollection aLinkedWith )
        {
            iBank = aBank;
            iLinkedWith = aLinkedWith;
        }

        public ArmRegisterCollection( ArmRegisterCollection aCopy )
            : this( aCopy.Bank, aCopy.iLinkedWith )
        {
            foreach ( ArmRegister reg in aCopy )
            {
                ArmRegister copy = new ArmRegister( reg );
                DoAdd( copy );
            }
        }
        #endregion

        #region API
        public ArmRegister Add( ArmRegister aRegister )
        {
            ArmRegister entry = null;
            //
            if ( iBackingStore != null )
            {
                string name = aRegister.OriginalName;
                entry = iBackingStore.ARCBSCreate( aRegister.RegType, name, aRegister.Value );
                entry = DoAdd( entry );
            }
            else
            {
                entry = DoAdd( aRegister );
            }
            //
            return entry;
        }

        public ArmRegister Add( TArmRegisterType aType, uint aValue )
        {
            ArmRegister entry = null;
            if ( iBackingStore != null )
            {
                string name = ArmRegister.GetTypeName( aType );
                entry = iBackingStore.ARCBSCreate( aType, name, aValue );
            }
            else
            {
                entry = new ArmRegister( aType, aValue );
            }
            //
            entry = DoAdd( entry );
            return entry;
        }

        public ArmRegister Add( string aName, uint aValue )
        {
            TArmRegisterType type = ArmRegister.GetTypeByName( aName );

            ArmRegister entry = null;
            if ( iBackingStore != null )
            {
                entry = iBackingStore.ARCBSCreate( type, aName, aValue );
            }
            else
            {
                entry = new ArmRegister( aName, aValue );
            }
            //
            entry = DoAdd( entry );
            return entry;
        }

        public void Copy( ArmRegisterCollection aCollection )
        {
            foreach ( ArmRegister reg in aCollection )
            {
                Add( reg.OriginalName, reg.Value );
            }
        }

        public virtual void AddDefaults()
        {
            Clear();
            //
            Array items = Enum.GetValues( typeof( TArmRegisterType ) );
            foreach ( object enumEntry in items )
            {
                TArmRegisterType value = (TArmRegisterType) enumEntry;
                if ( value >= TArmRegisterType.EArmReg_00 && value <= TArmRegisterType.EArmReg_EXCPC )
                {
                    Add( value, 0 );
                }
            }
        }

        public void AddMany( params TArmRegisterType[] aTypes )
        {
            foreach ( TArmRegisterType reg in aTypes )
            {
                string name = ArmRegister.GetTypeName( reg );
                Add( name, 0 );
            }
        }

        public void SetAll( uint aValue )
        {
            foreach ( ArmRegister reg in this )
            {
                reg.Value = aValue;
            }
        }

        public bool Contains( TArmRegisterType aType )
        {
            if ( aType == TArmRegisterType.EArmReg_Other )
            {
                throw new ArgumentException( "Type must be unique" );
            }
            //
            bool ret = false;
            //
            foreach ( ArmRegister reg in this )
            {
                if ( reg.RegType == aType )
                {
                    ret = true;
                    break;
                }
            }
            //
            return ret;
        }

        public bool Contains( string aName )
        {
            // Need this to map the specified name into a common name.
            // I.e. convert R14_USR to R14
            ArmRegister temp = new ArmRegister( aName, 0 );

            // First try concrete entries
            bool ret = iEntries.ContainsKey( temp.Name );
            if ( !ret && iLinkedWith != null )
            {
                // Try linked
                ret = iLinkedWith.Contains( temp.Name );
            }

            return ret;
        }

        public void Clear()
        {
            if ( iBackingStore != null )
            {
                iBackingStore.ARCBSClear();
            }

            iEntries.Clear();
        }

        public void Remove( TArmRegisterType aType )
        {
            ArmRegister temp = new ArmRegister( aType, 0 );
            bool contains = iEntries.ContainsKey( temp.Name );
            if ( contains )
            {
                temp = iEntries[ temp.Name ];
                iEntries.Remove( temp.Name );
                if ( iBackingStore != null )
                {
                    iBackingStore.ARCBSRemove( temp );
                }
            }
        }
        #endregion

        #region Properties
        public TArmRegisterBank Bank
        {
            get { return iBank; }
        }

        public ArmRegister this[ ArmRegister aRegister ]
        {
            get
            {
                ArmRegister ret = this[ aRegister.Name ];
                return ret;
            }
        }

        public ArmRegister this[ TArmRegisterType aType ]
        {
            get
            {
                // We can only find entries which have a well known name
                if ( aType == TArmRegisterType.EArmReg_Other )
                {
                    throw new ArgumentException( "Type must be unique" );
                }

                // Check for existing entry
                foreach ( ArmRegister entry in this )
                {
                    if ( entry.RegType == aType )
                    {
                        return entry;
                    }
                }
                
                // The specified entry did not exist so silently
                // add it and return a reference to the new entry
                ArmRegister ret = Add( aType, 0 );
                return ret;
            }
        }

        public ArmRegister this[ string aName ]
        {
            get
            {
                ArmRegister ret = new ArmRegister( aName, 0 );

                // First try concrete entries in this object
                if ( iEntries.ContainsKey( ret.Name ) )
                {
                    ret = iEntries[ ret.Name ];
                }
                else if ( iLinkedWith != null && iLinkedWith.Contains( ret.Name ) )
                {
                    // Try linked entries
                    ret = iLinkedWith[ ret.Name ];
                }
                else
                {
                    // Not found
                    Add( aName, 0 );
                }
                //
                return ret;
            }
        }

        public int Count
        {
            get
            {
                int ret = iEntries.Count;
                //
                if ( iLinkedWith != null )
                {
                    ret += iLinkedWith.Count;
                }
                //
                return ret;
            }
        }

        public bool IsEmpty
        {
            get
            {
                bool empty = true;
                //
                foreach ( ArmRegister reg in this )
                {
                    if ( reg.Value != 0 )
                    {
                        empty = false;
                        break;
                    }
                }
                //
                return empty;
            }
        }

        public object Tag
        {
            get { return iTag; }
            set { iTag = value; }
        }

        public IARCBackingStore BackingStore
        {
            get { return iBackingStore; }
            set { iBackingStore = value; }
        }
        #endregion

        #region Internal methods
        private void MakeDefaultEntries()
        {
            Add( TArmRegisterType.EArmReg_00, 0 );
            Add( TArmRegisterType.EArmReg_01, 0 );
            Add( TArmRegisterType.EArmReg_02, 0 );
            Add( TArmRegisterType.EArmReg_03, 0 );
            Add( TArmRegisterType.EArmReg_04, 0 );
            Add( TArmRegisterType.EArmReg_05, 0 );
            Add( TArmRegisterType.EArmReg_06, 0 );
            Add( TArmRegisterType.EArmReg_07, 0 );
            Add( TArmRegisterType.EArmReg_08, 0 );
            Add( TArmRegisterType.EArmReg_09, 0 );
            Add( TArmRegisterType.EArmReg_10, 0 );
            Add( TArmRegisterType.EArmReg_11, 0 );
            Add( TArmRegisterType.EArmReg_12, 0 );
            Add( TArmRegisterType.EArmReg_SP, 0 );
            Add( TArmRegisterType.EArmReg_LR, 0 );
            Add( TArmRegisterType.EArmReg_PC, 0 );
            Add( TArmRegisterType.EArmReg_CPSR, 0 );
        }

        private ArmRegister DoAdd( ArmRegister aRegister )
        {
            ArmRegister ret = aRegister;
            //
            bool exists = iEntries.ContainsKey( aRegister.Name );
            if ( exists )
            {
                ret = iEntries[ aRegister.Name ];
                ret.Value = aRegister.Value;
            }
            else
            {
                // Associate entry with this collection
                aRegister.Parent = this;
                iEntries.Add( aRegister.Name, aRegister );
            }
            //
            return ret;
        }
        #endregion

        #region From IComparer<ArmRegister>
        public int Compare( ArmRegister aLeft, ArmRegister aRight )
        {
            int ret = -1;
            //
            if ( aLeft == null || aRight == null )
            {
                if ( aRight == null )
                {
                    ret = 1;
                }
            }
            else
            {
                // Try to order the registers so that Rnn register names come first
                // then CPSR, then the other stuff.
                TArmRegisterType leftType = aLeft.RegType;
                TArmRegisterType rightType = aRight.RegType;
                //
                if ( leftType != TArmRegisterType.EArmReg_Other && rightType == TArmRegisterType.EArmReg_Other )
                {
                    // Left is smaller since it's a standard register
                    ret = -1;
                }
                else if ( leftType == TArmRegisterType.EArmReg_Other && rightType != TArmRegisterType.EArmReg_Other )
                {
                    // Right is smaller since it's a standard register
                    ret = 1;
                }
                else if ( leftType == TArmRegisterType.EArmReg_Other && rightType == TArmRegisterType.EArmReg_Other )
                {
                    // Must compare names since both are non-standard registers
                    ret = aLeft.OriginalName.CompareTo( aRight.OriginalName );
                }
                else
                {
                    // Registers are not non-standard, compare based upon numerical value
                    if ( leftType == rightType )
                    {
                        ret = 0;
                    }
                    else if ( leftType > rightType )
                    {
                        ret = 1;
                    }
                }
            }
            //
            return ret;
        }
        #endregion

        #region From IEnumerable<ArmRegister>
        public IEnumerator<ArmRegister> GetEnumerator()
        {
            SortedList<string, ArmRegister> entries = new SortedList<string, ArmRegister>();

            // Get specific entries - we always take all of these
            foreach ( KeyValuePair<string, ArmRegister> kvp in iEntries )
            {
                ArmRegister reg = kvp.Value;
                entries.Add( reg.Name, reg );
            }

            // And also common entries
            if ( iLinkedWith != null )
            {
                foreach ( ArmRegister reg in iLinkedWith )
                {
                    // Make sure that the concrete entries override
                    // any common values
                    if ( entries.ContainsKey( reg.Name ) == false )
                    {
                        entries.Add( reg.Name, reg );
                    }
                }
            }

            // Ensure list is really sorted.
            List<ArmRegister> ret = new List<ArmRegister>();
            foreach ( KeyValuePair<string, ArmRegister> pair in entries )
            {
                ret.Add( pair.Value );
            }
            ret.Sort( this );

            // Now we can iterate...
            foreach ( ArmRegister entry in ret )
            {
                yield return entry;
            }
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            SortedList<string, ArmRegister> entries = new SortedList<string, ArmRegister>();

            // Get specific entries - we always take all of these
            foreach ( KeyValuePair<string, ArmRegister> kvp in iEntries )
            {
                ArmRegister reg = kvp.Value;
                entries.Add( reg.Name, reg );
            }

            // And also common entries
            if ( iLinkedWith != null )
            {
                foreach ( ArmRegister reg in iLinkedWith )
                {
                    // Make sure that the concrete entries override
                    // any common values
                    if ( entries.ContainsKey( reg.Name ) == false )
                    {
                        entries.Add( reg.Name, reg );
                    }
                }
            }

            // Ensure list is really sorted.
            List<ArmRegister> ret = new List<ArmRegister>();
            foreach ( KeyValuePair<string, ArmRegister> pair in entries )
            {
                ret.Add( pair.Value );
            }
            ret.Sort( this );

            // Now we can iterate...
            foreach ( ArmRegister entry in ret )
            {
                yield return entry;
            }
        }
        #endregion

        #region From System.Object
        public override string ToString()
        {
            StringBuilder ret = new StringBuilder();
            foreach ( ArmRegister entry in this )
            {
                ret.AppendLine( entry.ToString() );
            }
            return ret.ToString();
        }
        #endregion

        #region Data members
        private object iTag = null;
        private readonly TArmRegisterBank iBank;
        private readonly ArmRegisterCollection iLinkedWith;
        private string iName = string.Empty;
        private IARCBackingStore iBackingStore = null;
        private Dictionary<string, ArmRegister> iEntries = new Dictionary<string, ArmRegister>();
        #endregion
    }

    #region Backing store interface
    public interface IARCBackingStore
    {
        void ARCBSClear();

        ArmRegister ARCBSCreate( TArmRegisterType aType, string aName, uint aValue );
        void ARCBSRemove( ArmRegister aRegister );
    }
    #endregion
}