/*
* 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 SymbianUtils.Tracer;
using SymbianUtils.BasicTypes;
using SymbianStructuresLib.Arm;
using SymbianStructuresLib.Arm.Exceptions;
using SymbianStructuresLib.Arm.SecurityMode;
using SymbianStructuresLib.Arm.Instructions;
using SymbianStructuresLib.Debug.Code;
using SymbianDebugLib.PluginAPI.Types;
using SymbianDebugLib.PluginAPI.Types.Code;
using SymbianETMLib.Common.Types;
using SymbianETMLib.Common.Buffer;
using SymbianETMLib.Common.Engine;
using SymbianETMLib.Common.Config;
using SymbianETMLib.Common.Utilities;

namespace SymbianETMLib.Common.State
{
    public class ETMStateData : ITracer
    {
        #region Constructors
        internal ETMStateData( ETEngineBase aEngine )
        {
            iEngine = aEngine;
            iCurrentState = new ETMDecodeStateUnsynchronized( this );
        }
        #endregion

        #region API
        internal void PushBack( SymByte aByte )
        {
            Buffer.PushBack( aByte );
            iCurrentRawByte = iLastRawByte;
            --iPacketNumber;
        }

        internal void PrepareToHandleByte( SymByte aByte )
        {
            iLastRawByte = iCurrentRawByte;
            iCurrentRawByte = aByte;
            //
            iCurrentState = iCurrentState.PrepareToHandleByte( aByte );
            System.Diagnostics.Debug.Assert( iCurrentState != null );
            //
            ++iPacketNumber;
        }

        internal void IncrementProcessedInstructionCounter()
        {
            ++iNumberOfProcessedInstructions;
        }

        internal uint IncrementPC()
        {
            if ( !iLastBranch.IsUnknown )
            {
                uint instructionSize = (uint) CurrentInstructionSet;
                iPC.Address += instructionSize;
            }

            // Increment the instruction counter irrespective of whether or not we
            // know the program counter address
            IncrementProcessedInstructionCounter();
            return iPC;
        }

        internal ETMInstruction FetchInstruction( uint aAddress )
        {
            ETMInstruction ret = new ETMInstruction( aAddress );
            //
            bool gotCode = false;
            if ( this.LastBranch.IsKnown && Engine.DebugEngineView != null )
            {
                DbgViewCode codeView = Engine.DebugEngineView.Code;

                // In the case where we've been asked to fetch the code from the exception
                // vector, then bypass the rom/rofs code entirely.
                bool isExceptionVector = Config.IsExceptionVector( aAddress );
                if ( isExceptionVector )
                {
                    System.Diagnostics.Debug.Assert( this.CurrentInstructionSet == TArmInstructionSet.EARM );
                    TArmExceptionVector vector = Config.MapToExceptionVector( aAddress );
                    uint rawInstruction = Config.GetExceptionVector( vector );
                    ret.Instruction = codeView.ConvertToInstruction( aAddress, TArmInstructionSet.EARM, rawInstruction );
                }
                else
                {
                    IArmInstruction[] instructions = null;
                    gotCode = codeView.GetInstructions( aAddress, CurrentInstructionSet, 1, out instructions );
                    //
                    if ( gotCode )
                    {
                        System.Diagnostics.Debug.Assert( instructions != null && instructions.Length == 1 );
                        ret.Instruction = instructions[ 0 ];
                    }
                }
            }
            //
            return ret;
        }

        internal void SetUnsynchronized()
        {
            iSynchronized = false;
        }

        internal void SetSynchronized()
        {
            if ( !iSynchronized )
            {
                uint pos = iPacketNumber;
                iEngine.OnSynchronised( pos );
                iSynchronized = true;
            }
        }

        // <summary>
        // Set the known address bits of the program counter. We may not know all
        // bits until an I-sync packet is reached, or then until we see a full 5-byte
        // branch.
        // </summary>
        internal void SetKnownAddressBits( uint aAddress, int aNumberOfValidBits, TETMBranchType aBranchType )
        {
            iLastBranch.SetKnownAddressBits( aAddress, aNumberOfValidBits );
            
            iPC.Address = iLastBranch.Address;
            iPC.KnownBits = iLastBranch.KnownBits;

            // If we know the full branch address, then inform the engine
            if ( iPC.IsKnown )
            {
                iEngine.OnBranch( iPC, iCurrentInstructionSet, iCurrentException, aBranchType );
            }
        }

        internal void SetPC( uint aAddress )
        {
            SetPC( aAddress, this.CurrentInstructionSet );
        }

        internal void SetPC( uint aAddress, TArmInstructionSet aInstructionSet )
        {
            iPC.Address = aAddress;
            iCurrentInstructionSet = aInstructionSet;
            
            // If BBC mode is enabled, i.e. branches are output even when a direct branch is taken
            // then we don't need to emit a branch event when seeing a 'Direct' branch type.
            bool isBBCModeEnabled = Config.BBCModeEnabled;
            if ( isBBCModeEnabled == false && iPC.IsKnown )
            {
                iEngine.OnBranch( iPC, iCurrentInstructionSet, iCurrentException, TETMBranchType.EBranchDirect );
            }
        }

        internal void SetContextID( uint aValue )
        {
            // Tidy up the raw value.
            uint id = ( aValue >> 2 );
            if ( iCurrentContextId != id )
            {
                iCurrentContextId = id;
                iEngine.OnContextSwitch( iCurrentContextId );
            }
        }
        #endregion

        #region Properties
        public uint PacketNumber
        {
            get { return iPacketNumber; }
        }

        public int NumberOfProcessedInstructions
        {
            get { return iNumberOfProcessedInstructions; }
        }

        public SymByte CurrentByte
        {
            get { return iCurrentRawByte; }
        }

        public SymByte LastByte
        {
            get { return iLastRawByte; }
        }

        public ETMDecodeState CurrentState
        {
            get { return iCurrentState; }
        }

        public TArmExceptionType CurrentException
        {
            get { return iCurrentException; }
            set
            {
                if ( iCurrentException != value )
                {
                    iCurrentException = value;
                    Engine.OnExceptionModeChange( iCurrentException );
                }
            }
        }

        public TArmSecurityMode CurrentSecurityMode
        {
            get { return iCurrentSecurityMode; }
            set
            {
                if ( iCurrentSecurityMode != value )
                {
                    iCurrentSecurityMode = value;
                    Engine.OnExceptionModeChange( iCurrentException );
                }
            }
        }

        public TArmInstructionSet CurrentInstructionSet
        {
            get { return iCurrentInstructionSet; }
            set
            {
                if ( iCurrentInstructionSet != value )
                {
                    iCurrentInstructionSet = value;
                }
            }
        }
        #endregion 

        #region Internal properties
        internal SymAddress CurrentAddress
        {
            get { return iPC; }
        }

        internal SymAddressWithKnownBits LastBranch
        {
            get { return iLastBranch; }
        }

        internal ETEngineBase Engine
        {
            get { return iEngine; }
        }

        internal ETMInstruction LastInstruction
        {
            get { return iLastInstruction; }
            set { iLastInstruction = value; }
        }

        internal ETConfigBase Config
        {
            get { return iEngine.Config; }
        }

        private ETBufferBase Buffer
        {
            get { return iEngine.Buffer; }
        }
        #endregion

        #region Internal constants
        #endregion

        #region From ITracer
        public void Trace( string aText )
        {
            iEngine.Trace( aText );
        }

        public void Trace( string aFormat, params object[] aParams )
        {
            iEngine.Trace( aFormat, aParams );
        }
        #endregion

        #region From System.Object
        #endregion

        #region Data members
        private readonly ETEngineBase iEngine;
        private bool iSynchronized = false;
        private int iNumberOfProcessedInstructions = 0;
        private uint iPacketNumber = 0;
        private uint iCurrentContextId = uint.MaxValue;
        private ETMInstruction iLastInstruction = new ETMInstruction();
        private SymAddressWithKnownBits iLastBranch = new SymAddressWithKnownBits();
        private SymAddressWithKnownBits iPC = new SymAddressWithKnownBits();
        private SymByte iCurrentRawByte = 0;
        private SymByte iLastRawByte = 0;
        private ETMDecodeState iCurrentState = null;
        private TArmExceptionType iCurrentException = TArmExceptionType.EUnknown;
        private TArmSecurityMode iCurrentSecurityMode = TArmSecurityMode.EUnknown;
        private TArmInstructionSet iCurrentInstructionSet = TArmInstructionSet.EARM;
        #endregion
    }
}