/*

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

using System.Collections.Generic;

using System.Threading;

using SymbianUtils;

using SymbianUtils.Range;

using SymbianStructuresLib.CodeSegments;

using SymbianStructuresLib.Debug.Symbols.Interfaces;

using SymbianStructuresLib.Debug.Common.Id;

using SymbianStructuresLib.Debug.Common.Interfaces;

using SymbianStructuresLib.Debug.Common.FileName;

namespace SymbianStructuresLib.Debug.Symbols

{

    public class SymbolCollection : DisposableObject, IEnumerable<Symbol>, IComparable<SymbolCollection>, IComparer<Symbol>, IFormattable

    {

        #region Static constructors

        public static SymbolCollection New( IPlatformIdAllocator aIdAllocator, string aFileNameInHost, string aFileNameInDevice )

        {

            SymbolCollection ret = new SymbolCollection( aIdAllocator, aFileNameInHost, aFileNameInDevice );

            return ret;

        }

        public static SymbolCollection NewCopy( IPlatformIdAllocator aIdAllocator, SymbolCollection aCollection )

        {

            SymbolCollection ret = new SymbolCollection( aIdAllocator, aCollection );

            return ret;

        }

        public static SymbolCollection NewByHostFileName( IPlatformIdAllocator aIdAllocator, string aFileName )

        {

            SymbolCollection ret = new SymbolCollection( aIdAllocator, aFileName );

            return ret;

        }

        #endregion

        #region Delegates & events

        public delegate void RelocationStatusChangeHandler( SymbolCollection aCollection );

        public event RelocationStatusChangeHandler RelocationStatusChanged;

        #endregion

        #region Constructors

        private SymbolCollection( IPlatformIdAllocator aIdAllocator, string aFileNameInHost )

		{

            iOriginalCollection = null;

            iId = aIdAllocator.AllocateId();

            iIdAllocator = aIdAllocator;

            iFileName = PlatformFileName.NewByHostName( aFileNameInHost );

            DefaultSymbolAdd();

		}

        private SymbolCollection( IPlatformIdAllocator aIdAllocator, string aFileNameInHost, string aFileNameInDevice )

            : this( aIdAllocator, aFileNameInHost )

        {

            iFileName.FileNameInDevice = aFileNameInDevice;

        }

        private SymbolCollection( IPlatformIdAllocator aIdAllocator, SymbolCollection aCopy )

        {

            iId = aIdAllocator.AllocateId();

            iIdAllocator = aIdAllocator;

            iTag = aCopy.iTag;

            iOriginalCollection = aCopy;

            iFlags = aCopy.iFlags;

            iTagged = aCopy.iTagged;

            iBaseAddress = aCopy.iBaseAddress;

            iCodeSegmentResolver = aCopy.iCodeSegmentResolver;

            iRelocationHandler = aCopy.iRelocationHandler;

            iFileName = PlatformFileName.New( aCopy.FileName );

            iCodeSegmentResolver = aCopy.IfaceCodeSegmentResolver;

            iRelocationHandler = aCopy.IfaceRelocationHandler;

            // Deep copy symbols

            foreach ( Symbol symbol in aCopy )

            {

                Symbol clone = Symbol.NewClone( this, symbol );

                iSymbols.Add( clone );

            }

            // Recalculate addresses

            RecalculationAddressRange();

        }

		#endregion

        #region API

        public void Serialize( StreamWriter aWriter )

        {

            StringBuilder temp = new StringBuilder();

            //

            lock ( iFileName )

            {

                temp.AppendLine( string.Empty );

                temp.AppendLine( "From    " + iFileName.FileNameInHost );

                temp.AppendLine( string.Empty );

            }

            //

            lock ( iSymbols )

            {

                foreach ( Symbol symbol in iSymbols )

                {

                    temp.AppendLine( symbol.ToString( "stream", null ) );

                }

            }

            aWriter.Write( temp.ToString() );

        }

        public void Add( Symbol aSymbol )

        {

            if ( aSymbol.IsDefault )

            {

                throw new ArgumentException( "Cannot add default symbol" );

            }

            //

            lock ( iSymbols )

            {

                int count = iSymbols.Count;

                if ( count == 1 )

                {

                    // Possibly...

                    DefaultSymbolRemove();

                }

                // Because count might have changed if we removed default

                // symbol.

                count = iSymbols.Count;

                if ( count >= 1 )

                {

                    Symbol last = iSymbols[ count - 1 ];

                    if ( aSymbol.Address < last.Address )

                    {

                        // We appear to be adding a symbol with an earlier address,

                        // which implies we need to sort the collection.

                        lock( iFlagLock )

                        {

                            iFlags |= TFlags.EFlagsRequiresSorting;

                        }

                    }

                }

                // Now add it

                iSymbols.Add( aSymbol );

                //

                if ( !InTransaction )

                {

                    RecalculationAddressRange();

                }

            }

        }

        public void AddRange( IEnumerable<Symbol> aSymbols )

        {

            TransactionBegin();

            //

            try

            {

                foreach ( Symbol symbol in aSymbols )

                {

                    Add( symbol );

                }

            }

            finally

            {

                TransactionEnd();

            }

        }

        public void Clear()

        {

            lock ( iSymbols )

            {

                iSymbols.Clear();

                // We are definitely empty so force the default symbol to be

                // added irrespective of flags

                DefaultSymbolAdd( true );

            }

        }

        public void Remove( Symbol aSymbol )

        {

            if ( aSymbol.IsDefault )

            {

                throw new ArgumentException( "Cannot remove default symbol" );

            }

            //

            lock ( iSymbols )

            {

                iSymbols.Remove( aSymbol );

                if ( iSymbols.Count == 0 )

                {

                    // We are definitely empty so force the default symbol to be

                    // added irrespective of flags

                    DefaultSymbolAdd( true );

                    System.Diagnostics.Debug.Assert( IsEmptyApartFromDefaultSymbol );

                }

            }

        }

        public void RemoveAt( int aIndex )

        {

            lock ( iSymbols )

            {

                Symbol symbol = iSymbols[ aIndex ];

                if ( symbol.IsDefault )

                {

                    throw new ArgumentException( "Cannot remove default symbol" );

                }

                //

                iSymbols.RemoveAt( aIndex );

                if ( iSymbols.Count == 0 )

                {

                    // We are definitely empty so force the default symbol to be

                    // added irrespective of flags

                    DefaultSymbolAdd( true );

                    System.Diagnostics.Debug.Assert( IsEmptyApartFromDefaultSymbol );

                }

            }

        }

        public bool Contains( uint aAddress )

        {

            if ( iAddresses == null )

            {

                iAddresses = new AddressRangeCollection( (IEnumerable<AddressRange>) this );

                RecalculationAddressRange();

            }

            //

            bool found = iAddresses.Contains( aAddress );

            return found;

        }

        public bool IsMatchingCodeSegment( CodeSegDefinition aCodeSegment )

        {

            bool ret = false;

            //

            if ( iCodeSegmentResolver != null )

            {

                ret = iCodeSegmentResolver.IsMatchingCodeSegment( this, aCodeSegment );

            }

            else

            {

                PlatformFileName codeSegName = PlatformFileName.NewByDeviceName( aCodeSegment.FileName );

                ret = FileName.Equals( codeSegName );

            }

            //

            return ret;

        }

        public void Sort()

        {

            if ( ( iFlags & TFlags.EFlagsRequiresSorting ) == TFlags.EFlagsRequiresSorting )

            {

                iSymbols.Sort( this );

                RecalculationAddressRange();

            }

        }

        public void SortAsync()

        {

            if ( ( iFlags & TFlags.EFlagsRequiresSorting ) == TFlags.EFlagsRequiresSorting )

            {

                ThreadPool.QueueUserWorkItem( new WaitCallback( InitiateAsyncSort ) );

            }

        }

        public void Relocate( uint aTo )

        {

            uint old = iBaseAddress;

            iBaseAddress = aTo;

            //

            if ( iRelocationHandler != null )

            {

                iRelocationHandler.PrepareForRelocation( this, old, BaseAddress );

            }

            //

            RecalculationAddressRange();

        }

        public void TransactionBegin()

        {

            lock ( iFlagLock )

            {

                iFlags |= TFlags.EFlagsInTransaction;

            }

        }

        public void TransactionEnd()

        {

            lock ( iFlagLock )

            {

                iFlags &= ~TFlags.EFlagsInTransaction;

            }

            RecalculationAddressRange();

        }

        public void Clone( IEnumerable<Symbol> aSymbols )

        {

            // Deep copy symbols

            Clear();

            try

            {

                TransactionBegin();

                foreach ( Symbol symbol in aSymbols )

                {

                    // Make sure we don't try to add the default symbol. The symbol collection

                    // manages this automatically.

                    if ( symbol.IsDefault )

                    {

                    }

                    else

                    {

                        Symbol clone = Symbol.NewClone( this, symbol );

                        Add( clone );

                    }

                }

            }

            finally

            {

                TransactionEnd();

            }

        }

        #endregion

		#region Properties

		public int Count

		{

            get

            {

                lock ( iSymbols )

                {

                    return iSymbols.Count;

                }

            }

		}

		public Symbol this[ int aIndex ]

		{

            get

            {

                lock ( iSymbols )

                {

                    return iSymbols[ aIndex ];

                }

            }

        }

        public Symbol this[ uint aAddress ]

        {

            get

            {

                // For debugging

                int x = 0;

                if ( x > 0 )

                {

                    string dump = Dump( aAddress );

                    System.Diagnostics.Debug.WriteLine( dump );

                }

                //

                Symbol ret = null;

                Symbol temp = Symbol.NewTemp( this, aAddress );

                //

                lock ( iSymbols )

                {

                    AddressFindingComparer comparer = new AddressFindingComparer();

                    int pos = iSymbols.BinarySearch( temp, comparer );

                    int count = iSymbols.Count;

                    //

                    if ( pos >= 0 && pos < count )

                    {

                        ret = iSymbols[ pos ];

                        System.Diagnostics.Debug.Assert( ret.AddressRange.Contains( aAddress ) );

                    }

                }

                //

                return ret;

            }

        }

        public Symbol FirstSymbol

		{

			get

			{

				Symbol ret = null;

                lock ( iSymbols )

                {

                    if ( Count > 0 )

                    {

                        ret = this[ 0 ];

                    }

                }

				return ret;

			}

		}

		public Symbol LastSymbol

		{

			get

			{

				Symbol ret = null;

                lock ( iSymbols )

                {

                    if ( Count > 0 )

                    {

                        ret = this[ Count - 1 ];

                    }

                }

				return ret;

			}

		}

        public bool Tagged

        {

            get { return iTagged; }

            set

            {

                // The 'tagged' property is one of the few that we must (and can safely)

                // cascade to the original underlying collection. 

                //

                // We do this, because when working with ROFS/relocated symbols, we generally

                // clone and fixup, rather than fixup the original. This permits us to use

                // a symbol collection at multiple base addresses (i.e. use the same symbols within

                // different process-relative views of the "world").

                //

                // If we don't cascade the tagged attribute to the original (i.e. primary) symbol

                // collection, then when the client application wants to serialized tagged collections

                // the ROFS collections will potentially be missing (if they have been unloaded).

                if ( iOriginalCollection != null )

                {

                    iOriginalCollection.Tagged = value;

                    iTagged = value;

                }

                else if ( iTagged != value )

                {

                    iTagged = value;

                    if ( iTagged )

                    {

                        System.Diagnostics.Debug.WriteLine( string.Format( "[S] TAGGING: 0x{0:x8}, {1}", this.BaseAddress, iFileName ) );

                    }

                }

            }

        }

        public bool InTransaction

        {

            get { return ( iFlags & TFlags.EFlagsInTransaction ) == TFlags.EFlagsInTransaction; }

        }

        public bool IsRelocatable

        {

            get { return ( iFlags & TFlags.EFlagsIsRelocatable ) == TFlags.EFlagsIsRelocatable; }

            set

            {

                lock ( iFlagLock )

                {

                    bool wasSet = ( iFlags & TFlags.EFlagsIsRelocatable ) == TFlags.EFlagsIsRelocatable;

                    if ( wasSet != value )

                    {

                        if ( value )

                        {

                            iFlags |= TFlags.EFlagsIsRelocatable;

                        }

                        else

                        {

                            iFlags &= ~TFlags.EFlagsIsRelocatable;

                        }

                        // Report event if needed

                        if ( RelocationStatusChanged != null )

                        {

                            RelocationStatusChanged( this );

                        }

                    }

                }

            }

        }

        public bool IsFixed

        {

            get { return !IsRelocatable; }

            set

            {

                IsRelocatable = !value;

            }

        }

        public bool IsEmptyApartFromDefaultSymbol

        {

            get

            { 

                bool ret = ( iFlags & TFlags.EFlagsIsEmptyApartFromDefaultSymbol ) == TFlags.EFlagsIsEmptyApartFromDefaultSymbol;

                return ret;

            }

            private set

            {

                lock ( iFlagLock )

                {

                    if ( value )

                    {

                        iFlags |= TFlags.EFlagsIsEmptyApartFromDefaultSymbol;

                    }

                    else

                    {

                        iFlags &= ~TFlags.EFlagsIsEmptyApartFromDefaultSymbol;

                    }

                }

            }

        }

        public object Tag

        {