/*
* Copyright (c) 2004-2008 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;
using SymbianStructuresLib.Arm.Registers;
using SymbianStructuresLib.Debug.Symbols;
using SymbianDebugLib.Engine;
using SymbianDebugLib.PluginAPI.Types.Symbol;
using CrashDebuggerLib.Structures.KernelObjects;
using CrashDebuggerLib.Structures.Common;
using CrashDebuggerLib.Structures.Process;

namespace CrashDebuggerLib.Structures.Register
{
    public class RegisterCollection : CrashDebuggerAware, IEnumerable<RegisterEntry>, IARCBackingStore, IComparer<RegisterEntry>
    {
        #region Enumerations
        public enum TType
        {
            // Special cases
            ETypeGeneral        = -1,       // CPU specific
            ETypeCommonBank     = 0,        // R00 -> R07 inclusive

            // Linked into to CPSR values
            ETypeUser           = 0x10,     // 0b10000
            ETypeFastInterrupt  = 0x11,     // 0b10001
            ETypeInterrupt      = 0x12,     // 0b10010
            ETypeSupervisor     = 0x13,     // 0b10011
            ETypeAbort          = 0x17,     // 0b10111
            ETypeUndefined      = 0x1B,     // 0b11011

            // Not used in Symbian OS
            ETypeSystem         = 0x1F      // 0b11111
        }
        #endregion

        #region Constructors
        internal RegisterCollection( CrashDebuggerInfo aCrashDebugger, TType aType )
            : this( aCrashDebugger, aType, null, null )
        {
        }

        internal RegisterCollection( CrashDebuggerInfo aCrashDebugger, TType aType, DProcess aProcess )
            : this( aCrashDebugger, aType, aProcess, null )
        {
        }

        internal RegisterCollection( RegisterCollection aCopy, TType aType, DProcess aProcess )
            : this( aCopy.CrashDebugger, aType, aProcess, null )
        {
            foreach ( RegisterEntry entry in aCopy )
            {
                Add( entry.OriginalName, entry.Value );
            }
        }

        internal RegisterCollection( CrashDebuggerInfo aCrashDebugger, TType aType, DProcess aProcess, RegisterCollection aLinkedWith )
            : base( aCrashDebugger )
        {
            iType = aType;
            iProcess = aProcess;

            iEntries = new ArmRegisterCollection();
            iEntries.BackingStore = this as IARCBackingStore;

            iLinkedWith = aLinkedWith;
        }
        #endregion

        #region API
        public RegisterEntry Add( string aName, uint aValue )
        {
            ArmRegister added = iEntries.Add( aName, aValue );
            RegisterEntry ret = added as RegisterEntry;
            return ret;
        }

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

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

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

            return ret;
        }

        public void Clear()
        {
            iEntries.Clear();
        }

        public static string BankName( TType aType )
        {
            string ret = string.Empty;
            //
            switch ( aType )
            {
            default:
            case TType.ETypeGeneral:
            case TType.ETypeCommonBank:
                ret = string.Empty;
                break;
            case TType.ETypeAbort:
                ret = "ABT";
                break;
            case TType.ETypeFastInterrupt:
                ret = "FIQ";
                break;
            case TType.ETypeInterrupt:
                ret = "IRQ";
                break;
            case TType.ETypeSupervisor:
                ret = "SVC";
                break;
            case TType.ETypeSystem:
                ret = "SYS";
                break;
            case TType.ETypeUndefined:
                ret = "UND";
                break;
            case TType.ETypeUser:
                ret = "USR";
                break;
            }
            //
            return ret;
        }
        #endregion

        #region Properties
        public string Name
        {
            get { return iName; }
            set { iName = value; }
        }

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

        public RegisterEntry this[ TArmRegisterType aType ]
        {
            get
            {
                RegisterEntry ret = new RegisterEntry( this, aType );
                return this[ ret.Name ];
            }
        }

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

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

        #region Internal methods
        public void Dump()
        {
            System.Diagnostics.Debug.WriteLine( "REGISTERS [" + iType + "]" );
            System.Diagnostics.Debug.WriteLine( string.Empty );
            //
            string regs = this.ToString();
            System.Diagnostics.Debug.WriteLine( regs );
        }

        internal Symbol LookUpSymbol( uint aAddress )
        {
            Symbol ret = null;
            //
            if ( iProcess != null )
            {
                ret = iProcess.LookUpSymbol( aAddress );
            }
            else
            {
                ret = base.CrashDebugger.LookUpSymbol( aAddress );
            }
            //
            return ret;
        }
        #endregion

        #region IArmRegisterBackingStore Members
        void IARCBackingStore.ARCBSClear()
        {
            // Nothing to do - our entries are derived from ArmRegister and 
            // are owned by iEntries.
        }

        void IARCBackingStore.ARCBSRemove( ArmRegister aRegister )
        {
            // Nothing to do - our entries are derived from ArmRegister and 
            // are owned by iEntries.
        }

        ArmRegister IARCBackingStore.ARCBSCreate( TArmRegisterType aType, string aName, uint aValue )
        {
            RegisterEntry entry = null;
            //            
            if ( aType == TArmRegisterType.EArmReg_CPSR )
            {
                // CPSR is a bit special...
                entry = new RegisterEntryCPSR( this, aValue );
            }
            else
            {
                entry = new RegisterEntry( this, aName, aValue );
                entry.RegType = aType;
            }
            //
            return entry;
        }
        #endregion

        #region From IComparer<RegisterEntry>
        public int Compare( RegisterEntry aLeft, RegisterEntry aRight )
        {
            int ret = -1;

            // 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<RegisterEntry>
        public IEnumerator<RegisterEntry> GetEnumerator()
        {
            SortedList<string, RegisterEntry> entries = new SortedList<string, RegisterEntry>();

            // Get specific entries - we always take all of these
            foreach ( ArmRegister reg in iEntries )
            {
                entries.Add( reg.Name, (RegisterEntry) reg );
            }

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

            // For some reason, sorted list isn't actually sorting the entries
            // by key properly. We must do this ourselves... Ugh :(
            List<RegisterEntry> ret = new List<RegisterEntry>();
            foreach ( KeyValuePair<string, RegisterEntry> pair in entries )
            {
                ret.Add( pair.Value );
            }
            ret.Sort( this );

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

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            IEnumerator<RegisterEntry> self = (IEnumerator<RegisterEntry>) this;
            System.Collections.IEnumerator ret = (System.Collections.IEnumerator) self;
            return ret;
        }
        #endregion

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

        #region Data members
        private readonly TType iType;
        private readonly DProcess iProcess;
        private readonly RegisterCollection iLinkedWith;
        private readonly ArmRegisterCollection iEntries;
        private string iName = string.Empty;
        #endregion
    }
}