/*
* 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.Text.RegularExpressions;
using System.IO;
using System.Collections.Generic;
using CrashItemLib.PluginAPI;
using CrashItemLib.Crash;
using CrashItemLib.Crash.Source;
using CrashItemLib.Crash.Processes;
using CrashItemLib.Crash.Registers;
using CrashItemLib.Crash.Registers.Special;
using CrashItemLib.Crash.Utils;
using CrashItemLib.Crash.Threads;
using CrashItemLib.Crash.CodeSegs;
using CrashItemLib.Crash.Stacks;
using CrashItemLib.Crash.Summarisable;
using CrashItemLib.Crash.Messages;
using CrashItemLib.Crash.Telephony;
using CrashItemLib.Crash.Memory;
using CrashItemLib.Crash.InfoHW;
using CrashItemLib.Crash.InfoSW;
using CrashItemLib.Crash.Events;
using CrashItemLib.Crash.Header;
using CrashItemLib.Crash.Container;
using SymbianStructuresLib.Arm.Registers;
using SymbianUtils.DataBuffer;
using SymbianUtils.DataBuffer.Primer;
using SymbianUtils.Range;
using DExcPlugin.Extractor;
using EM=DExcPlugin.ExpressionManager.DExcExpressionManager;

namespace DExcPlugin.Transformer
{
	internal class DExcTransformer
	{
		#region Constructors
        public DExcTransformer( CFFSource aDescriptor, CFFDataProvider aDataProvider, DExcExtractedData aData )
		{
            iData = aData;
            iDescriptor = aDescriptor;
            iDataProvider = aDataProvider;
        }
        #endregion

        #region API
        public CIContainer Transform()
        {
            try
            {
                iContainer = iDataProvider.CreateContainer( iDescriptor );

                SaveInputData();

                CreateHeader();
                CIProcess process = CreateProcess();
                CreateThread( process );
            }
            catch ( Exception e )
            {
#if DEBUG
                System.Diagnostics.Debug.WriteLine( "DEXC READER QUEUE EXCEPTION: " + e.Message );
                System.Diagnostics.Debug.WriteLine( "DEXC READER QUEUE STACK: " + e.StackTrace );
#endif
                //
                iContainer = iDataProvider.CreateErrorContainer( iDescriptor );
                CIMessageError error = new CIMessageError( iContainer, "Error" );
                error.AddLine( e.Message );
                iContainer.Messages.Add( error );
            }
            //
            return iContainer;
        }
        #endregion

        #region Internal methods
        private void SaveInputData()
        {
            string inputData = iData.ToString();

            // Convert the entire text data into binary
            List<byte> inputDataAsBytes = new List<byte>();

            // We just want to map the raw unicode character onto a single byte.
            // ASCII range is probably not sufficient (guess?) so this is why we
            // do not use System.Text.ASCIIEncoding, but rather roll our own.
            foreach ( char c in inputData )
            {
                byte b = System.Convert.ToByte( c );
                inputDataAsBytes.Add( b );
            }

            CISourceElement source = iContainer.Source;
            source.InputDataClear();
            source.InputDataAdd( inputDataAsBytes.ToArray() );
        }

        private void CreateHeader()
        {
            CIHeader header = iContainer.Header;
            header.CrashTime = iDescriptor.MasterFile.LastWriteTime;
            header.FileFormatVersion = "D_EXC for Symbian OS EKA2";
        }

        private CIProcess CreateProcess()
        {
            CIProcess process = new CIProcess( iContainer );

            ExtractProcess( process );
            ExtractProcessCodeSegs( process );

            iContainer.AddChild( process );
            return process;
        }

        private CIThread CreateThread( CIProcess aProcess )
        {
            // Make a new thread
            CIThread thread = aProcess.CreateThread();

            // Extract items
            ExtractThread( thread );
            ExtractThreadExitReason( thread );
            ExtractThreadRegisters( thread );
            ExtractThreadStack( thread );

            iContainer.AddChild( thread );
            return thread;
        }
        #endregion

        #region Internal constants
        #endregion

        #region Helpers - process
        private void ExtractProcess( CIProcess aProcess )
        {
            // Extract process info from thread full name.
            DExcExtractorList threadInfo = iData[ DExcExtractorListType.EListThread ];
            foreach ( string line in threadInfo )
            {
                Match m = EM.ThreadName.Match( line );
                if ( m.Success )
                {
                    CIFullNameUtils parser = new CIFullNameUtils( m.Groups[ 1].Value );
                    parser.GetProcessInfo( aProcess );
                    
                    return;
                }
            }
        }

        private void ExtractProcessCodeSegs( CIProcess aProcess )
        {
            DExcExtractorList codeSegInfo = iData[ DExcExtractorListType.EListCodeSegments ];
            foreach ( string line in codeSegInfo )
            {
                Match m = EM.CodeSegmentsEntry.Match( line );
                if ( m.Success )
                {
                    GroupCollection groups = m.Groups;
                    //
                    uint codeSegBase = uint.Parse( groups[ 1 ].Value, System.Globalization.NumberStyles.HexNumber );
                    uint codeSegLimit = uint.Parse( groups[ 2 ].Value, System.Globalization.NumberStyles.HexNumber );
                    string codeSegName = groups[ 3 ].Value;
                    //
                    aProcess.CreateCodeSeg( codeSegName, codeSegBase, codeSegLimit );
                }
            }
        }
        #endregion

        #region Helpers - thread
        private void ExtractThread( CIThread aThread )
        {
            // Extract process info from thread full name.
            DExcExtractorList threadInfo = iData[ DExcExtractorListType.EListThread ];
            foreach ( string line in threadInfo )
            {
                Match m = EM.ThreadName.Match( line );
                if ( m.Success )
                {
                    CIFullNameUtils parser = new CIFullNameUtils( m.Groups[ 1 ].Value );
                    parser.GetThreadInfo( aThread );
                }
                else
                {
                    m = EM.ThreadId.Match( line );
                    if ( m.Success )
                    {
                        aThread.Id = int.Parse( m.Groups[ 1 ].Value );
                    }
                }
            }
        }

        private void ExtractThreadExitReason( CIThread aThread )
        {
            aThread.ExitInfo.Type = CrashItemLib.Crash.ExitInfo.CIExitInfo.TExitType.EExitTypeException;

            // Extract process info from thread full name.
            DExcExtractorList threadInfo = iData[ DExcExtractorListType.EListThread ];
            foreach ( string line in threadInfo )
            {
                Match m = EM.ThreadPanicDetails.Match( line );
                if ( m.Success )
                {
                    aThread.ExitInfo.Type = CrashItemLib.Crash.ExitInfo.CIExitInfo.TExitType.EExitTypePanic;
                    aThread.ExitInfo.Category = m.Groups[ 1 ].Value;
                    aThread.ExitInfo.Reason = int.Parse( m.Groups[ 2 ].Value );
                }
            }
        }

        private void ExtractThreadRegisters( CIThread aThread )
        {
            CIThreadRegisterListCollection threadRegs = aThread.Registers;
            CIRegisterList regListUser = threadRegs[ TArmRegisterBank.ETypeUser ];
            CIRegisterList regListEXC = threadRegs[ TArmRegisterBank.ETypeException ];
            CIRegisterList regListCOP = threadRegs[ TArmRegisterBank.ETypeCoProcessor ];
            CIRegisterList regListSVC = threadRegs[ TArmRegisterBank.ETypeSupervisor ];

            #region User registers
            foreach ( string line in iData[ DExcExtractorListType.EListRegistersUser ] )
            {
                Match m = EM.RegistersUserSet.Match( line );
                if ( m.Success )
                {
                    GroupCollection groups = m.Groups;
                    int firstReg = int.Parse( groups[ 1 ].Value );
                    for ( int i = firstReg; i < firstReg + 4; i++ )
                    {
                        Group gp = groups[ 2 + ( i - firstReg ) ];
                        uint value = uint.Parse( gp.Value, System.Globalization.NumberStyles.HexNumber );
                        TArmRegisterType regType = (TArmRegisterType) i;
                        regListUser[ regType ].Value = value;
                    }
                }
                else
                {
                    m = EM.RegistersUserCPSR.Match( line );
                    if ( m.Success )
                    {
                        // Get CPSR value and set it
                        uint cpsrValue = uint.Parse( m.Groups[ 1 ].Value, System.Globalization.NumberStyles.HexNumber );
                        threadRegs.CPSR = cpsrValue;
                    }
                }
            }
            #endregion

            #region Exception registers
            foreach ( string line in iData[ DExcExtractorListType.EListRegistersException ] )
            {
                Match m = EM.RegistersExceptionSet1.Match( line );
                if ( m.Success )
                {
                    GroupCollection groups = m.Groups;
                    //
                    regListEXC[ TArmRegisterType.EArmReg_EXCCODE ].Value = uint.Parse( m.Groups[ 1 ].Value, System.Globalization.NumberStyles.HexNumber );
                    regListEXC[ TArmRegisterType.EArmReg_EXCPC ].Value = uint.Parse( m.Groups[ 2 ].Value, System.Globalization.NumberStyles.HexNumber );
                    //
                    regListCOP[ TArmRegisterType.EArmReg_FAR ].Value = uint.Parse( m.Groups[ 3 ].Value, System.Globalization.NumberStyles.HexNumber );
                    regListCOP[ TArmRegisterType.EArmReg_FSR ].Value = uint.Parse( m.Groups[ 4 ].Value, System.Globalization.NumberStyles.HexNumber );

                    if ( regListEXC.Contains( TArmRegisterType.EArmReg_EXCCODE ) )
                    {
                        CIRegister reg = regListEXC[ TArmRegisterType.EArmReg_EXCCODE ];
                        System.Diagnostics.Debug.Assert( reg is CIRegisterExcCode );
                        CIRegisterExcCode excReg = (CIRegisterExcCode) reg;
                        //
                        excReg.ExpandToFullExceptionRange();
                    }

                    // It also means it was an exception
                    aThread.ExitInfo.Type = CrashItemLib.Crash.ExitInfo.CIExitInfo.TExitType.EExitTypeException;
                }
                else
                {
                    m = EM.RegistersExceptionSet2.Match( line );
                    if ( m.Success )
                    {
                        GroupCollection groups = m.Groups;
                        //
                        regListSVC[ TArmRegisterType.EArmReg_SP ].Value = uint.Parse( m.Groups[ 1 ].Value, System.Globalization.NumberStyles.HexNumber );
                        regListSVC[ TArmRegisterType.EArmReg_LR ].Value = uint.Parse( m.Groups[ 2 ].Value, System.Globalization.NumberStyles.HexNumber );
                        regListSVC[ TArmRegisterType.EArmReg_SPSR ].Value = uint.Parse( m.Groups[ 3 ].Value, System.Globalization.NumberStyles.HexNumber );
                    }
                }
            }
            #endregion
        }

        private void ExtractThreadStack( CIThread aThread )
        {
            DExcExtractorListStackData stackDataList = (DExcExtractorListStackData) iData[ DExcExtractorListType.EListStackData ];
            DataBuffer stackData = stackDataList.StackData;

            // Get stack range details
            DExcExtractorListThreadInfo threadInfo = (DExcExtractorListThreadInfo) iData[ DExcExtractorListType.EListThread ];
            AddressRange stackRange = threadInfo.StackRange;

            // If we didn't get the stack range, we cannot create a stack entry
            if ( !stackRange.IsValid || stackRange.Max == 0 || stackRange.Min == 0 )
            {
                CIMessageWarning warning = new CIMessageWarning( aThread.Container, "Stack Address Range Unavailable" );
                warning.AddLine( "The stack address range details are invalid." );
                aThread.AddChild( warning );
            }
            else if ( stackData.Count == 0 )
            {
                // No stack data
                CIMessageWarning warning = new CIMessageWarning( aThread.Container, "Stack Data Unavailable" );
                warning.AddLine( "The crash details contain no stack data." );
                aThread.AddChild( warning );
            }
            else
            {
                // Set base address of data buffer if not already set
                if ( stackData.AddressOffset == 0 )
                {
                    stackData.AddressOffset = stackRange.Min;
                }

                // In theory, D_EXC only ever captures user-side crashes (panics/exceptions) therefore
                // we should always be able to assume that the stack data goes with a user-side thread.
                CIRegisterList userRegs = aThread.Registers[ TArmRegisterBank.ETypeUser ];
                if ( userRegs != null )
                {
                    CIStack stack = aThread.CreateStack( userRegs, stackData, stackData.AddressOffset, stackRange );

                    // Register it as a specific crash instance
                    iContainer.AddChild( stack );
                }
            }
        }
        #endregion

        #region Data members
        private readonly CFFDataProvider iDataProvider;
        private readonly CFFSource iDescriptor;
        private readonly DExcExtractedData iData = null;
        private CIContainer iContainer = null;
		#endregion
	}
}