/*
* 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;
using System.Xml;
using SymbianUtils.BasicTypes;
using SymbianStructuresLib.Arm.Exceptions;
using SymbianStructuresLib.Arm.Registers;
using SymbianStructuresLib.Arm.Registers.EmbeddedTrace;
using SymbianStructuresLib.Arm.Registers.CoProcessor;
using SymbianETMLib.Common.Buffer;
using SymbianETMLib.Common.State;
using SymbianETMLib.Common.Types;
using SymbianETMLib.Common.Utilities;
using SymbianETMLib.Common.Exception;

namespace SymbianETMLib.Common.Config
{
    public abstract class ETConfigBase
    {
        #region Constructors
        protected ETConfigBase( ETBufferBase aBuffer )
        {
            iBuffer = aBuffer;
            //
            RegisterETMControl = 0xC000; // 4 byte context id
            RegisterSysConControl = 1 << 13; // Assume HIVECS;
            //
            SetExceptionVector( TArmExceptionVector.EReset, 0 );
            SetExceptionVector( TArmExceptionVector.EUndefinedInstruction, 0 );
            SetExceptionVector( TArmExceptionVector.ESVC, 0 );
            SetExceptionVector( TArmExceptionVector.EPrefetchAbort, 0 );
            SetExceptionVector( TArmExceptionVector.EDataAbort, 0 );
            SetExceptionVector( TArmExceptionVector.EIRQ, 0 );
            SetExceptionVector( TArmExceptionVector.EFIQ, 0 );
        }
        #endregion

        #region API
        public void AddContextIdMapping( uint aId, string aName )
        {
            // Clean the context id so that it matches the kind of data 
            // we see on the phone.
            uint id = aId & 0x0FFFFFFF;

            if ( !iContextIDs.ContainsKey( id ) )
            {
                iContextIDs.Add( id, aName );
            }
        }

        public void SetExceptionVector( TArmExceptionVector aVector, uint aInstruction )
        {
            if ( !iExceptionVectors.ContainsKey( aVector ) )
            {
                iExceptionVectors.Add( aVector, aInstruction );
            }
            else
            {
                iExceptionVectors[ aVector ] = aInstruction;
            }
        }

        public string GetContextID( uint aID )
        {
            string ret = "Unknown Thread";
            //
            uint lastKey = 0;
            //
            foreach ( KeyValuePair<uint, string> kvp in iContextIDs )
            {
                if ( kvp.Key > aID )
                {
                    if ( lastKey != 0 )
                    {
                        ret = kvp.Value;//iContextIDs[ lastKey ];
                    }
                    break;
                }
                else
                {
                    lastKey = kvp.Key;
                }
            }
            //
            return ret;
        }
        #endregion

        #region API - internal
        internal uint GetExceptionVector( TArmExceptionVector aVector )
        {
            uint ret = iExceptionVectors[ aVector ];
            return ret;
        }

        internal bool IsExceptionVector( uint aAddress )
        {
            bool ret = false;
            
            // Get current vector setting and also the vector address range
            TArmExceptionVectorLocation type = ExceptionVectorLocation;
            uint min = (uint) type;
            uint max = min + (uint) TArmExceptionVector.EFIQ;
            //
            ret = ( aAddress >= min && aAddress <= max );
            //
            return ret;
        }

        internal TArmExceptionVector MapToExceptionVector( uint aAddress )
        {
            System.Diagnostics.Debug.Assert( IsExceptionVector( aAddress ) );
            // 
            TArmExceptionVector ret = TArmExceptionVector.EUndefinedInstruction;
            //
            uint baseAddress = (uint) ExceptionVectorLocation;
            uint delta = aAddress - baseAddress;
            switch ( delta )
            {
            case (uint) TArmExceptionVector.EReset:
            case (uint) TArmExceptionVector.EUndefinedInstruction:
            case (uint) TArmExceptionVector.ESVC:
            case (uint) TArmExceptionVector.EPrefetchAbort:
            case (uint) TArmExceptionVector.EDataAbort:
            case (uint) TArmExceptionVector.EIRQ:
            case (uint) TArmExceptionVector.EFIQ:
                ret = (TArmExceptionVector) delta;
                break;
            default:
                throw new ETMException( "ERROR - specified address is an unsupported vector location" );
            }
            //
            return ret;
        }
        #endregion

        #region Properties
        public bool Verbose
        {
            get { return iVerbose; }
            set { iVerbose = value; }
        }

        public bool BBCModeEnabled
        {
            get
            {
                //                        10 0 0 000 00 01
                SymMask mask = new SymMask( "1 # ### ## ##" );
                uint val = mask.Apply( RegisterETMControl );
                return ( val != 0 );
            }
        }

        public int ContextIDSize
        {
            get
            {
                // Bits [15:14] define the context id size.
                uint ret = RegisterETMControl & 0xC000; // b11000000 00000000
                ret >>= 14;
                if ( ret > 0 )
                {
                    ++ret;
                }
                return (int) ret;
            }
        }

        public uint RegisterETMControl
        {
            get { return iRegistersETM[ TArmRegisterType.EArmReg_ETM_Control ].Value; }
            set { iRegistersETM[ TArmRegisterType.EArmReg_ETM_Control ].Value = value; }
        }

        public uint RegisterETMId
        {
            get { return iRegistersETM[ TArmRegisterType.EArmReg_ETM_Id ].Value; }
            set { iRegistersETM[ TArmRegisterType.EArmReg_ETM_Id ].Value = value; }
        }

        public uint RegisterSysConControl
        {
            get { return iRegistersCoProSystemControl[ TArmRegisterType.EArmReg_SysCon_Control ].Value; }
            set { iRegistersCoProSystemControl[ TArmRegisterType.EArmReg_SysCon_Control ].Value = value; }
        }

        public TArmExceptionVectorLocation ExceptionVectorLocation
        {
            get
            {
                TArmExceptionVectorLocation ret = TArmExceptionVectorLocation.ENormal;
                uint mask = (uint) ( 1 << 13 );
                if ( ( RegisterSysConControl & mask ) == mask )
                {
                    ret = TArmExceptionVectorLocation.EHigh;
                }
                return ret;
            }
        }

        internal TETMBranchCompressionScheme BranchCompressionScheme
        {
            get
            {
                TETMBranchCompressionScheme ret = TETMBranchCompressionScheme.EOriginal;
                                // 101011 100 1 0000 00001111 00001111
                SymMask mask = new SymMask( "1 #### ######## ########" );
                if ( mask.IsMatch( RegisterETMId ) )
                {
                    ret = TETMBranchCompressionScheme.EAlternative;
                }
                return ret;
            }
        }
        #endregion

        #region Internal methods
        protected ETBufferBase Buffer
        {
            get { return iBuffer; }
        }
        #endregion

        #region From System.Object
        #endregion

        #region Data members
        private readonly ETBufferBase iBuffer;
        private bool iVerbose = false;
        private ArmETMRegisterCollection iRegistersETM = new ArmETMRegisterCollection();
        private ArmCoProSystemControlRegisterCollection iRegistersCoProSystemControl = new ArmCoProSystemControlRegisterCollection();
        private Dictionary<TArmExceptionVector, uint> iExceptionVectors = new Dictionary<TArmExceptionVector, uint>();
        private SortedDictionary<uint, string> iContextIDs = new SortedDictionary<uint, string>();
        #endregion
    }
}