/*
* Copyright (c) 2004-2008 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.Text.RegularExpressions;
using SymbianStructuresLib.Debug.Symbols;
using SymbianSymbolLib.SourceManagement.Source;
using SymbianSymbolLib.SourceManagement.Provisioning;
using SymbianUtils;
using SymbianUtils.FileTypes;
using SymbianUtils.Tracer;

namespace SLPluginMap.Reader.GCCE
{
    internal class GCCEMapFileReader : MapReader
	{
        #region Delegates & events
        #endregion

        #region Constructors
        public GCCEMapFileReader( SymSource aSource, ITracer aTracer )
            : base( aSource, aTracer )
		{
            base.TrimLine = false;
            iSymbolParser = new GCCESymbolCreator( this, base.Collection );
		}
		#endregion

        #region API
        #endregion

        #region Properties
		#endregion

		#region From AsyncTextReaderBase
		protected override void HandleFilteredLine( string aLine )
		{
            switch ( iStateGlobal )
			{
            case TGlobalState.EWaitingForImage_ER_RO_Base:
                ParseGlobalBaseAddress( aLine );
                break;
            case TGlobalState.EProcessingSymbols:
                ParseSymbols( aLine );
                break;
            default:
                break;
            }
		}

        protected override void HandleReadCompleted()
        {
            try
            {
                SortAndSize();
            }
            finally
            {
                base.HandleReadCompleted();
            }
        }
		#endregion

        #region Internal methods
		private void ParseGlobalBaseAddress( string aLine )
		{
            Match m = KGlobalBaseAddressRegEx.Match( aLine );
            if ( m.Success )
            {
                string value = m.Groups[ 1 ].Value;
                base.GlobalBaseAddress = uint.Parse( value, System.Globalization.NumberStyles.HexNumber );
                iStateGlobal = TGlobalState.EProcessingSymbols;
            }
		}

		private void ParseSymbols( string aLine )
		{
			try
			{
                // It's the start of a section...
                Match m = KSectionRegEx.Match( aLine );
                if ( m.Success )
                {
                    iSectionType = GetSection( aLine );
                    iLastSeenObjectName = string.Empty;
                }
                else if ( iSectionType != TSection.ESectionUnsupported )
                {
                    m = KSizeAndObjectRegEx.Match( aLine );
                    if ( m.Success )
                    {
                        iLastSeenObjectName = m.Groups[ "Object" ].Value.Trim();
                    }
                    else
                    {
                        Symbol sym = iSymbolParser.Parse( aLine );
                        if ( sym != null )
                        {
                            // Update object with cached information
                            sym.Object = iLastSeenObjectName;
                            iUnsortedSymbols.Add( sym );
                        }
                    }
                }
			}
			catch( Exception )
			{
			}
		}

        private void ListSymbols( IEnumerable<Symbol> aList )
        {
            foreach ( Symbol sym in aList )
            {
                string line = sym.ToString();
                if ( sym.InstructionSet == SymbianStructuresLib.Arm.TArmInstructionSet.ETHUMB )
                {
                    line = "T " + line;
                }
                else
                {
                    line = "  " + line;
                }
                //
                System.Diagnostics.Debug.WriteLine( line );
            }
        }

        private void SortAndSize()
        {
            // Sort the symbols into ascending address order
            Comparison<Symbol> comparer = delegate( Symbol aLeft, Symbol aRight )
            {
                // compare by address
                int ret = aLeft.Address.CompareTo( aRight.Address );
                return ret;
            };
            iUnsortedSymbols.Sort( comparer );

            // Subsume duplicates
            int count = iUnsortedSymbols.Count;
            for ( int i = count - 1; i >= 1; i-- )
            {
                Symbol sym1 = iUnsortedSymbols[ i - 0];
                Symbol sym2 = iUnsortedSymbols[ i - 1 ];
                //
                if ( sym1.Name == sym2.Name && sym1.Object == sym2.Object )
                {
                    // Since the symbol is the same and since we do not have any
                    // size information for GCCE map files, then we can safely
                    // discard one of the symbols.
                    iUnsortedSymbols.RemoveAt( i );
                }
            }

            // Now calculate sizes
            count = iUnsortedSymbols.Count;
            for ( int i = 0; i < count - 1; i++ )
            {
                Symbol sym1 = iUnsortedSymbols[ i + 0 ];
                Symbol sym2 = iUnsortedSymbols[ i + 1 ];
                
                // Calculate the symbol size based upon the address of the next symbol.
                // This may not be totally accurate, but it's the best we can do
                sym1.Size = ( sym2.Address - sym1.Address );

                // Save the symbol
                base.ReportSymbol( sym1 );
            }
        }

        private static TSection GetSection( string aText )
        {
            TSection ret = TSection.ESectionUnsupported;
            //
            Match m = KSectionRegEx.Match( aText );
            if ( m.Success )
            {
                string sectionName = m.Groups[ 0 ].Value;
                switch ( sectionName )
                {
                case ".text":
                    ret = TSection.ESectionText;
                    break;
                case ".emb_text":
                    ret = TSection.ESectionEmbText;
                    break;
                case ".rodata":
                    ret = TSection.ESectionReadOnlyData;
                    break;
                default:
                    break;
                }
            }
            //
            return ret;
        }
		#endregion

		#region Internal enumerations
		private enum TGlobalState
		{
			EWaitingForImage_ER_RO_Base = 0,
			EProcessingSymbols
		}

        private enum TSection
        {
            ESectionUnsupported = -1,
            ESectionText = 0,
            ESectionEmbText,
            ESectionReadOnlyData
        }
		#endregion

        #region Internal constants
        private readonly static Regex KGlobalBaseAddressRegEx = new Regex(
              @"\s*0x(?<Address>[A-Fa-f0-9]{8})\s+PROVIDE \(Image\$\$ER_RO\$\$Base",
            RegexOptions.Multiline
            | RegexOptions.CultureInvariant
            | RegexOptions.Compiled
            );

        private readonly static Regex KSectionRegEx = new Regex(
              "^\\.([a-zA-Z0-9_\\$\\.]*)",
            RegexOptions.Multiline
            | RegexOptions.CultureInvariant
            | RegexOptions.Compiled
            );
        private readonly static Regex KSizeAndObjectRegEx = new Regex(
              "(?<Prefix>.+?)0x(?<Address>[A-Fa-f0-9]{8})\\s+0x(?<Size>[A-F" +
              "a-f0-9]{1,8})\\s(?<Object>.+)",
            RegexOptions.Multiline
            | RegexOptions.CultureInvariant
            | RegexOptions.Compiled
            );
        #endregion

        #region Data members
		private TGlobalState iStateGlobal = TGlobalState.EWaitingForImage_ER_RO_Base;
        private readonly GCCESymbolCreator iSymbolParser;
        private List<Symbol> iUnsortedSymbols = new List<Symbol>();
        private string iLastSeenObjectName = string.Empty;
        private TSection iSectionType = TSection.ESectionUnsupported;
		#endregion
	}
}