/*

* 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.Container;

using CrashItemLib.Crash.Threads;

using CrashItemLib.Crash.Processes;

using CrashItemLib.Crash.Registers;

using CrashItemLib.Crash.Registers.Special;

using SymbianUtils.Range;

using SymbianUtils.Enum;

using SymbianStructuresLib.Uids;

using SymbianUtils.DataBuffer;

using SymbianStructuresLib.Arm.Registers;

namespace CrashItemLib.Crash.ExitInfo

{

    [CIDBAttributeColumn( "Name", 0 )]

    [CIDBAttributeColumn( "Value", 1, true )]

    public class CIExitInfo : CIElement

    {

        #region Enumerations

        public enum TExitType

        {

            EExitTypePending = 0,

            EExitTypeKill,

            EExitTypePanic,

            EExitTypeTerminate,

            EExitTypeException

        }

        #endregion

        #region Constructors

        public CIExitInfo( CIElement aParent )

            : base( aParent.Container, aParent )

		{

		}

		#endregion

        #region API

        #endregion

        #region Properties

        public TExitType Type

        {

            get

            {

                TExitType ret = iType;

                //

                if ( !iTypeWasExplicitlySet && OwningThread != null )

                {

                    // A client did not specify an explict exit reason, so in this case

                    // we'll try to work out if we're dealing with an exception based upon

                    // register values. 

                    //

                    // We can only do this if the owning object is available.

                    CIThread thread = OwningThread;

                    CIThreadRegisterListCollection regs = thread.Registers;

                    if ( thread.Registers.Contains( TArmRegisterBank.ETypeException ) )

                    {

                        // Best guess

                        ret = TExitType.EExitTypeException;

                    }

                }

                //

                return iType; 

            }

            set

            {

                iTypeWasExplicitlySet = true;

                iType = value; 

            }

        }

        public string TypeDescription

        {

            get 

            {

                switch( Type )

                {

                case TExitType.EExitTypeException:

                    return "Exception";

                case TExitType.EExitTypePending:

                    return "Pending";

                case TExitType.EExitTypePanic:

                    return "Panic";

                case TExitType.EExitTypeTerminate:

                    return "Terminate";

                case TExitType.EExitTypeKill:

                    return "Kill";

                default:

                    return "Unknown";

                }

            }

        }

        public bool IsAbnormalTermination

        {

            get

            {

                bool ret = false;

                //

                switch ( Type )

                {

                case TExitType.EExitTypeException:

                case TExitType.EExitTypePanic:

                case TExitType.EExitTypeTerminate:

                    ret = true;

                    break;

                default:

                case TExitType.EExitTypeKill:

                case TExitType.EExitTypePending:

                    break;

                }

                //

                return ret;

            }

        }

        public string Category

        {

            get

            {

                string ret = iCategory;

                //

                if ( Type == TExitType.EExitTypeException )

                {

                    CIRegisterExcCode code = RegisterExcCode;

                    if ( code != null )

                    {

                        ret = EnumUtils.ToString( ExceptionCode );

                    }

                }

                //

                return ret; 

            }

            set { iCategory = value; }

        }

        public int Reason

        {

            get

            {

                int ret = iReason;

                //

                if ( Type == TExitType.EExitTypeException )

                {

                    ret = (int) ExceptionCode;

                }

                //

                return ret; 

            }

            set { iReason = value; }

        }

        public CIRegisterFSR RegisterFSR

        {

            get

            {

                CIRegisterFSR ret = null;

                //

                CIRegisterList list = RegListCoProcessor;

                if ( list != null && list.Contains( TArmRegisterType.EArmReg_FSR ) )

                {

                    CIRegister reg = list[ TArmRegisterType.EArmReg_FSR ];

                    ret = reg as CIRegisterFSR;

                }

                //

                return ret;

            }

        }

        public CIRegisterExcCode RegisterExcCode

        {

            get

            {

                CIRegisterExcCode ret = null;

                //

                CIRegisterList list = RegListException;

                if ( list != null && list.Contains( TArmRegisterType.EArmReg_EXCCODE ) )

                {

                    CIRegister reg = list[ TArmRegisterType.EArmReg_EXCCODE ];

                    ret = reg as CIRegisterExcCode;

                }

                //

                return ret;

            }

        }

        public CIRegisterExcCode.TExceptionCode ExceptionCode

        {

            get

            {

                if ( Type != TExitType.EExitTypeException )

                {

                    throw new InvalidOperationException();

                }

                CIRegisterExcCode.TExceptionCode code = CIRegisterExcCode.TExceptionCode.EExceptionCodeUnknown;

                CIRegisterExcCode excCode = RegisterExcCode;

                //

                if ( excCode != null )

                {

                    code = excCode;

                }

                //

                return code;

            }

        }

        public string ExceptionDescription

        {

            get

            {

                string ret = string.Empty;

                //

                if ( Type == TExitType.EExitTypeException )

                {

                    CIRegisterExcCode reg = RegisterExcCode;

                    if ( reg != null )

                    {

                        ret = reg.ExceptionCodeDescription;

                    }

                }

                //

                return ret;

            }

        }

        public CIThread OwningThread

        {

            get { return base.Parent as CIThread; }

        }

        public CIProcess OwningProcess

        {

            get

            { 

                CIProcess ret = base.Parent as CIProcess;

                //

                if ( ret == null && OwningThread != null )

                {

                    ret = OwningThread.OwningProcess;

                }

                //

                return ret;

            }

        }

        #endregion

        #region Internal methods

        private CIRegisterList RegListException

        {

            get

            {

                System.Diagnostics.Debug.Assert( OwningThread != null );

                //

                CIThread thread = (CIThread) OwningThread;

                CIThreadRegisterListCollection registers = thread.Registers;

                //

                if ( registers.Contains( TArmRegisterBank.ETypeException ) )

                {

                    CIRegisterList list = registers[ TArmRegisterBank.ETypeException ];

                    return list;

                }

                //

                return null;

            }

        }

        private CIRegisterList RegListCoProcessor

        {

            get

            {

                System.Diagnostics.Debug.Assert( OwningThread != null );

                //

                CIThread thread = (CIThread) OwningThread;

                CIThreadRegisterListCollection registers = thread.Registers;

                //

                if ( registers.Contains( TArmRegisterBank.ETypeCoProcessor ) )

                {

                    CIRegisterList list = registers[ TArmRegisterBank.ETypeCoProcessor ];

                    return list;

                }

                //

                return null;

            }

        }

        #endregion

        #region From CIElement

        public override void PrepareRows()

        {

            DataBindingModel.ClearRows();

            // Type is common

            CIDBRow rowType= new CIDBRow();

            rowType.Add( new CIDBCell( "Type" ) );

            rowType.Add( new CIDBCell( TypeDescription ) );

            DataBindingModel.Add( rowType );

            // We must prepare them by hand because we show

            // different content depending on the type of exit.

            if ( Type == TExitType.EExitTypePending )

            {

                // Nothing to add

            }

            else if ( Type == TExitType.EExitTypeException )

            {

                string code = ExceptionDescription;

                if ( code != string.Empty )

                {

                    CIDBRow rowExcCode = new CIDBRow();

                    rowExcCode.Add( new CIDBCell( "Exception Code" ) );

                    rowExcCode.Add( new CIDBCell( code ) );

                    DataBindingModel.Add( rowExcCode );

                }

                CIRegisterFSR fsr = RegisterFSR;

                if ( fsr != null )

                {

                    CIDBRow rowFSR = new CIDBRow();

                    rowFSR.Add( new CIDBCell( "Fault Type" ) );

                    rowFSR.Add( new CIDBCell( fsr.FaultDescription ) );

                    DataBindingModel.Add( rowFSR );

                }

            }

            else

            {

                // Panic, terminate

                CIDBRow rowCategory = new CIDBRow();

                rowCategory.Add( new CIDBCell( "Category" ) );

                rowCategory.Add( new CIDBCell( Category ) );

                DataBindingModel.Add( rowCategory );

                CIDBRow rowReason = new CIDBRow();

                rowReason.Add( new CIDBCell( "Reason" ) );

                rowReason.Add( new CIDBCell( Reason.ToString() ) );

                DataBindingModel.Add( rowReason );

                CIDBRow rowFullPanic = new CIDBRow();

                rowFullPanic.Add( new CIDBCell( "In Full" ) );

                rowFullPanic.Add( new CIDBCell( string.Format( "{0}-{1}", Category, Reason ) ) );

                DataBindingModel.Add( rowFullPanic );

            }

        }

        #endregion

        #region From System.Object

        public override string ToString()

        {

            StringBuilder ret = new StringBuilder();

            //

            if ( Type == TExitType.EExitTypePending )

            {

                ret.Append( "Pending" );

            }

            else if ( Type == TExitType.EExitTypeException )

            {

                ret.Append( "Exception" );

            }

            else

            {

                ret.AppendFormat( "{0}-{1}", Category, Reason );

            }

            //

            return ret.ToString();

        }

        #endregion

        #region Data members

        private int iReason = 0;

        private string iCategory = string.Empty;

        private bool iTypeWasExplicitlySet = false;

        private TExitType iType = TExitType.EExitTypePending;

        #endregion

    }

}