/*
* 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.IO;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using SymbianUtils.Range;

namespace SymbianSymbolLibTest
{
    class Program
    {
        class Binary
        {
            public string iFileName = string.Empty;
            public byte[] iData = null;
            public long iDataStart = 0;
            public long iDataEnd = 0;
        }
        
        class Binary2
        {
            public string iFileName = string.Empty;
            public List<string> iData = new List<string>();
        }

        class Store
        {
            public Store()
            {
            }

            public void Add( string aFileName, Binary2 aData )
            {
                lock ( iEntries )
                {
                    if ( !iEntries.ContainsKey( aFileName ) )
                    {
                        iEntries.Add( aFileName, aData );
                    }
                }
            }

            public int Count
            {
                get { return iEntries.Count; }
            }

            public void Dump()
            {
            }

            private Dictionary<string, Binary2> iEntries = new Dictionary<string, Binary2>();
        }

        class ThreadReader
        {
            public delegate void CompletionHandler( ThreadReader aReader );
            public event CompletionHandler Completed = null;

            public ThreadReader( byte[] aData, int aStart, int aCount, Store aStore )
            {
                iData = aData;
                iStart = aStart;
                iCount = aCount;
                iStore = aStore;
            }

            public void Read()
            {
                //System.Console.WriteLine( string.Format( "Reading starting - pos: 0x{0}, len: {1:d8}", iStart, iCount ) );
                DateTime timeStamp = DateTime.Now;
                
                Binary2 currentBinary = null;

                long binaryCount = 0;
                long lineCount = 0;
                using ( StreamReader reader = new StreamReader( new MemoryStream( iData, iStart, iCount ) ) )
                {
                    string line = reader.ReadLine();
                    while ( line != null )
                    {
                        ++lineCount;
                        if ( line.StartsWith( "From    " ) )
                        {
                            currentBinary = new Binary2();
                            currentBinary.iFileName = line.Substring( 8 );
                            //
                            ++binaryCount;
                            iStore.Add( currentBinary.iFileName, currentBinary );
                        }
                        else if ( currentBinary != null )
                        {
                            currentBinary.iData.Add( line );
                        }

                        line = reader.ReadLine();
                    }
                }

                DateTime endTime = DateTime.Now;
                TimeSpan span = ( endTime - timeStamp );
                //System.Console.WriteLine( string.Format( "Reading complete - {0} time, {1} lines, {2} binaries", span, lineCount, binaryCount ) );

                if ( Completed != null )
                {
                    Completed( this );
                }
            }

            private readonly byte[] iData;
            private readonly int iStart;
            private readonly int iCount;
            private readonly Store iStore;
        }

        class SymbolFile
        {
            #region Constructors
            public SymbolFile( FileInfo aFile )
            {
                iFile = aFile;
            }
            #endregion

            #region API
            public void Read()
            {
                Partition();
                //
                iWaiter = new AutoResetEvent( false );
                for( int i=iReaders.Count-1; i>=0; i-- )
                {
                    ThreadReader reader = iReaders[ i ];
                    reader.Completed += new ThreadReader.CompletionHandler( Reader_Completed );
                    ThreadPool.QueueUserWorkItem( new WaitCallback(StartReader ), reader );
                }
                
                // Now wait
                using ( iWaiter )
                {
                    iWaiter.WaitOne();
                }
                iWaiter = null;
            }
            #endregion

            #region Properties
            public int Count
            {
                get { return iStore.Count; }
            }
            #endregion

            #region Event handlers
            private void Reader_Completed( ThreadReader aReader )
            {
                iCompleted.Add( aReader );
                iReaders.Remove( aReader );
                //
                if ( iReaders.Count == 0 )
                {
                    iWaiter.Set();
                }
            }
            #endregion

            #region Internal methods
            private static void StartReader( object aThreadReader )
            {
                ThreadReader reader = (ThreadReader) aThreadReader;
                reader.Read();
            }

            private void Partition()
            {
                // Read entire file into buffer
                byte[] data = new byte[ iFile.Length ];
                using ( Stream reader = new FileStream( iFile.FullName, FileMode.Open ) )
                {
                    reader.Read( data, 0, data.Length );
                }

                // This is the pattern we are searching for:
                byte[] pattern = new byte[] { (byte) 'F', (byte) 'r', (byte) 'o', (byte) 'm', (byte) ' ', (byte) ' ', (byte) ' ', (byte) ' ' };

                int threadCount = System.Environment.ProcessorCount;
                int chunkSize = (int) iFile.Length / threadCount;

                //
                int blockPosStart = 0;
                for ( int i = 0; i < threadCount; i++ )
                {
                    int pos = 0;
                    int blockPosEnd = Math.Min( data.Length - 1, blockPosStart + chunkSize );
                    while ( pos >= 0 )
                    {
                        pos = Array.IndexOf( data, pattern[ 0 ], blockPosEnd );
                        if ( pos > 0 )
                        {
                            if ( pos + 8 >= data.Length )
                            {
                                break;
                            }
                            else if ( pos + 8 < data.Length && data[ pos + 7 ] == pattern[ 7 ] )
                            {
                                bool isMatch = CompareByteArrays( pattern, data, pos );
                                if ( isMatch )
                                {
                                    int length = pos - blockPosStart;
                                    System.Console.WriteLine( string.Format( "Block {0:d2} @ 0x{1:x8}, length: {2:d8}", i, blockPosStart, length ) );
                                    //
                                    ThreadReader reader = new ThreadReader( data, blockPosStart, length, iStore );
                                    iReaders.Add( reader );

                                    blockPosStart = pos;
                                    break;
                                }
                            }
                            else
                            {
                                // Didn't find a match, move forwards
                                blockPosEnd = pos + 1;
                            }
                        }
                        else
                        {
                            // Searched to end of file and didn't find another block, so just create
                            // a new reader for everything that remains.
                            int length2 = data.Length - blockPosStart;
                            System.Console.WriteLine( string.Format( "Block {0:d2} @ 0x{1:x8}, length: {2:d8}", i, blockPosStart, length2 ) );
                            //
                            ThreadReader reader2 = new ThreadReader( data, blockPosStart, length2, iStore );
                            iReaders.Add( reader2 );
                            break;
                        }
                    }
                }
            }

            private static bool CompareByteArrays( byte[] aSearchFor, byte[] aSearchIn, int aStartPos )
            {
                bool areEqual = true;
                //
                for ( int i = aStartPos; i < aSearchFor.Length; i++ )
                {
                    byte b = aSearchIn[ i ];
                    byte c = aSearchFor[ i - aStartPos ];
                    if ( b != c )
                    {
                        areEqual = false;
                        break;
                    }
                }
                //
                return areEqual;
            }
            #endregion

            #region Data members
            private readonly FileInfo iFile;
            private AutoResetEvent iWaiter = null;
            private Store iStore = new Store();
            private List<ThreadReader> iCompleted = new List<ThreadReader>();
            private List<ThreadReader> iReaders = new List<ThreadReader>();
            #endregion
        }

        static void Main( string[] args )
        {
            string path = @"C:\Tool Demo Files\2. Crash Data\File43\CoreImage"; // C:\Tool Demo Files\2. Crash Data\File28\";
            DirectoryInfo dir = new DirectoryInfo( path );
            FileInfo[] files = dir.GetFiles( "*.symbol" );
            //
            //
            foreach ( FileInfo file in files )
            {
                //
                DateTime timeStamp = DateTime.Now;
                System.Console.WriteLine( string.Format( "[{0}] - Reading starting...", file.Name ) );

                SymbolFile symbolFile = new SymbolFile( file );
                symbolFile.Read();

                DateTime endTime = DateTime.Now;
                TimeSpan span = ( endTime - timeStamp );

                System.Console.WriteLine( string.Format( "[{0}] - Reading complete - {1} time, {2} binaries", file.Name, span, symbolFile.Count ) );
                System.Console.WriteLine( " " );
                System.Console.WriteLine( " " );
                System.Console.WriteLine( " " );
                System.Console.ReadKey();
            }
        }
    }
}