/*

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

using System.Text.RegularExpressions;

using System.Threading;

using System.Collections;

using System.Collections.Generic;

using SymbianDebugLib.Engine;

using SymbianUtils;

using SymbianUtils.Range;

using SymbianUtils.RawItems;

using HeapLib.Cells;

using HeapLib.Array;

using HeapLib.Statistics;

using HeapLib.Relationships;

using HeapLib.Reconstructor.DataSources;

using HeapLib.Reconstructor.Misc;

using HeapLib.Reconstructor.RHeap.Extractor;

namespace HeapLib.Reconstructor

{

	public sealed class HeapReconstructor

	{

        #region Events

        public enum TEvent

        {

            EReconstructingStarted = 0,

            EReconstructingProgress,

            EReconstructingComplete

        }

        public delegate void Observer( TEvent aEvent, HeapReconstructor aReconstructor );

        public event Observer iObserver;

        public delegate void ExceptionHandler( string aTitle, string aBody );

        public event ExceptionHandler iExceptionHandler;

        #endregion

        #region Constructors & destructor

		public HeapReconstructor( DataSource aDataSource, Options aOptions, DbgEngine aDebugEngine )

		{

            iRelationshipInspector = new RelationshipInspector( iData, iStatistics );

            iRelationshipInspector.iObserver += new AsyncReaderBase.Observer( RelationshipInspector_Observer );

            //

            iExtractor = new RHeapExtractor( aDataSource, aOptions, aDebugEngine, iRelationshipInspector, iStatistics, iData );

            iExtractor.iObserver += new AsyncReaderBase.Observer( Extractor_Observer );

            iExtractor.iExceptionHandler += new AsyncReaderBase.ExceptionHandler( Extractor_ExceptionHandler );

		}

        #endregion

		#region API

        public void Reconstruct()

        {

            iState = TState.EStateExtractingHeapObjects;

            //

            iData.Clear();

            //

            iStatistics.Clear();

            iStatistics.HeapBaseAddress = SourceData.MetaData.Heap.HeapBaseAddress;

            iStatistics.HeapSize = SourceData.MetaData.Heap.ChunkSize;

            if ( iStatistics.HeapSize == 0 || iStatistics.HeapBaseAddress == 0 )

            {

                throw new ArgumentException( "Heap size or Heap base address not initialised" );

            }

            //

            iExtractor.Extract();

        }

        #endregion

		#region Properties

        public AddressRange AddressRange

        {

            get { return Statistics.AddressRange; }

        }

		public Options Options

		{

            get { return iExtractor.Options; }

        }

		public HeapStatistics Statistics

		{

			get { return iStatistics; }

		}

		public uint AllocatedCellHeaderSize

		{

			get { return iExtractor.AllocatedCellHeaderSize; }

		}

		public HeapCellArray Data

		{

			get { return iData; }

		}

		public DataSource SourceData

		{

            get { return iExtractor.SourceData; }

		}

        public bool IsDebugAllocator

        {

            get { return SourceData.MetaData.Heap.DebugAllocator; }

        }

        public int Progress

        {

            get

            {

                int progress = 0;

                //

                progress += iExtractor.Progress;

                progress += iRelationshipInspector.Progress;

                //

                return progress / 2;

            }

        }

        #endregion

        #region From System.Object

        public string ToString( bool aShowAllEntries )

        {

            StringBuilder text = new StringBuilder();

            //

            int count = Data.Count;

            for ( int i = 0; i < count; i++ )

            {

                HeapCell element = Data[ i ];

                if ( aShowAllEntries || ( !aShowAllEntries && element.Symbol != null ) )

                {

                    string line = element.ToString() + Environment.NewLine;

                    text.Append( line );

                }

            }

            //

            return text.ToString();

        }

        #endregion

		#region Internal state enumeration

		private enum TState

		{

            EStateExtractingHeapObjects = 0,

            EStateInspectingCellRelationships,

            EStateUpdatingStatistics

		}

		#endregion

        #region Extractor observer

        private void Extractor_Observer( AsyncReaderBase.TEvent aEvent, AsyncReaderBase aSender )

        {

            if ( iObserver != null )

            {

                if ( aEvent == AsyncReaderBase.TEvent.EReadingStarted )

                {

                    iObserver( TEvent.EReconstructingStarted, this );

                }

                else if ( aEvent == AsyncReaderBase.TEvent.EReadingComplete )

                {

                    iState = TState.EStateInspectingCellRelationships;

                    iRelationshipInspector.Inspect();

                    iObserver( TEvent.EReconstructingProgress, this );

                }

                else

                {

                    iObserver( TEvent.EReconstructingProgress, this );

                }

            }

        }

        private void Extractor_ExceptionHandler( Exception aException, AsyncReaderBase aSender )

        {

            System.Diagnostics.Debug.WriteLine( "EXTRACTOR EXCEPTION: " + aException.Message );

            if ( iExceptionHandler != null )

            {

                iExceptionHandler( "Heap Extraction Exception", aException.Message + System.Environment.NewLine + aException.StackTrace );

            }

        }

        #endregion

        #region Relationship Inspector observer

        private void RelationshipInspector_Observer( AsyncReaderBase.TEvent aEvent, AsyncReaderBase aSender )

        {

            if ( iObserver != null )

            {

                if ( aEvent == AsyncReaderBase.TEvent.EReadingStarted || aEvent == AsyncReaderBase.TEvent.EReadingProgress )

                {

                    iObserver( TEvent.EReconstructingProgress, this );

                }

                else if ( aEvent == AsyncReaderBase.TEvent.EReadingComplete )

                {

                    iState = TState.EStateUpdatingStatistics;

                    iStatistics.Finalise( iData );

                    iObserver( TEvent.EReconstructingComplete, this );

                }

            }

        }

        #endregion

		#region Data members

        private TState iState;

        private HeapStatistics iStatistics = new HeapStatistics();

        private HeapCellArray iData = new HeapCellArray();

        private readonly RHeapExtractor iExtractor;

		private readonly RelationshipInspector iRelationshipInspector;

        #endregion

	}

}