/*
* 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.Collections.Generic;
using SymbianUtils.Range;
using EM=DExcPlugin.ExpressionManager.DExcExpressionManager;

namespace DExcPlugin.Extractor
{
	internal class DExcExtractor
	{
        #region Events
        public enum TEvent
        {
            EEventExtractedAllData
        }

        public delegate void EventHandler( TEvent aEvent, DExcExtractor aExtractor );
        public event EventHandler StateChanged;
        #endregion

        #region Constructors
        public DExcExtractor()
		{
            Init();
        }
		#endregion

		#region API
        public void Init()
        {
            iState = TState.EStateIdle;
            iData = new DExcExtractedData();
            iLists = new Dictionary<TState, DExcExtractorList>();
            iCurrentLineNumber = 0;
		    
            // Null (really just exists to catch a state transition)
            // =======================================================
            CreateList( TState.EStateIdle, DExcExtractorListType.EListNull ).AddExpression( DExcExtractorEntry.NewMatchSaveAndTransition( EM.LogStart, TState.EStateHeader ) );
		    
            // Header
            // =======================================================
            CreateList( TState.EStateHeader, DExcExtractorListType.EListHeader ).AddExpression( DExcExtractorEntry.NewMatchSaveAndTransition( EM.ThreadName, TState.EStateThreadInfo ) );

            // Thread info
            // ===========
            DExcExtractorListThreadInfo listThreadInfo = new DExcExtractorListThreadInfo( TState.EStateThreadInfo, DExcExtractorListType.EListThread );
            PrepareList( listThreadInfo, EM.ThreadName, EM.ThreadId, EM.ThreadStackRange, EM.ThreadPanicDetails );
            listThreadInfo.AddExpression( DExcExtractorEntry.NewMatchSaveAndTransition( EM.RegistersExceptionStart, TState.EStateRegisterInfoException ) );
            listThreadInfo.AddExpression( DExcExtractorEntry.NewMatchSaveAndTransition( EM.RegistersUserStart, TState.EStateRegisterInfoUser ) );

            // Registers (exception)
            // =====================
            DExcExtractorList listRegisterInfoException = CreateList( TState.EStateRegisterInfoException, DExcExtractorListType.EListRegistersException,
                                                                        EM.RegistersExceptionSet1,
                                                                        EM.RegistersExceptionSet2 );
            listRegisterInfoException.AddExpression( DExcExtractorEntry.NewMatchSaveAndTransition( EM.RegistersUserStart, TState.EStateRegisterInfoUser ) );

            // Registers (user)
            // ================
            DExcExtractorList listRegisterInfoUser = CreateList( TState.EStateRegisterInfoUser, DExcExtractorListType.EListRegistersUser,
                                                                   EM.RegistersUserCPSR,
                                                                   EM.RegistersUserSet );

            // Since code segs are optional, we want to record that we at least saw the header text (which is mandatory). This
            // tracking allows us to validate that we have received/observed data for all states.
            listRegisterInfoUser.AddExpression( DExcExtractorEntry.NewMatchSaveAndTransition( EM.CodeSegmentsStart, TState.EStateCodeSegments ) );

            // Code segments
            // =============
            DExcExtractorList listCodeSegments = CreateList( TState.EStateCodeSegments, DExcExtractorListType.EListCodeSegments, EM.CodeSegmentsEntry );

            // We need to transition state to "stack data", but we must be sure not to throw away the state line we just encountered.
            listCodeSegments.AddExpression( DExcExtractorEntry.NewMatchSaveAndTransition( EM.StackDataEntry, TState.EStateStackData ) );

            // Stack data
            // ==========
            DExcExtractorListStackData listStackData = new DExcExtractorListStackData( TState.EStateStackData, DExcExtractorListType.EListStackData );
            PrepareList( listStackData, EM.StackDataEntry );
            listStackData.AddExpression( DExcExtractorEntry.NewMatchSaveAndTransition( EM.LogStart, TState.EStateHeader ) );

            // We want to observe the stack data as it arrives so that we can identify when all stack data has been supplied.
            listStackData.StackChanged += new DExcExtractorListStackData.StackDataChangeHandler( StackDataChanged );
        }

        public void Init( string aStackFileName )
        {
            Init();
            //
            DExcExtractorListStackData stackData = (DExcExtractorListStackData) iLists[ TState.EStateStackData ];
            stackData.Prime( aStackFileName );
        }

        public bool Offer( string aLine, long aLineNumber )
		{
            bool consumed = false;

            // Cache line number - we use this to update the data starting position
            // when the state is changed.
            iCurrentLineNumber = aLineNumber;

            // Get list for current state
            DExcExtractorList list = CurrentList;
            if ( list != null )
            {
                consumed = list.Offer( aLine, aLineNumber, this );
            }

            return consumed;
		}

        public void Finialize()
		{
			// If we were parsing code segs but we didn't get any stack
			// data then we must ensure we still notify when we've reached
			// the end of the code seg data (or else no crash item will be
			// created).
            switch ( State )
            {
            case TState.EStateIdle:
                // Already finished or not started
                return;
            default:
                break;
            }

            // Did we create entries in all non-idle lists?
            bool haveEntriesForAllLists = ListsAreValid;
            if ( haveEntriesForAllLists )
            {
                NotifyEvent( TEvent.EEventExtractedAllData );
                State = TState.EStateIdle;
            }
		}
		#endregion

        #region Properties
        public TState State
		{
            get { return iState; }
            set
            {
                if ( value != iState )
                {
                    TState oldState = value;
                    iState = value;
                    //
                    if ( oldState == TState.EStateIdle )
                    {
                        // Was idle, now not - set starting line number
                        iData.LineNumber = iCurrentLineNumber;
                    }
                    else if ( iState == TState.EStateIdle )
                    {
                        Init();
                    }
                }
            }
		}

        public DExcExtractedData CurrentData
        {
            get { return iData; }
        }

        public DExcExtractorList CurrentList
        {
            get
            {
                DExcExtractorList ret = null;
                //
                if ( iLists.ContainsKey( State ) )
                {
                    ret = iLists[ State ];
                }
                //
                return ret;
            }
        }
		#endregion

        #region Event handlers
        private void StackDataChanged( DExcExtractorListStackData aSelf )
        {
            DExcExtractorListThreadInfo threadInfo = (DExcExtractorListThreadInfo) iLists[ TState.EStateThreadInfo ];
            AddressRange range = threadInfo.StackRange;
            if ( range.IsValid )
            {
                uint lastAddress = aSelf.StackData.Last.Address;
                if ( lastAddress == range.Max - 1 )
                {
                    NotifyEvent( TEvent.EEventExtractedAllData );
                    State = TState.EStateIdle;
                }
            }
        }
        #endregion
        
        #region Internal enumerations
        internal enum TState
        {
            EStateIdle = 0,
            EStateHeader,
            EStateThreadInfo,
            EStateRegisterInfoException,
            EStateRegisterInfoUser,
            EStateCodeSegments,
            EStateStackData,
        }
        #endregion

        #region Internal methods
        private void NotifyEvent( TEvent aEvent )
        {
            if ( StateChanged != null )
            {
                StateChanged( aEvent, this );
            }
        }

        private void PrepareList( DExcExtractorList aList, params Regex[] aExpressions )
        {
            foreach ( Regex exp in aExpressions )
            {
                DExcExtractorEntry entry = DExcExtractorEntry.NewMatchAndSave( exp );
                aList.AddExpression( entry );
            }
            //
            iLists.Add( aList.State, aList );
            iData.Add( aList );
        }

        private DExcExtractorList CreateList( TState aAssociatedState, DExcExtractorListType aType, params Regex[] aExpressions )
        {
            DExcExtractorList ret = new DExcExtractorList( aAssociatedState, aType );
            PrepareList( ret, aExpressions );
            return ret;
        }

        private bool ListsAreValid
        {
            get
            {
                int countThreadInfo = iLists[ TState.EStateThreadInfo ].Count;
                int countRegUser = iLists[ TState.EStateRegisterInfoUser ].Count;
                int countCodeSegs = iLists[ TState.EStateCodeSegments ].Count;
                int countStackData = ((DExcExtractorListStackData) iLists[ TState.EStateStackData ]).StackData.Count;
                //
                bool valid = ( countThreadInfo >= 3 ) && ( countRegUser > 0 ) && ( countCodeSegs > 0 ) && ( countStackData > 0 );
                return valid;
            }
        }
        #endregion

        #region From System.Object
        public override string ToString()
        {
            string ret = iData.ToString();
            return ret;
        }
        #endregion

        #region Data members
        private TState iState;
        private long iCurrentLineNumber = 0;
        private DExcExtractedData iData = new DExcExtractedData();
        private Dictionary<TState, DExcExtractorList> iLists = new Dictionary<TState, DExcExtractorList>();
		#endregion
	}
}