/*
* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice,
*   this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright notice,
*   this list of conditions and the following disclaimer in the documentation
*   and/or other materials provided with the distribution.
* - Neither the name of Nokia Corporation nor the names of its contributors
*   may be used to endorse or promote products derived from this software
*   without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
* 
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: 
*
*/

using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
using SymbianUtils;
using HeapLib.Reconstructor.Misc;
using HeapLib.Reconstructor.DataSources.Analyser.Readers;
using HeapLib.Reconstructor.DataSources.Analyser.Extractor;
using HeapLib.Reconstructor.DataSources.Analyser.Interpreter;

namespace HeapLib.Reconstructor.DataSources.Analyser
{
    public class DataSourceAnalyser
    {
        #region Events
        public enum TEvent
        {
            EReadingStarted = 0,
            EReadingProgress,
            EReadingComplete
        }

        public delegate void Observer( TEvent aEvent, DataSourceAnalyser aSender );
        public event Observer iObserver;

        public delegate void ExceptionHandler( Exception aException, DataSourceAnalyser aSender );
        public event ExceptionHandler iExceptionHandler;
        #endregion

        #region Constructors & destructor
        public DataSourceAnalyser( string[] aLines )
        {
            iReader = new ReaderLines( this, aLines );
            iReader.iObserver += new AsyncReaderBase.Observer( Reader_Observer );
            iReader.iExceptionHandler += new AsyncReaderBase.ExceptionHandler( Reader_ExceptionHandler );
        }

        public DataSourceAnalyser( string aFileName )
        {
            iReader = new ReaderFile( this, aFileName );
            iReader.iObserver += new AsyncReaderBase.Observer( Reader_Observer );
            iReader.iExceptionHandler += new AsyncReaderBase.ExceptionHandler( Reader_ExceptionHandler );
        }
        #endregion

        #region API
        public void Analyse()
        {
            if ( iReader is ReaderFile )
            {
                ReaderFile reader = (ReaderFile) iReader;
                reader.StartRead();
            }
            else if ( iReader is ReaderLines )
            {
                ReaderLines reader = (ReaderLines) iReader;
                reader.StartRead();
            }
        }
        #endregion

        #region Properties
        public bool IsReady
        {
            get { return iReader.IsReady; }
        }

        public int Progress
        {
            get { return iReader.Progress; }
        }

        public DataSourceCollection DataSources
        {
            get { return iDataSources; }
        }
        #endregion

        #region Reader call back method
        internal void HandleFilteredLine( string aLine, long aLineNumber )
        {
            // The four types of data we allow.
            //
            // 1) Text data from a trace file
            //    [15:21:32.719] xti2:MCU_ASCII_PRINTF; channel:0xE0; msg:HeapData - EComServer::!ecomserver - HEAP INFO FOR THREAD 'EComServer::!ecomserver'
            //
            // 2) Text data from a MemSpy heap dump file
            //    HEAP INFO FOR THREAD 'ecomserver::!ecomserver'
            //
            // 3) Binary data from a trace file:
            //    [14:39:24.344] xti2:MCU_ASCII_PRINTF; channel:0xE0; msg:[BinHeap:00000131]<BinHeapData:00000131:00000130:000000000001346e>
            //    [14:39:24.344] xti2:MCU_ASCII_PRINTF; channel:0xE0; msg:[BinHeap:00000131]00000000: be d0 be d0 ba da ba da 00 00 00 d0 01 00 00 00 ................
            //    [14:39:24.344] xti2:MCU_ASCII_PRINTF; channel:0xE0; msg:[BinHeap:00000131]00000010: 6e 34 01 00 82 00 00 00 83 00 00 00 01 00 00 00 n4..............
            //
            // 4) Binary data from a MemSpy heap dump file
            //    <BinHeapData:00000114:00000113:0000000000001234>
            //    000ae8cc: 00 00 00 00 00 00 00 00 9d 2a 17 00 24 00 00 00

            // First, try running the line past any existing extractors
            bool handled = false;
            foreach ( Extractor.Extractor ext in iActiveExtractors )
            {
                if ( ext.ExtractFrom( aLine, false ) )
                {
                    handled = true;
                    break;
                }
            }
            //
            if ( !handled )
            {
                // Try to create a new extractor that can handle this type of line
                Extractor.Extractor extractor = iExtractorFactory.FindSuitableExtractor( aLine );
                if ( extractor != null )
                {
                    InterpreterBase interpreter = iInterpreterFactory.FindSuitableInterpreter( extractor );

                    if ( interpreter != null )
                    {
                        // Link up extractor and interpreter with a new data source
                        string dataSourceFileName = GetSourceFileName();
                        DataSource dataSource = new DataSource( dataSourceFileName, aLineNumber );
                        interpreter.DataSource = dataSource;
                        extractor.Interpreter = interpreter;

                        // We should also initialise the interpreter now that we've
                        // prepared the data source
                        interpreter.PrepareToStart( extractor );

                        // We must fire the extractor
                        extractor.ExtractFrom( aLine, true );

                        // Save the extractor so that we can ask it to handle future lines
                        AddExtractor( extractor );

                        // Save the data source
                        iDataSources.Add( dataSource );
                    }
                }
            }
        }
        #endregion

        #region Internal methods
        private void ReadingComplete()
        {
            RemoveEmptySources();

            // Check if the sources that are left were all completed, and if not
            // update their error flags.
            foreach ( DataSource source in iDataSources )
            {
                Elements.MetaData metaData = source.MetaData;
                if ( metaData.IsDataComplete == false )
                {
                    source.AddError( DataSource.TErrorTypes.EErrorTypeDataMissing );
                }
            }
        }

        private string GetSourceFileName()
        {
            string fileName = "RawHeapData.txt";
            if ( iReader is ReaderFile )
            {
                fileName = ( (ReaderFile) iReader ).FileName;
            }
            return fileName;
        }

        private void RemoveEmptySources()
        {
            iDataSources.RemoveEmptySources();
        }

        private void AddExtractor( Extractor.Extractor aExtractor )
        {
            // Check whether we already have an extractor for this thread.
            string threadName = aExtractor.Interpreter.DataSource.ThreadName;
            
            // If an entry with the same thread name already exists, then we
            // remove it, and replace it with a new entry
            Extractor.Extractor existingEntry = ExtractorByThread( threadName );
            if ( existingEntry != null )
            {
                iActiveExtractors.Remove( existingEntry );
            }

            // Save new extractor for the thread
            iActiveExtractors.Add( aExtractor );
        }

        private Extractor.Extractor ExtractorByThread( string aName )
        {
            Predicate<Extractor.Extractor> findByNamePredicate = delegate( Extractor.Extractor aExtractor )
            {
                string entryName = aExtractor.Interpreter.DataSource.ThreadName;
                return ( entryName == aName );
            };

            Extractor.Extractor ret = iActiveExtractors.Find( findByNamePredicate );
            return ret;
        }
        #endregion

        #region From AsyncReaderBase
        void Reader_ExceptionHandler( Exception aException, AsyncReaderBase aSender )
        {
            if ( iExceptionHandler != null )
            {
                iExceptionHandler( aException, this );
            }
        }

        void Reader_Observer( AsyncReaderBase.TEvent aEvent, AsyncReaderBase aSender )
        {
            if ( iObserver != null )
            {
                switch ( aEvent )
                {
                case AsyncReaderBase.TEvent.EReadingStarted:
                    iObserver( TEvent.EReadingStarted, this );
                    break;
                case AsyncReaderBase.TEvent.EReadingProgress:
                    iObserver( TEvent.EReadingProgress, this );
                    break;
                case AsyncReaderBase.TEvent.EReadingComplete:
                    ReadingComplete();
                    iObserver( TEvent.EReadingComplete, this );
                    break;
                default:
                    break;
                }
            }
        }
        #endregion

        #region Data members
        private readonly AsyncTextReader iReader;
        private DataSourceCollection iDataSources = new DataSourceCollection();
        private ExtractorFactory iExtractorFactory = new ExtractorFactory();
        private InterpreterFactory iInterpreterFactory = new InterpreterFactory();
        private List<Extractor.Extractor> iActiveExtractors = new List<HeapLib.Reconstructor.DataSources.Analyser.Extractor.Extractor>();
        #endregion
    }
}