/*

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

using System.Text;

using System.Collections;

using System.Collections.Generic;

using SymbianUtils;

namespace HeapComparisonLib.CSV

{

	public class CSVComparisonEngine

	{

        #region Events

        public enum TEvent

        {

            // Reported as events

            EEventOperationStarted = 0,

            EEventOperationComplete,

            // Reported as percentage progress

            EEventSplittingProgress,

            EEventComparingProgress,

            // Reported as indexed progress

            EEventSplittingMovedToNewFile,

            EEventComparingMovedToNewDataSet,

        }

        public delegate void PercentageProgressHandler( TEvent aEvent, CSVComparisonEngine aSender, int aProgressPercent );

        public event PercentageProgressHandler ePercentageProgressHandler;

        public delegate void IndexedProgressHandler( TEvent aEvent, CSVComparisonEngine aSender, int aCurrentIndex, int aMaxIndex );

        public event IndexedProgressHandler eIndexedProgressHandler;

        public delegate void EventHandler( TEvent aEvent, CSVComparisonEngine aSender );

        public event EventHandler eEventHandler;

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

        public event ExceptionHandler eExceptionHandler;

        #endregion

        #region Constructors & destructor

        public CSVComparisonEngine( List<string> aSource, string aDestinationPath )

        {

            iSource.AddRange( aSource );

            iDestinationPath = aDestinationPath;

        }

		#endregion

		#region API

        public void CompareAsync()

        {

            iIndex = 0;

            iState = TState.EStateIdle;

            // Start things off...

            OnStateSplitting();

        }

        #endregion

        #region Properties

        public int Count

        {

            get { return iDataSets.Count; }

        }

        #endregion

        #region Internal state related

        private enum TState

        {

            EStateIdle = 0,

            EStateSplittingLogs,

            EStateComparingAndExportingIndividualDataSets,

            EStateComparingAllDataSets,

            EStateFinished

        }

        private void OnStateSplitting()

        {

            // If we have more files to split, then kick off

            // a new splitter.

            if ( iIndex < iSource.Count )

            {

                string fileName = iSource[ iIndex ];

                if ( eIndexedProgressHandler != null )

                {

                    eIndexedProgressHandler( TEvent.EEventSplittingMovedToNewFile, this, iIndex + 1, iSource.Count );

                }

                // Move to next file

                iIndex++;

                // Set up next worker

                iWorkerSplitter = new CSVWorkerLogSplitter( fileName, iDataSets );

                iWorkerSplitter.iObserver += new AsyncReaderBase.Observer( WorkerSplitter_Observer );

                iWorkerSplitter.SplitAsync();

                //

                ChangeState( TState.EStateSplittingLogs );

            }

            else

            {

                // Done with splitting phase, move on to comparing.

                // We must have at least two sets, or else there's nothing

                // to compare.

                if ( iDataSets.Count <= 1 )

                {

                    if ( eExceptionHandler != null )

                    {

                        eExceptionHandler( "Nothing to compare", "There are insufficient data sets to compare." );

                    }

                    ChangeState( TState.EStateFinished );

                }

                else

                {

                    // Next, find the shared chunks

                    IdentifySharedHeaps();

                    // And now start to export

                    iIndex = 0;

                    if ( iWorkerSplitter != null )

                    {

                        iWorkerSplitter.Dispose();

                        iWorkerSplitter = null;

                    }

                    ChangeState( TState.EStateComparingAndExportingIndividualDataSets );

                    OnStateComparingAndExportingIndividualDataSets();

                }

            }

        }

        private void OnStateComparingAndExportingIndividualDataSets()

        {

            // If there are only two sets to compare, then we generate a single output file and that's it.

            // If we have 3 (or more) data sets, then we will generate three (or more) comparison files, e.g.:

            //

            // [File 1]    0 vs 1

            // [File 2]    1 vs 2

            // 

            // and also

            // 

            // [File 3]    0 vs 2

            //

            // Etc.

            int numberOfComparisons = ( iDataSets.Count > 2 ? iDataSets.Count : 1 );

            if ( iIndex + 1 < iDataSets.Count )

            {

                if ( eIndexedProgressHandler != null )

                {

                    eIndexedProgressHandler( TEvent.EEventComparingMovedToNewDataSet, this, iIndex + 1, numberOfComparisons );

                }

                // Get sets to compare

                CSVDataSet set1 = iDataSets[ iIndex + 0 ];

                CSVDataSet set2 = iDataSets[ iIndex + 1 ];

                // Build excel file name

                string excelFileName = BuildExcelFileNameForTwoSetComparison();

                // Since we've now built the filename it's okay to increment the index

                ++iIndex;

                // Create and initiate comparison

                iWorkerComparatorTwo = new CSVWorkerTwoDataSetComparator( set1, set2, excelFileName );

                iWorkerComparatorTwo.eObserver += new CSVWorkerTwoDataSetComparator.Observer( WorkerComparatorTwo_Observer );

                iWorkerComparatorTwo.CompareAndSaveAsync();

                ChangeState( TState.EStateComparingAndExportingIndividualDataSets );

            }

            else

            {

                // Special comparison of first vs last set when comparing

                // more than two data sets

                if ( iDataSets.Count > 2 )

                {

                    if ( eIndexedProgressHandler != null )

                    {

                        eIndexedProgressHandler( TEvent.EEventComparingMovedToNewDataSet, this, numberOfComparisons, numberOfComparisons );

                    }

                    // Special value to indicate first vs last comparison

                    iIndex = KSpecialFirstVsLastComparisonIndex;

                    // Get sets to compare

                    CSVDataSet set1 = iDataSets[ 0 ];

                    CSVDataSet set2 = iDataSets[ iDataSets.Count - 1 ];

                    // Build excel file name

                    string excelFileName = BuildExcelFileNameForTwoSetComparison();

                    // Create and initiate comparison

                    if ( iWorkerComparatorTwo != null )

                    {

                        iWorkerComparatorTwo.Dispose();

                        iWorkerComparatorTwo = null;

                    }

                    iWorkerComparatorTwo = new CSVWorkerTwoDataSetComparator( set1, set2, excelFileName );

                    iWorkerComparatorTwo.eObserver += new CSVWorkerTwoDataSetComparator.Observer( WorkerComparatorTwo_Observer );

                    iWorkerComparatorTwo.CompareAndSaveAsync();

                    ChangeState( TState.EStateComparingAndExportingIndividualDataSets );

                }

                else

                {

                    if ( iWorkerComparatorTwo != null )

                    {

                        iWorkerComparatorTwo.Dispose();

                        iWorkerComparatorTwo = null;

                    }

                    //

                    ChangeState( TState.EStateComparingAllDataSets );

                    OnStateComparingAndExportingAllDataSets();

                }

            }

        }

        private void OnStateComparingAndExportingAllDataSets()

        {

            // Create and initiate comparison

            string excelFileName = BuildExcelFileNameForSummarySpreadsheet();

            iWorkerComparatorAll = new CSVWorkerAllDataSetComparator( iDataSets, excelFileName );

            iWorkerComparatorAll.eObserver += new CSVWorkerAllDataSetComparator.Observer( WorkerComparatorAll_Observer );

            iWorkerComparatorAll.CompareAndSaveAsync();

            ChangeState( TState.EStateComparingAllDataSets );

        }

        #endregion

        #region Event handlers

        void WorkerSplitter_Observer( AsyncReaderBase.TEvent aEvent, AsyncReaderBase aSender )

        {

            switch ( aEvent )

            {

            case AsyncReaderBase.TEvent.EReadingStarted:

                break;

            case AsyncReaderBase.TEvent.EReadingProgress:

                if ( ePercentageProgressHandler != null )

                {

                    ePercentageProgressHandler( TEvent.EEventSplittingProgress, this, aSender.Progress );

                }

                break;

            case AsyncReaderBase.TEvent.EReadingComplete:

                OnStateSplitting();

                break;

            }

        }

        void WorkerComparatorTwo_Observer( CSVWorkerTwoDataSetComparator.TEvent aEvent, string aThreadName )

        {

            switch ( aEvent )

            {

            case CSVWorkerTwoDataSetComparator.TEvent.EExportingStarted:

                break;

            case CSVWorkerTwoDataSetComparator.TEvent.EExportingProgress:

                if ( ePercentageProgressHandler != null )

                {

                    ePercentageProgressHandler( TEvent.EEventComparingProgress, this, iWorkerComparatorTwo.Progress );

                }

                break;

            case CSVWorkerTwoDataSetComparator.TEvent.EExportingComplete:

                if ( iIndex >= iDataSets.Count )

                {

                    OnStateComparingAndExportingAllDataSets();

                }

                else

                {

                    OnStateComparingAndExportingIndividualDataSets();

                }

                break;

            }

        }

        void WorkerComparatorAll_Observer( CSVWorkerAllDataSetComparator.TEvent aEvent )

        {

            switch ( aEvent )

            {

            case CSVWorkerAllDataSetComparator.TEvent.EExportingStarted:

                break;

            case CSVWorkerAllDataSetComparator.TEvent.EExportingProgress:

                if ( ePercentageProgressHandler != null )

                {

                    ePercentageProgressHandler( TEvent.EEventComparingProgress, this, iWorkerComparatorAll.Progress );

                }

                break;

            case CSVWorkerAllDataSetComparator.TEvent.EExportingComplete:

                ChangeState( TState.EStateFinished );

                break;

            }

        }

        #endregion

        #region Internal methods

        private void ChangeState( TState aNewState )

        {

            if ( eEventHandler != null )

            {

                if ( iState == TState.EStateIdle )

                {

                    eEventHandler( TEvent.EEventOperationStarted, this );

                }

                else if ( aNewState == TState.EStateFinished )

                {

                    eEventHandler( TEvent.EEventOperationComplete, this );

                }

            }

            iState = aNewState;

        }

        private string BuildExcelFileNameForTwoSetComparison()

        {

            StringBuilder temp = new StringBuilder( iDestinationPath );

            if ( iDestinationPath[ iDestinationPath.Length - 1 ] != Path.DirectorySeparatorChar )

            {

                temp.Append( Path.DirectorySeparatorChar );

            }

            // Special case for first vs last

            if ( iIndex == KSpecialFirstVsLastComparisonIndex )

            {

                temp.AppendFormat( "Comparison ({0:d3} vs {1:d3}).xls", 1, iDataSets.Count );

            }

            else

            {

                temp.AppendFormat( "Comparison ({0:d3} vs {1:d3}).xls", iIndex + 1, iIndex + 2 );

            }

            return temp.ToString();

        }

        private string BuildExcelFileNameForSummarySpreadsheet()

        {

            StringBuilder temp = new StringBuilder( iDestinationPath );

            if ( iDestinationPath[ iDestinationPath.Length - 1 ] != Path.DirectorySeparatorChar )

            {

                temp.Append( Path.DirectorySeparatorChar );

            }

            temp.Append( "Summary.xls" );

            return temp.ToString();

        }

        private int CalculateProgressPercentage( int aCurrent, int aMax )

        {

            float ret = (float) aCurrent / (float) aMax;

            ret *= 100.0f;

            return (int) ret;

        }

        private void IdentifySharedHeaps()

        {

            // MemSpy should (and could) do this, at least eventually, but for now

            // we'll work this out on the PC if MemSpy supplied us with the chunk handles for

            // each thread.

            int count = iDataSets.Count;

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

            {

                CSVDataSet dataSet = iDataSets[ i ];

                dataSet.FindSharedHeaps();

            }

        }

        #endregion

        #region Internal constants

        private const int KSpecialFirstVsLastComparisonIndex = int.MaxValue;

        #endregion

        #region Data members

        private readonly string iDestinationPath;

        private List<string> iSource = new List<string>();

        private CSVDataSetCollection iDataSets = new CSVDataSetCollection();

        private int iIndex = 0;

        private TState iState = TState.EStateIdle;

        private CSVWorkerLogSplitter iWorkerSplitter;

        private CSVWorkerTwoDataSetComparator iWorkerComparatorTwo;

        private CSVWorkerAllDataSetComparator iWorkerComparatorAll;

		#endregion

    }

}