/*
* 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.IO;
using System.Text;
using System.Security.Cryptography;
using System.Collections.Generic;
using CrashItemLib.Crash;
using CrashItemLib.Crash.Base;
using CrashItemLib.Crash.Processes;
using CrashItemLib.Crash.Registers;
using CrashItemLib.Crash.Registers.Special;
using CrashItemLib.Crash.Stacks;
using CrashItemLib.Crash.Threads;
using CrashItemLib.Crash.Symbols;
using CrashItemLib.Crash.Summarisable;
using SymbianStructuresLib.Arm.Registers;


namespace CrashInfoFilePlugin.PluginImplementations.FileFormat
{
    public class CCrashInfoHashBuilder
    {
        #region Enumerations
        [Flags]
        public enum TConfiguration
        {
            // <summary>
            // Include stack data in hash
            // </summary>
            EIncludeStack = 1,

            // <summary>
            // Force inclusion of stack data in hash, even if hash builder
            // believes that it's inclusion is not needed in order to uniquely
            // pin-point the crash.
            // </summary>
            EIncludeStackForced = 2,

            // <summary>
            // By default, offset is only included in program counter symbol. 
            // This will force it to be incldued for all symbols (i.e. even
            // those within stack trace).
            // </summary>
            EIncludeOffsetsForAllSymbols = 4,

            // <summary>
            // Include the processor mode at the time of the crash within the hash.
            // </summary>
            EIncludeProcessorMode = 8,

            // <summary>
            // By default we output an MD5 hash, but you can enable plain text
            // output by using this option.
            // </summary>
            EOutputAsText = 16,
            
            // <summary>
            // A general purpose default configuration
            // </summary>
            EDefault = EIncludeStack | EIncludeStackForced | EIncludeProcessorMode
        }
        #endregion

        #region Factory
        public static CCrashInfoHashBuilder New( TConfiguration aConfig, CISummarisableEntity aEntity )
        {
            CCrashInfoHashBuilder ret = CCrashInfoHashBuilder.New( aConfig, aEntity, KDefaultNumberOfStackEntriesToCheckForSymbols );
            return ret;
        }

        public static CCrashInfoHashBuilder New( TConfiguration aConfig, CISummarisableEntity aEntity, int aNumberOfStackEntriesToCheck )
        {
            // By default we'll return an empty string for the hash if mandatory input
            // elements are not available
            CCrashInfoHashBuilder ret = null;
            //
            CIStack stack = aEntity.Stack;
            CIThread thread = aEntity.Thread;
            CIProcess process = aEntity.Process;
            CIRegisterList regs = aEntity.Registers;
            //
            if ( stack != null && regs != null )
            {
                if ( process == null || thread == null )
                {
                    ret = new CCrashInfoHashBuilder( aConfig, regs, stack, aNumberOfStackEntriesToCheck );
                }
                else
                {
                    ret = new CCrashInfoHashBuilder( aConfig, regs, stack, thread, process, aNumberOfStackEntriesToCheck );
                }
            }
            else
            {
                throw new ArgumentException( LibResources.KRes_CCrashInfoHashBuilder_BadSummarisable );
            }
            //
            return ret;
        }
        #endregion

        #region Constructors
        private CCrashInfoHashBuilder( TConfiguration aConfig, CIRegisterList aRegisters, CIStack aStack, int aNumberOfStackEntriesToCheck )
            : this( aConfig, aRegisters, aStack, null, null, aNumberOfStackEntriesToCheck )
        {
        }

        private CCrashInfoHashBuilder( TConfiguration aConfig, CIRegisterList aRegisters, CIStack aStack, CIThread aThread, CIProcess aProcess, int aNumberOfStackEntriesToCheck )
        {
            iConfig = aConfig;
            iRegisters = aRegisters;
            iStack = aStack;
            iProcess = aProcess;
            iThread = aThread;
            iNumberOfStackEntriesToCheck = aNumberOfStackEntriesToCheck;
        }
        #endregion

        #region API
        public string GetHash()
        {
            StringBuilder hash = new StringBuilder();
            //
            if ( ( iConfig & TConfiguration.EIncludeProcessorMode ) != 0 )
            {
                string processorMode = GetProcessorMode();
                hash.AppendFormat( "MODE: [{0}] ", processorMode );
            }
            //
            string moduleName = GetAppropriateBinaryModuleName();
            hash.AppendFormat( "MODN: [{0}] ", moduleName );
            //
            string programCounter = GetProgramCounter();
            hash.AppendFormat( "PC: [{0}] ", programCounter );
            //
            if ( ( iConfig & TConfiguration.EIncludeStack ) != 0 || ( iConfig & TConfiguration.EIncludeStackForced ) != 0 )
            {
                string stackSymbols = GetStackSymbols();
                hash.AppendFormat( "STK: [{0}] ", stackSymbols );
            }
            
            // Final stage is to MD5 hash the text, unless the caller requested
            // plain text output.
            string ret = hash.ToString();            
            if ( ( iConfig & TConfiguration.EOutputAsText ) == 0 )
            {
                ret = GetMD5( ret );
            }
            //
            return ret;
        }
        #endregion

        #region Internal constants
        private const int KDefaultNumberOfStackEntriesToCheckForSymbols = 4;
        #endregion

        #region Internal methods
        private string GetProcessorMode()
        {
            string ret = LibResources.KRes_CCrashInfoHashBuilder_NoCPUMode;
            //
            if ( iRegisters.IsCurrentProcessorMode )
            {
                CIRegisterCPSR cpsr = iRegisters[ TArmRegisterType.EArmReg_CPSR ] as CIRegisterCPSR;
                if ( cpsr != null )
                {
                    ret = ArmRegisterBankUtils.BankAsString( cpsr.ProcessorMode );
                }
            }
            //
            return ret;
        }

        private string GetAppropriateBinaryModuleName()
        {
            // We'll use the name of the binary associated with the program 
            // counter symbol (if present) or then if not, we'll fall back
            // to using the process name.
            string ret = string.Empty;
            //
            bool fallBack = false;
            if ( iRegisters.Contains( TArmRegisterType.EArmReg_PC ) )
            {
                CIRegister pc = iRegisters[ TArmRegisterType.EArmReg_PC ];
                if ( pc.Symbol.IsNull == false )
                {
                    // Symbol available - use the associated binary name
                    string binName = pc.Symbol.Symbol.Collection.FileName.EitherFullNameButDevicePreferred;
                    ret = Path.GetFileName( binName );
                }
                else
                {
                    fallBack = true;
                }
            }
            else
            {
                fallBack = true;
            }

            // Do we need to fallback because symbol et al was unavailable?
            if ( fallBack )
            {
                // No Symbol, then in this case we'll try to fall back
                // to the process name. 
                if ( iProcess != null )
                {
                    ret = iProcess.Name;
                }
                else
                {
                    // Must be e.g. IRQ, FIQ, ABT, etc
                    ret = LibResources.KRes_CCrashInfoHashBuilder_AbortModeStack;
                }
            }
            //
            return ret;
        }

        private string GetProgramCounter()
        {
            string ret = string.Empty;
            //
            if ( iRegisters.Contains( TArmRegisterType.EArmReg_PC ) )
            {
                CIRegister pc = iRegisters[ TArmRegisterType.EArmReg_PC ];
                ret = CleanSymbol( pc.Value, pc.Symbol, true );
            }
            //
            return ret;
        }

        private string GetStackSymbols()
        {
            StringBuilder ret = new StringBuilder();
            //
            if ( iStack.IsStackOutputAvailable )
            {
                bool isOverflow = iStack.IsOverflow;
                bool isForced = ( iConfig & TConfiguration.EIncludeStackForced ) != 0;
                bool isNullDereference = ( iStack.Registers.Contains( TArmRegisterType.EArmReg_00 ) && iStack.Registers[ TArmRegisterType.EArmReg_00 ].Value == 0 );

                // If dealing with a stack overflow, then we don't, by default, include any
                // symbols from the stack, as they are likely to be entirely dirty or "ghosts" for
                // the most part. 
                //
                // Furthermore, if the 'crash' was caused by dereferencing a NULL this pointer
                // (which is somewhat of a guess on our part, but we ascertain this by inspecting
                // the value of R0) then we don't include stack either.
                //
                // However, the above behaviour can be overriden by forcing stack processing.
                bool processEntries = ( ( isOverflow == false && isNullDereference == false ) || isForced );
                if ( processEntries )
                {
                    // Get the entries and work out the number of items we should check for
                    // associated symbols.
                    CIElementList<CIStackEntry> stackEntries = iStack.ChildrenByType<CIStackEntry>();

                    // Discard all the entries that are outside of the stack pointer range.
                    // Once we see a register-based entry (for accurate decoding) or the current
                    // stack pointer entry, we've reached the start of the interesting stack data.
                    //
                    // However, if there has been a stack overflow then don't discard anything
                    // or else we'll end up with nothing left!
                    if ( iStack.IsOverflow == false && stackEntries.Count > 0 )
                    {
                        int i = 0;
                        while ( stackEntries.Count > 0 )
                        {
                            // If we see a register based entry then the stack reconstruction almost certainly
                            // used the accurate algorithm.
                            //
                            // Since we have already included the program counter in the hash text, it doesn't
                            // make sense to include it twice, so skip that.
                            // However, link register might be useful.
                            bool remove = true;
                            CIStackEntry entry = stackEntries[ i ];

                            if ( entry.IsCurrentStackPointerEntry )
                            {
                                break;
                            }
                            else if ( entry.IsRegisterBasedEntry )
                            {
                                // Preserve LR, skip PC
                                if ( entry.Register.Type == TArmRegisterType.EArmReg_LR )
                                {
                                    ++i;
                                    remove = false;
                                }
                            }

                            if ( remove )
                            {
                                stackEntries.RemoveAt( 0 );
                            }
                        }
                    }

                    // Did the caller also want offsets within the output? By default only the program
                    // counter receives this treatment, but it can be overridden.
                    bool includeOffset = ( iConfig & TConfiguration.EIncludeOffsetsForAllSymbols ) != 0;

                    // We should now have the stack entries directly relating to the crash call stack.
                    // Process them in turn, but only look at entries which happen to have associated
                    // symbols.
                    
                    int SymbolsNeeded = iNumberOfStackEntriesToCheck;
                    foreach (CIStackEntry entry in stackEntries)
                    {                       
                        if ( entry.Symbol != null && entry.Symbol.IsNull == false )
                        {
                            string txt = CleanSymbol( entry.Data, entry.Symbol, includeOffset );
                            ret.AppendFormat( "{0}, ", txt );
                            SymbolsNeeded--;
                        }     
                        if (SymbolsNeeded == 0)
                        {
                            break;
                        }
                    }
                   
                    // Remove trailing comma
                    string t = ret.ToString();
                    if ( t.EndsWith( ", " ) )
                    {
                        ret = ret.Remove( ret.Length - 2, 2 );
                    }
                }
            }
            //
            string final = ret.ToString().TrimEnd();
            return final;
        }

        private string GetMD5( string aMakeHash )
        {
            MD5 md5 = MD5.Create();
            byte[] inputBytes = Encoding.ASCII.GetBytes( aMakeHash );
            byte[] hash = md5.ComputeHash( inputBytes );
            //
            StringBuilder sb = new StringBuilder();
            //
            for ( int i = 0; i < hash.Length; i++ )
            {
                sb.Append( hash[ i ].ToString( "x2" ) );
            }
            //
            return sb.ToString();
        }

        private static string CleanSymbol( uint aAddress, CISymbol aSymbol, bool aAddOffset )
        {
            string ret = string.Empty;
            //
            if ( aSymbol.IsNull == false )
            {
                if ( aAddOffset )
                {
                    // Only include the name and offset, not the address
                    uint offset = aSymbol.Symbol.Offset( aAddress );
                    ret = string.Format( "|0x{0:x4}| {1}", offset, aSymbol.Symbol.Name );
                }
                else
                {
                    ret = aSymbol.Symbol.Name;
                }
            }
            //
            return ret;
        }
        #endregion

        #region Data members
        private readonly TConfiguration iConfig;
        private readonly CIRegisterList iRegisters;
        private readonly CIStack iStack;
        private readonly CIThread iThread;
        private readonly CIProcess iProcess;
        private readonly int iNumberOfStackEntriesToCheck;
        #endregion
    }
}