/*
* 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.Collections;
using System.Collections.Specialized;
using System.Text.RegularExpressions;
using System.IO;
using System.Text;
using SymbianUtils;
using SymbolLib.Engines;
using SymbolLib.CodeSegDef;

namespace SymbolLib.SearchAndReplace
{
	public class SymbolicSearchAndReplaceParser : AsyncTextFileReader
	{
		#region Constructors & destructor
		public SymbolicSearchAndReplaceParser( SymbolManager aSymbolManager, string aSourceFile, string aDestinationFile )
        :   this( aSymbolManager, aSourceFile, aDestinationFile, string.Empty )
		{
		}
        
        public SymbolicSearchAndReplaceParser( SymbolManager aSymbolManager, string aSourceFile, string aDestinationFile, string aPrefix )
            : base( aSourceFile, new AsyncTextReaderPrefix( aPrefix ), true )
        {
            iSymbolManager = aSymbolManager;
            iWriter = new StreamWriter( aDestinationFile, false );
        }
        #endregion

        #region API
        public void SearchAndReplace()
        {
            base.AsyncRead();
        }
        #endregion

        #region Properties
        public SymbolManager SymbolManager
		{
			get { return iSymbolManager; }
		}
		#endregion

		#region From AsyncTextReaderBase
        protected override void HandleFilteredLine( string aLine )
		{
			const string KHexChars = "abcdefABCDEF1234567890";

            int startPos = 0;
            StringBuilder line = new StringBuilder();

            CodeSegDefinition def = iSymbolManager.ROFSEngine.DefinitionParser.ParseAndResolveDefinition( aLine );
            if ( def != null )
            {
                SymbolManager.LoadDynamicCodeSegment( def, TSynchronicity.ESynchronous );
                line.Append( aLine );
            }
            else
            {
                // Look through the line looking for 0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f in runs of 8 characters
                MatchCollection collection = iAddressRegEx.Matches( aLine );
                if ( collection != null && collection.Count > 0 )
                {
                    foreach ( Match m in collection )
                    {
                        // Now get the stack address
                        CaptureCollection captures = m.Captures;
                        foreach ( Capture capture in captures )
                        {
                            string matchText = capture.Value.Trim();

                            // Take all the initial text
                            int capturePos = capture.Index;

                            // Check whether it is a discrete word
                            bool checkForSymbolMatch = true;
                            if ( capturePos > 0 )
                            {
                                // Check previous character wasn't a match from our group
                                char prevCharacter = aLine[ capturePos - 1 ];
                                checkForSymbolMatch = ( KHexChars.IndexOf( prevCharacter ) < 0 );
                            }
                            if ( checkForSymbolMatch && ( capturePos + matchText.Length < aLine.Length ) )
                            {
                                // Check next character too
                                char nextCharacter = aLine[ capturePos + matchText.Length ];
                                checkForSymbolMatch = ( KHexChars.IndexOf( nextCharacter ) < 0 );
                            }

                            // Take any preceeding text...
                            if ( capturePos > 0 )
                            {
                                int length = capturePos - startPos;
                                line.Append( aLine.Substring( startPos, length ) );
                                startPos = capturePos;
                            }

                            // Always store the original text
                            line.Append( matchText );

                            // Decide if we can try to find a symbol...
                            if ( checkForSymbolMatch )
                            {
                                // And now take the text as a symbol (if we have
                                // a match).
                                long address = SymbianUtils.NumberBaseUtils.TextToDecimalNumber( matchText, NumberBaseUtils.TNumberBase.EHex );
                                Generics.GenericSymbol symbol = iSymbolManager.EntryByAddress( address );

                                if ( symbol != null )
                                {
                                    line.Append( " [ " + symbol.Symbol + " ]" );
                                }
                                else if ( iSymbolManager.AddressInRange( address ) )
                                {
                                    line.Append( " [ #UNKNOWN# ]" );
                                }
                            }
                            else
                            {
                                // Not a match, just take the original match text and move on...
                            }

                            startPos += matchText.Length;
                        }
                    }
                }

                // Remember to add anything that is left at the end...
                string remainder = aLine.Substring( startPos );
                line.Append( remainder );
            }

            iWriter.WriteLine( line.ToString() );
        }

		protected override void HandleReadCompleted()
		{
			try
			{
                if ( iWriter != null )
                {
                    iWriter.Close();
                }
                iWriter = null;
			}
			finally
			{
				base.HandleReadCompleted();
			}
		}
		#endregion

        #region From DisposableObject
        protected override void CleanupManagedResources()
        {
            try
            {
                if ( iWriter != null )
                {
                    iWriter.Close();
                }
                iWriter = null;
            }
            finally
            {
                base.CleanupManagedResources();
            }
        }
        #endregion

        #region Data members
        private readonly SymbolManager iSymbolManager;
		private static Regex iAddressRegEx = new Regex( @"[a-fA-F0-9]{8}", RegexOptions.IgnoreCase );
        private StreamWriter iWriter;
		#endregion
	}
}