/*
* 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.Text.RegularExpressions;
using SymbolLib.Generics;
using SymbolLib.Sources.Symbol.File;

namespace SymbolLib.Sources.Symbol.Symbol
{
	public class SymbolSymbol : GenericSymbol
	{
		#region Constructors
        public static SymbolSymbol New( GenericSymbolCollection aCollection )
        {
            return new SymbolSymbol( aCollection );
        }

        public static SymbolSymbol NewUnknown()
        {
            return NewUnknown( new SymbolsForBinary( string.Empty ) );
        }

        public static SymbolSymbol NewUnknown( uint aAddress, uint aSize, string aObject )
        {
            SymbolSymbol ret = NewUnknown();
            //
            ret.OffsetAddress = aAddress;
            ret.Size = aSize;
            ret.Object = aObject;
            //
            return ret;
        }

        public static SymbolSymbol NewUnknown( GenericSymbolCollection aCollection )
        {
            SymbolSymbol symbol = new SymbolSymbol( aCollection );
            //
            symbol.OffsetAddress = GenericSymbol.KNullEntryAddress;
            symbol.Symbol = GenericSymbol.KNonMatchingSymbolName;
            if ( aCollection.HostBinaryFileName.Length > 0 )
            {
                symbol.Object = Path.GetFileName( aCollection.HostBinaryFileName );
            }
            else
            {
                symbol.Object = GenericSymbol.KNonMatchingObjectName;
            }
            //
            return symbol;
        }
        #endregion

        #region Internal constructors
        private SymbolSymbol( GenericSymbolCollection aCollection )
            : base( aCollection )
		{
		}

        private SymbolSymbol( string aSymbolName )
            : this( aSymbolName, 0 )
        {
		}

        private SymbolSymbol( string aSymbolName, uint aAddress )
            : base( new SymbolsForBinary( string.Empty )  )
        {
            Symbol = aSymbolName;
            OffsetAddress = aAddress;
        }
        #endregion

        #region API
        public void ResetOffsetAddress( long aOffset )
        {
            // This resets the offset address
            OffsetAddress = aOffset;

            // This resets the OffsetEndAddress
            Size = Size;
        }
        #endregion

        #region From GenericSymbol
        public override bool Parse( string aLine )
		{
            bool ret = false;
            //
            Match m = KSimpleSymbolRegEx.Match( aLine );
            if ( m.Success )
            {
                ret = ExtractFromMatch( m );
            }
            //
            return ret;
		}

        public override TSourceType SourceType
        {
            get { return GenericSymbol.TSourceType.ESourceTypeFileSymbol; }
        }
        #endregion

        #region Internal methods
        private bool ExtractFromMatch( Match aMatch )
        {
            bool ret = false;
            //
            long baseAddress = Collection.BaseAddress;
            long address = uint.Parse( aMatch.Groups[ "Address" ].Value, System.Globalization.NumberStyles.HexNumber );
            long offsetAddress = address - baseAddress;
            if ( address < baseAddress )
            {
                ret = false;
            }
            else
            {
                OffsetAddress = offsetAddress;
                Size = uint.Parse( aMatch.Groups[ "Size" ].Value, System.Globalization.NumberStyles.HexNumber );

                string symbolAndObject = aMatch.Groups[ "SymbolAndObject" ].Value;
                ParseSymbolText( symbolAndObject );

                System.Diagnostics.Debug.Assert( Address >= 0 );
                System.Diagnostics.Debug.Assert( Address <= EndAddress );

                ret = true;
            }
            //
            return ret;
        }
        #endregion

        #region Internal constants
        private static readonly Regex KSimpleSymbolRegEx = new Regex( "(?<Address>[A-Fa-f0-9]{8}) \\s+ (?<Size>[A-Fa-f0-9]{4,}) \\s+ (?<SymbolAndObject>.+)",
            RegexOptions.CultureInvariant
            | RegexOptions.Compiled
            );
        #endregion

        #region Internal methods
        protected void ParseSymbolText( string aText )
		{
			int splitPos = aText.LastIndexOf( ' ' );
			if	( splitPos > 0 )
			{
				Symbol = aText.Substring( 0, splitPos ).TrimEnd();
				Object = aText.Substring( splitPos ).TrimStart();
			}
			else
			{
				Symbol = aText;
                Object = string.Empty;
			}
		}
		#endregion
	}
}