/*

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

using System.Collections.Generic;

using System.Runtime.InteropServices;

using Excel = Microsoft.Office.Interop.Excel;

using System.Reflection; 

using SymbianExcelUtils;

using SymbianUtils;

using SymbianUtils.Range;

namespace HeapComparisonLib.CSV

{

    internal class CSVExcelExporterAllDataSets : DisposableObject

    {

        #region Constructors & destructor

        public CSVExcelExporterAllDataSets( string aOutputFileName, SortedDictionary<long, string> aThreadMap, int aDataSetCount )

        {

            iDataSetCount = aDataSetCount;

            iFileName = aOutputFileName;

            // Sort the aThreadMap list by thread name, rather than id.

            SortedDictionary<string, TThreadMapEntry> temp = new SortedDictionary<string, TThreadMapEntry>();

            foreach ( KeyValuePair<long, string> kvp in aThreadMap )

            {

                TThreadMapEntry entry = new TThreadMapEntry();

                entry.iThreadName = kvp.Value;

                entry.iThreadId = kvp.Key;

                //

                string mungedName = string.Format( "{1} [{0:d5}]", kvp.Key, kvp.Value );

                temp.Add( mungedName, entry );

            }

            // Now build new list, in the right order

            iThreadMap = new Dictionary<long, TThreadMapEntry>( temp.Count + 1 );

            foreach ( KeyValuePair<string, TThreadMapEntry> kvp in temp )

            {

                iThreadMap.Add( kvp.Value.iThreadId, kvp.Value );

            }

            // Open up excel

            iExcelApp = new Excel.Application();

            if ( iExcelApp != null )

            {

                iExcelApp.Visible = false;

                iExcelApp.DisplayAlerts = false;

                // Prepare sheets

                PrepareWorksheetReadyForData();

            }

            else

            {

                throw new Exception( "Microsoft Excel not available" );

            }

        }

        #endregion

        #region API

        public void Export( CSVDataSet aSet )

        {

            int count = aSet.Count;

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

            {

                CSVThread thread = aSet[ i ];

                // find row

                if ( iThreadMap.ContainsKey( thread.ThreadId ) )

                {

                    TThreadMapEntry entry = iThreadMap[ thread.ThreadId ];

                    Utils.SetValue( entry.iRowIndex, iColumnCounter, iSheetChunkSize, thread.SizeCurrent.ToString() );

                    Utils.SetValue( entry.iRowIndex, iColumnCounter, iSheetAlloc, thread.AllocSpaceTotal.ToString() );

                    Utils.SetValue( entry.iRowIndex, iColumnCounter, iSheetFree, thread.FreeSpaceTotal.ToString() );

                    // Update stats

                    ++entry.iNumberOfMatchingDataSets;

                    // Min & max for each type

                    entry.iRangeChunk.UpdateMin( thread.SizeCurrent );

                    entry.iRangeChunk.UpdateMax( thread.SizeCurrent );

                    entry.iRangeAlloc.UpdateMin( thread.AllocSpaceTotal );

                    entry.iRangeAlloc.UpdateMax( thread.AllocSpaceTotal );

                    entry.iRangeFree.UpdateMin( thread.FreeSpaceTotal );

                    entry.iRangeFree.UpdateMax( thread.FreeSpaceTotal );

                    // Delta for each type

                    long deltaChunk = entry.iLastChunk > 0 ? ( thread.SizeCurrent - entry.iLastChunk ) : 0;

                    long deltaAlloc = entry.iLastAlloc > 0 ? ( thread.AllocSpaceTotal - entry.iLastAlloc ) : 0;

                    long deltaFree = entry.iLastFree > 0 ? ( thread.FreeSpaceTotal - entry.iLastFree ) : 0;

                    entry.iDeltaChunk += deltaChunk;

                    entry.iDeltaAlloc += deltaAlloc;

                    entry.iDeltaFree += deltaFree;

                    // Net effect

                    entry.iNetEffectChunk += CSVExcelExporterAllDataSets.NetEffectForDelta( deltaChunk );

                    entry.iNetEffectAlloc += CSVExcelExporterAllDataSets.NetEffectForDelta( deltaAlloc );

                    entry.iNetEffectFree += CSVExcelExporterAllDataSets.NetEffectForDelta( deltaFree );

                    // Update last values

                    entry.iLastChunk = thread.SizeCurrent;

                    entry.iLastAlloc = thread.AllocSpaceTotal;

                    entry.iLastFree = thread.FreeSpaceTotal;

                }

                else

                {

                    throw new Exception( "Cannot find thread entry for thread named: " + thread.ThreadName );

                }

            }

            ++iColumnCounter;

        }

        #endregion

        #region From DisposableObject

        protected override void CleanupManagedResources()

        {

            try

            {

                if ( iExcelApp != null )

                {

                    // We're finished

                    PrepareWorsheetForSaving();

                    // Save excel workbook

                    SaveWorkbook();

                    // Close app

                    Utils.CloseExcel( iExcelApp );

                }

                iExcelApp = null;

            }

            finally

            {

                base.CleanupManagedResources();

            }

        }

        #endregion

        #region Internal methods

        private void PrepareWorksheetReadyForData( )

        {

            Excel.Workbooks workbooks = iExcelApp.Workbooks;

            workbooks.Add(Excel.XlWBATemplate.xlWBATWorksheet);

            Excel.Workbook workbook = workbooks.get_Item(workbooks.Count);

            Excel.Sheets sheets = workbook.Worksheets;

            iSheetChunkSize = (Excel.Worksheet) sheets.get_Item( 1 );

            CreateSheet( iSheetChunkSize, "Chunk Size" );

            iSheetFree = (Excel.Worksheet) sheets.Add( Type.Missing, sheets.get_Item( sheets.Count ), 1, Excel.XlSheetType.xlWorksheet );

            CreateSheet( iSheetFree, "Free Size" );

            iSheetAlloc = (Excel.Worksheet) sheets.Add( Type.Missing, sheets.get_Item( sheets.Count ), 1, Excel.XlSheetType.xlWorksheet );

            CreateSheet( iSheetAlloc, "Alloc Size" );

        }

        private void PrepareWorsheetForSaving()

        {

            // Update all sheets change factors...

            CalculateChangeFactor( iSheetChunkSize, TThreadMapEntry.TType.ETypeChunk );

            CalculateChangeFactor( iSheetAlloc, TThreadMapEntry.TType.ETypeAlloc );

            CalculateChangeFactor( iSheetFree, TThreadMapEntry.TType.ETypeFree );

            // Deltas

            CalculateDelta( iSheetChunkSize, TThreadMapEntry.TType.ETypeChunk );

            CalculateDelta( iSheetAlloc, TThreadMapEntry.TType.ETypeAlloc );

            CalculateDelta( iSheetFree, TThreadMapEntry.TType.ETypeFree );

            // Sort

            SortByChangeFactor( iSheetChunkSize );

            SortByChangeFactor( iSheetAlloc );

            SortByChangeFactor( iSheetFree );

            iSheetAlloc.Activate();

        }

        private void CreateSheet( Excel.Worksheet aSheet, string aTitle )

        {

            aSheet.Name = aTitle;

            // Create standard columns

            Utils.SetValue( 1, KColumnNumberThreadName, aSheet, "Thread Name" );

            Utils.SetValue( 1, KColumnNumberChangeFactor, aSheet, "Change Factor" );

            Utils.SetValue( 1, KColumnNumberDelta, aSheet, "Overall Delta" );

            // Set up column formatting

            Utils.FormatColumn( KColumnNumberChangeFactor, aSheet, KColumnNumberFormatChangeFactor );

            Utils.FormatColumn( KColumnNumberDelta, aSheet, KColumnNumberFormatDelta );

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

            {

                int col = i + KColumnNumberCycleFirst;

                Utils.SetValue( 1, col, aSheet, string.Format( "Cycle {0:d}", i + 1 ) );

                Utils.FormatColumn( col, aSheet, KColumnNumberFormatCycle );

            }

            Utils.MakeBoxedTitleRow( 1, KColumnNumberCycleFirst + iDataSetCount, aSheet, 0xFF0000 );

            // Add thread names & ids

            int row = 2;

            foreach ( KeyValuePair<long, TThreadMapEntry> kvp in iThreadMap )

            {

                TThreadMapEntry entry = kvp.Value;

                Utils.SetValue( row, KColumnNumberThreadName, aSheet, string.Format( "[{0:d5}] {1}", kvp.Key, kvp.Value.iThreadName ) );

                if ( entry.iRowIndex == 0 )

                {

                    entry.iRowIndex = row;

                }

                ++row;

            }

            // Size columns

            Utils.AutoFitColumn( KColumnNumberThreadName, aSheet );

            Utils.SetColumnWidth( KColumnNumberChangeFactor, aSheet, 15 );

            Utils.SetColumnWidth( KColumnNumberDelta, aSheet, 15 );

        }

        private void SaveWorkbook()

        {

            string path = Path.GetDirectoryName( iFileName );

            System.IO.DirectoryInfo dirInfo = new System.IO.DirectoryInfo( path );

            if ( !dirInfo.Exists )

            {

                dirInfo.Create();

            }

            System.IO.FileInfo fileInfo = new System.IO.FileInfo( iFileName );

            if ( fileInfo.Exists )

            {

                try

                {

                    fileInfo.Delete();

                }

                catch ( Exception )

                {

                }

            }

            Microsoft.Office.Interop.Excel.Workbooks workbooks = iExcelApp.Workbooks;

            Microsoft.Office.Interop.Excel.Workbook workbook = workbooks.get_Item( workbooks.Count );

            try

            {

                workbook.SaveAs( iFileName,

                                    Excel.XlFileFormat.xlExcel9795,

                                    Type.Missing,

                                    Type.Missing,

                                    Type.Missing,

                                    Type.Missing,

                                    Excel.XlSaveAsAccessMode.xlNoChange,

                                    Type.Missing,

                                    Type.Missing,

                                    Type.Missing,

                                    Type.Missing,

                                    Type.Missing );

            }

            catch ( System.IO.IOException )

            {

            }

            workbook.Close( false, Type.Missing, Type.Missing );

        }

        private void SortByChangeFactor( Excel.Worksheet aSheet )

        {

            int colCount = KColumnNumberCycleFirst + iDataSetCount;

            Excel.Range masterSortCell = (Excel.Range) aSheet.Cells[ 1, KColumnNumberChangeFactor ];

            Excel.Range range = Utils.GetRangeByColumnAndRow( 1, KColumnNumberThreadName, 1 + iThreadMap.Count, colCount, aSheet );

            range.Sort( masterSortCell.Columns[ 1, Type.Missing ], Microsoft.Office.Interop.Excel.XlSortOrder.xlDescending,

                        Type.Missing, Type.Missing, Microsoft.Office.Interop.Excel.XlSortOrder.xlAscending, 

                        Type.Missing, Microsoft.Office.Interop.Excel.XlSortOrder.xlAscending, Microsoft.Office.Interop.Excel.XlYesNoGuess.xlYes,

                        Type.Missing, Type.Missing,

                        Microsoft.Office.Interop.Excel.XlSortOrientation.xlSortColumns,

                        Microsoft.Office.Interop.Excel.XlSortMethod.xlPinYin,

                        Microsoft.Office.Interop.Excel.XlSortDataOption.xlSortNormal,

                        Microsoft.Office.Interop.Excel.XlSortDataOption.xlSortNormal,

                        Microsoft.Office.Interop.Excel.XlSortDataOption.xlSortNormal );

        }

        private void CalculateChangeFactor( Excel.Worksheet aSheet, TThreadMapEntry.TType aType )

        {

            aSheet.Activate();

            foreach ( KeyValuePair<long, TThreadMapEntry> kvp in iThreadMap )

            {

                TThreadMapEntry entry = kvp.Value;

                //

                string formula = entry.ChangeFactor( aType );

                Utils.SetValue( entry.iRowIndex, KColumnNumberChangeFactor, aSheet, formula );

            }

        }

        private void CalculateDelta( Excel.Worksheet aSheet, TThreadMapEntry.TType aType )

        {

            aSheet.Activate();

            foreach ( KeyValuePair<long, TThreadMapEntry> kvp in iThreadMap )

            {

                TThreadMapEntry entry = kvp.Value;

                //

                string formula = entry.Delta( aType );

                Utils.SetValue( entry.iRowIndex, KColumnNumberDelta, aSheet, formula );

            }

        }

        private static int NetEffectForDelta( long aDelta )

        {

            int ret = -1;

            //

            if ( aDelta > 0 )

            {

                ret = 1;

            }

            else if ( aDelta == 0 )

            {

                ret = 0;

            }

            //

            return ret;

        }

        #endregion

        #region Internal constants

        private const int KColumnNumberThreadName = 1;

        private const int KColumnNumberChangeFactor = 2;

        private const int KColumnNumberDelta = 3;

        private const int KColumnNumberCycleFirst = 5;

        private const string KColumnNumberFormatDelta = "[Red]###,###,##0;[Blue]-###,###,##0";

        private const string KColumnNumberFormatCycle = "###,###,##0";

        private const string KColumnNumberFormatChangeFactor = "[Red]#,##0.000000;[Blue]-#,##0.000000";

        #endregion

        #region Data members

        private readonly string iFileName;

        private readonly int iDataSetCount;

        private readonly Dictionary<long, TThreadMapEntry> iThreadMap;

        private Excel.Worksheet iSheetFree;

        private Excel.Worksheet iSheetAlloc;

        private Excel.Worksheet iSheetChunkSize;

        private Excel.Application iExcelApp;

        private int iColumnCounter = KColumnNumberCycleFirst;

        #endregion

    }

    #region Internal class

    internal class TThreadMapEntry

    {

        #region Enumerations

        public enum TType

        {

            ETypeChunk = 0,

            ETypeAlloc,

            ETypeFree

        }

        #endregion

        #region API

        public string ChangeFactor( TType aType )

        {

            string ret = string.Empty;

            //

            if ( aType == TType.ETypeChunk )

            {

                ret = ChangeFactor( iNetEffectChunk, iDeltaChunk, iRangeChunk );

            }

            else if ( aType == TType.ETypeAlloc )

            {

                ret = ChangeFactor( iNetEffectAlloc, iDeltaAlloc, iRangeAlloc );

            }

            else if ( aType == TType.ETypeFree )

            {

                ret = ChangeFactor( iNetEffectFree, iDeltaFree, iRangeFree );

            }

            //

            return ret;

        }

        public string Delta( TType aType )

        {

            string ret = string.Empty;

            //

            if ( aType == TType.ETypeChunk )

            {

                ret = ( iDeltaChunk != 0 ) ? "=" + iDeltaChunk.ToString() : string.Empty;

            }

            else if ( aType == TType.ETypeAlloc )

            {

                ret = ( iDeltaAlloc != 0 ) ? "=" + iDeltaAlloc.ToString() : string.Empty;

            }

            else if ( aType == TType.ETypeFree )

            {

                ret = ( iDeltaFree != 0 ) ? "=" + iDeltaFree.ToString() : string.Empty;

            }

            //

            return ret;

        }

        #endregion

        #region Internal methods

        private string ChangeFactor( int aNetEffect, long aDelta, AddressRange aRange )

        {

            StringBuilder ret = new StringBuilder();

            //      ( Total net effect * Total delta )

            // --------------------------------------------

            // (Max - Min) * (Number of Matching Data Sets)

            // 

            if ( aRange.Max - aRange.Min == 0 )

            {

                // Avoid divide by zero when there has been no change

            }

            else if ( aDelta == 0 )

            {

                // Overall change delta was zero

            }

            else

            {

                ret.Append( "=" );

                ret.AppendFormat( "( {0} * ABS({1}) )", aNetEffect, aDelta );

                ret.Append( " / " );

                ret.AppendFormat( "( ({0} - {1}) * {2} )", aRange.Max, aRange.Min, iNumberOfMatchingDataSets );

            }

            //

            return ret.ToString();

        }

        #endregion

        #region Data members

        public string iThreadName = string.Empty;

        public long iThreadId = 0;

        public int iRowIndex = 0;

        public int iNumberOfMatchingDataSets = 0;

        public AddressRange iRangeChunk = new AddressRange();

        public AddressRange iRangeAlloc = new AddressRange();

        public AddressRange iRangeFree = new AddressRange();

        public long iLastChunk = 0;

        public long iLastAlloc = 0;

        public long iLastFree = 0;

        public long iDeltaChunk = 0;

        public long iDeltaAlloc = 0;

        public long iDeltaFree = 0;

        public int iNetEffectChunk = 0;

        public int iNetEffectAlloc = 0;

        public int iNetEffectFree = 0;

        #endregion

    }

    #endregion

}