/*

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

using System.Collections.Generic;

using SymbolLib.Utils;

using SymbianUtils.Range;

namespace SymbolLib.Generics

{

	public abstract class GenericSymbolCollection : IEnumerable<GenericSymbol>, IComparable<GenericSymbolCollection>

	{

		#region Construct & destruct

		protected GenericSymbolCollection( string aHostBinaryFileName )

		{

            HostBinaryFileName = aHostBinaryFileName;

		}

		#endregion

        #region Virtual API

        public virtual void ClearTag()

        {

            Tagged = false;

        }

        public virtual void WriteToStream( StreamWriter aWriter )

        {

            // First write the binary name

            aWriter.WriteLine( string.Empty );

            aWriter.WriteLine( "From    " + HostBinaryFileName );

            aWriter.WriteLine( string.Empty );

            foreach ( GenericSymbol symbol in this )

            {

                aWriter.WriteLine( symbol.ToStringForStream() );

            }

        }

        #endregion

        #region Abstract API - methods

        public abstract void Add( GenericSymbolEngine aEngine, GenericSymbol aSymbol );

		public abstract void Remove( GenericSymbol aSymbol );

		public abstract void RemoveAt( int aIndex );

        public abstract IEnumerator CreateEnumerator();

        public abstract IEnumerator<GenericSymbol> CreateGenericEnumerator();

        public abstract GenericSymbol SymbolForAddress( long aAddress );

        #endregion

		#region Abstract API - properties

		public abstract int Count

		{

			get;

		}

		public abstract GenericSymbol this[ int aIndex ]

		{

			get;

		}

		public abstract void Sort();

		#endregion

		#region API

		public bool AddressFallsWithinRange( long aAddress )

		{

            bool found = false;

            //

            if ( this.Count == 1 && this[ 0 ].IsUnknownSymbol )

            {

                int x = 0;

                x++;

            }

            if ( aAddress > 0 )

            {

                if ( iAddresses == null )

                {

                    RebuildAddressRange();

                }

                //

                found = iAddresses.IsWithinRange( aAddress );

            }

            //

			return found;

		}

#if DEBUG

        public void Dump()

        {

            int i = 0;

            string line = string.Empty;

            foreach ( GenericSymbol entry in this )

            {

                line = i.ToString( "d8" ) + "   [" + entry.Address.ToString( "x8" ) + "-" + entry.EndAddress.ToString( "x8" ) + "] " + entry.Symbol.ToString();

                System.Diagnostics.Debug.WriteLine( line );

                i++;

            }

        }

        public void Dump( long aAddress )

        {

            int i = 0;

            string line = string.Empty;

            foreach ( GenericSymbol entry in this )

            {

                if ( entry.FallsWithinDomain( aAddress ) )

                {

                    line = i.ToString( "d8" ) + " * [" + entry.Address.ToString( "x8" ) + "-" + entry.EndAddress.ToString( "x8" ) + "] " + entry.Symbol.ToString();

                }

                else

                {

                    line = i.ToString( "d8" ) + "   [" + entry.Address.ToString( "x8" ) + "-" + entry.EndAddress.ToString( "x8" ) + "] " + entry.Symbol.ToString();

                }

                System.Diagnostics.Debug.WriteLine( line );

                i++;

            }

        }

#endif

        #endregion

		#region Symbol Properties

		public GenericSymbol FirstSymbol

		{

			get

			{

				GenericSymbol ret = null;

				if ( Count > 0 )

				{

					ret = this[ 0 ];

				}

				return ret;

			}

		}

		public GenericSymbol LastSymbol

		{

			get

			{

				GenericSymbol ret = null;

				if ( Count > 0 )

				{

					ret = this[ Count - 1 ];

				}

				return ret;

			}

		}

		#endregion

		#region Misc Properties

        public bool Tagged

        {

            get { return iTagged; }

            set { iTagged = value; }

        }

        public long BaseAddress

        {

            get { return iBaseAddress; }

            internal set { iBaseAddress = value; }

        }

		public string HostBinaryFileName

		{

            get { return iHostBinaryFileName; }

			set

            {

                System.Diagnostics.Debug.Assert( !value.ToLower().Contains( ".map" ) );

                iHostBinaryFileName = value; 

            }

		}

		public bool HostBinaryExists

		{

            get { return File.Exists( HostBinaryFileName ); }

		}

		public virtual long AddressRangeStart

		{

			get

			{

				long ret = 0;

				//

				if ( Count > 0 )

				{

					ret = FirstSymbol.Address;

				}

				//

				return ret;

			}

		}

		public virtual long AddressRangeEnd

		{

			get

			{

				long ret = 0xffffffff;

				//

				if ( Count > 0 )

				{

					ret = LastSymbol.EndAddress;

				}

				//

				return ret;

			}

		}

        public virtual AddressRange AddressRange

        {

            get { return new AddressRange( AddressRangeStart, AddressRangeEnd ); }

        }

        public string SourceFile

        {

            get { return iSourceFile; }

            internal set { iSourceFile = value; }

        }

		#endregion

        #region Internal methods

        protected void RebuildAddressRange()

        {

            iAddresses = new SymbolAddressRange( this );

        }

        #endregion

        #region From IEnumerable

        IEnumerator IEnumerable.GetEnumerator()

        {

            return CreateEnumerator();

        }

        IEnumerator<GenericSymbol> IEnumerable<GenericSymbol>.GetEnumerator()

        {

            return CreateGenericEnumerator();

        }

        #endregion

		#region From IComparable

        public int CompareTo( GenericSymbolCollection aOther )

		{

            int ret = 1;

            //

            if ( aOther != null )

            {

                ret = string.Compare( HostBinaryFileName, aOther.HostBinaryFileName, true );

                //

                if ( aOther is GenericSymbolCollection )

                {

                    GenericSymbolCollection otherCol = (GenericSymbolCollection) aOther;

                    //

                    if ( BaseAddress == otherCol.BaseAddress )

                    {

                        ret = 0;

                    }

                    else if ( BaseAddress > otherCol.BaseAddress )

                    {

                        ret = 1;

                    }

                    else

                    {

                        ret = -1;

                    }

                }

            }

            // Debug check

            if ( aOther == this )

            {

                System.Diagnostics.Debug.Assert( ret == 0 );

            }

            //

            return ret;

		}

		#endregion

        #region From System.Object

        public override string ToString()

        {

            return string.Format( "{0} {1}", AddressRange, iHostBinaryFileName );

        }

        #endregion

        #region Data members

        private bool iTagged = false;

        private long iBaseAddress = 0;

        private string iHostBinaryFileName = string.Empty;

        private string iSourceFile = string.Empty;

        private SymbolAddressRange iAddresses = null;

		#endregion

    }

}