/*

* 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.Collections.Generic;

using System.Text;

using SymbianUtils;

using SymbianUtils.Range;

using SymbianStructuresLib.Debug.Symbols;

using SymbianStructuresLib.Debug.Symbols.Interfaces;

using SymbianStructuresLib.CodeSegments;

using SymbianStructuresLib.Debug.Common.FileName;

using SymbianSymbolLib.SourceManagement.Provisioning;

namespace SymbianSymbolLib.SourceManagement.Source

{

    public class SymSource : DisposableObject, IEnumerable<SymbolCollection>, ISymbolCollectionRelocationHandler

    {

        #region Delegates & events

        public delegate void EventHandlerFunction( TEvent aEvent, SymSource aSource, object aData );

        public event EventHandlerFunction EventHandler;

        #endregion

        #region Enumerations

        public enum TEvent

        {

            EReadingStarted = 0,

            EReadingProgress,

            EReadingComplete

        }

        public enum TTimeToRead

        {

            EReadWhenPriming = 0,

            EReadWhenNeeded // i.e. relocated

        }

        #endregion

        #region Constructors

        public SymSource( string aURI, SymSourceProvider aProvider )

        {

            iURI = aURI;

            iProvider = aProvider;

        }

        public SymSource( string aURI, SymSourceProvider aProvider, SymbolCollection aCollection )

            : this( aURI, aProvider )

        {

            Add( aCollection );

        }

        #endregion

        #region API

        public virtual void Read( TSynchronicity aSynchronicity )

        {

            iProvider.ReadSource( this, aSynchronicity );

        }

        public virtual void Add( SymbolCollection aCollection )

        {

            // We want to be told if the collection changes it's relocation state.

            aCollection.RelocationStatusChanged += new SymbolCollection.RelocationStatusChangeHandler( Collection_RelocationStatusChanged );

            lock ( iCollectionsAll )

            {

                iCollectionsAll.Add( aCollection );

            }

            CategoriseCollection( aCollection );

        }

        public virtual void Remove( SymbolCollection aCollection )

        {

            aCollection.RelocationStatusChanged -= new SymbolCollection.RelocationStatusChangeHandler( Collection_RelocationStatusChanged );

            //

            lock ( iCollectionsAll )

            {

                iCollectionsAll.Remove( aCollection );

            }

            lock ( iAlwaysActivatedCollections )

            {

                iAlwaysActivatedCollections.Remove( aCollection );

            }

        }

        public virtual bool Contains( uint aAddress )

        {

            lock ( iAlwaysActivatedCollections )

            {

                return iAlwaysActivatedCollections.Contains( aAddress );

            }

        }

        public virtual Symbol Lookup( uint aAddress, out SymbolCollection aCollection )

        {

            lock ( iAlwaysActivatedCollections )

            {

                aCollection = null;

                //

                Symbol ret = iAlwaysActivatedCollections.Lookup( aAddress, out aCollection );

                return ret;

            }

        }

        protected virtual void OnAddedToCollection( SymSourceCollection aCollection )

        {

            ++iReferenceCount;

        }

        protected virtual void OnRemovedFromCollection( SymSourceCollection aCollection )

        {

            if ( --iReferenceCount <= 0 )

            {

                this.Dispose();

            }

        }

        protected virtual void OnPrepareForRelocation( SymbolCollection aCollection, uint aOldBase, uint aNewBase )

        {

            // If we read our data during priming, then we don't need to do anything... otherwise, we should

            // read the data now.

            if ( TimeToRead == TTimeToRead.EReadWhenNeeded )

            {

                this.Read( TSynchronicity.ESynchronous );

            }

        }

        #endregion

        #region API - framework

        public void ReportEvent( TEvent aEvent )

        {

            if ( aEvent == TEvent.EReadingComplete )

            {

                iAlwaysActivatedCollections.BuildLookupCache();

            }

            ReportEvent( aEvent, null );

        }

        public void ReportEvent( TEvent aEvent, object aData )

        {

            if ( EventHandler != null )

            {

                EventHandler( aEvent, this, aData );

            }

        }

        #endregion

        #region Event handlers

        private void Collection_RelocationStatusChanged( SymbolCollection aCollection )

        {

            CategoriseCollection( aCollection );

        }

        #endregion

        #region Properties

        public int Count

        {

            get

            {

                lock ( iCollectionsAll )

                {

                    return iCollectionsAll.Count;

                }

            }

        }

        public string URI

        {

            get

            {

                lock ( iURI )

                {

                    return iURI;

                }

            }

            set

            {

                lock ( iURI )

                {

                    iURI = value;

                }

            }

        }

        public string FileName

        {

            get { return iProvider.GetFileName( this ); }

        }

        public TTimeToRead TimeToRead

        {

            get { return iTimeToRead; }

            set

            {

                iTimeToRead = value;

            }

        }

        public SymSourceProvider Provider

        {

            get

            {

                lock ( iProvider )

                {

                    return iProvider;

                }

            }

        }

        public SymbolCollection this[ int aIndex ]

        {

            get 

            {

                lock ( iCollectionsAll )

                {

                    return iCollectionsAll[ aIndex ];

                }

            }

        }

        public virtual SymbolCollection this[ CodeSegDefinition aCodeSegment ]

        {

            get

            {

                lock ( iCollectionsAll )

                {

                    SymbolCollection ret = iCollectionsAll[ aCodeSegment ];

                    return ret;

                }

            }

        }

        public virtual SymbolCollection this[ PlatformFileName aFileName ]

        {

            get

            {

                lock ( iCollectionsAll )

                {

                    SymbolCollection ret = iCollectionsAll[ aFileName ];

                    return ret;

                }

            }

        }

        #endregion

        #region Internal methods

        internal int CountActivated

        {

            get

            {

                lock ( iAlwaysActivatedCollections )

                {

                    return iAlwaysActivatedCollections.Count;

                }

            }

        }

        internal void AddedToCollection( SymSourceCollection aCollection )

        {

            OnAddedToCollection( aCollection );

        }

        internal void RemovedFromCollection( SymSourceCollection aCollection )

        {

            OnRemovedFromCollection( aCollection );

        }

        private void CategoriseCollection( SymbolCollection aCollection )

        {

            // Reset state

            lock ( iAlwaysActivatedCollections )

            {

                iAlwaysActivatedCollections.Remove( aCollection );

                aCollection.IfaceRelocationHandler = null;

            }

            // Collections which do not move from their pre-determined base address

            // are transparently "activated" which means that they will be queried

            // automatically during symbolic look up.

            if ( aCollection.IsFixed )

            {

                lock ( iAlwaysActivatedCollections )

                {

                    iAlwaysActivatedCollections.Add( aCollection );

                }

            }

            else

            {

                aCollection.IfaceRelocationHandler = this;

            }

        }

        #endregion

        #region From ISymbolCollectionRelocationHandler

        public void PrepareForRelocation( SymbolCollection aCollection, uint aOldBase, uint aNewBase )

        {

            OnPrepareForRelocation( aCollection, aOldBase, aNewBase );

        }

        #endregion

        #region From IEnumerable<SymbolCollection>

        public IEnumerator<SymbolCollection> GetEnumerator()

        {

            lock ( iCollectionsAll )

            {

                foreach ( SymbolCollection col in iCollectionsAll )

                {

                    yield return col;

                }

            }

        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()

        {

            lock ( iCollectionsAll )

            {

                foreach ( SymbolCollection col in iCollectionsAll )

                {

                    yield return col;

                }

            }

        }

        #endregion

        #region From DisposableObject

        protected override void CleanupManagedResources()

        {

            try

            {

                base.CleanupManagedResources();

            }

            finally

            {

                int count = iCollectionsAll.Count;

                for ( int i = count - 1; i >= 0; i-- )

                {

                    SymbolCollection col = iCollectionsAll[ i ];

                    Remove( col );

                    col.Dispose();

                }

                // These should both be empty in any case

                iCollectionsAll.Clear();

                iAlwaysActivatedCollections.Clear();

            }

        }

        #endregion

        #region From System.Object

        public override string ToString()

        {

            return URI;

        }

        public override int GetHashCode()

        {

            return URI.GetHashCode();

        }

        public override bool Equals( object aObject )

        {

            if ( aObject is SymSource )

            {

                SymSource other = (SymSource) aObject;

                bool ret = ( string.Compare( other.URI, this.URI, StringComparison.CurrentCultureIgnoreCase ) == 0 );

                return ret;

            }

            //

            return base.Equals( aObject );

        }

        #endregion

        #region Data members

        private readonly SymSourceProvider iProvider;

        private string iURI = string.Empty;

        private int iReferenceCount = 0;

        private TTimeToRead iTimeToRead = TTimeToRead.EReadWhenPriming;

        private SymbolCollectionList iCollectionsAll = new SymbolCollectionList();

        private SymbolCollectionList iAlwaysActivatedCollections = new SymbolCollectionList();

        #endregion

    }

}