/*

* 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 SymbianUtils.Threading;

using SymbianStructuresLib.Arm;

using SymbianStructuresLib.Arm.Instructions;

using SymbianStructuresLib.CodeSegments;

using SymbianStructuresLib.Debug.Code;

using SymbianStructuresLib.Debug.Code.Interfaces;

using SymbianStructuresLib.Debug.Common.FileName;

using SymbianCodeLib.SourceManagement.Provisioning;

namespace SymbianCodeLib.SourceManagement.Source

{

    public abstract class CodeSource : DisposableObject, IEnumerable<CodeCollection>, ICodeCollectionRelocationHandler, ICodeCollectionInstructionConverter

    {

        #region Delegates & events

        public delegate void EventHandlerFunction( TEvent aEvent, CodeSource 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 CodeSource( string aURI, CodeSourceProvider aProvider )

        {

            iURI = aURI;

            iProvider = aProvider;

        }

        #endregion

        #region API

        public virtual void Read( TSynchronicity aSynchronicity )

        {

            bool isReading = this.IsReadInProgress;

            if ( isReading )

            {

                // Another thread is already reading this source.

                // If the caller asked for asynchronous reading, then when the

                // other thread completes the read the caller (in this thread) 

                // will be notified via the normal event callback framework - in which

                // case we need do nothing at all - just let the other thread get on with it.

                //

                // If, on the other hand, the caller requested a synchronous read, then they

                // will expect the code to be ready at the point in time which we return to them.

                //

                // In this situation, we should block this method until the code becomes ready.

                if ( aSynchronicity == TSynchronicity.ESynchronous )

                {

                    while ( this.IsReadInProgress )

                    {

                        System.Threading.Thread.Sleep( 0 );

                    }

                }

            }

            else

            {

                DoRead( aSynchronicity );

            }

        }

        public virtual void Add( CodeCollection aCollection )

        {

            // We can always do this task

            aCollection.IfaceInstructionConverter = this;

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

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

            lock ( iCollectionsAll )

            {

                iCollectionsAll.Add( aCollection );

            }

            CategoriseCollection( aCollection );

        }

        public virtual void Remove( CodeCollection aCollection )

        {

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

            //

            lock ( iCollectionsAll )

            {

                iCollectionsAll.Remove( aCollection );

            }

            lock ( iAlwaysActivatedCollections )

            {

                iAlwaysActivatedCollections.Remove( aCollection );

            }

        }

        public virtual bool Contains( uint aAddress )

        {

            return iAlwaysActivatedCollections.Contains( aAddress );

        }

        public virtual bool ProvideInstructions( uint aAddress, TArmInstructionSet aInstructionSet, int aCount, out IArmInstruction[] aInstructions )

        {

            lock ( iAlwaysActivatedCollections )

            {

                bool ret = iAlwaysActivatedCollections.GetInstructions( aAddress, aInstructionSet, aCount, out aInstructions );

                return ret;

            }

        }

        protected abstract void DoRead( TSynchronicity aSynchronicity );

        protected virtual void OnAddedToCollection( CodeSourceCollection aCollection )

        {

            ++iReferenceCount;

        }

        protected virtual void OnRemovedFromCollection( CodeSourceCollection aCollection )

        {

            if ( --iReferenceCount <= 0 )

            {

                this.Dispose();

            }

        }

        protected virtual void OnPrepareForRelocation( CodeCollection 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.

            //

            // However, don't initiate a read if we already have obtained code for the specified collection

            // (this can be the case if we are relocating a cloned code collection which has already been activated

            // itself in the past).

            if ( aCollection.IsCodeAvailable == false )

            {

                System.Diagnostics.Debug.Assert( this.IsReady == false );

                //

                if ( TimeToRead == TTimeToRead.EReadWhenNeeded )

                {

                    this.Read( TSynchronicity.ESynchronous );

                }

            }

        }

        protected virtual void OnReadComplete()

        {

        }

        #endregion

        #region API - framework

        public void ReportEvent( TEvent aEvent )

        {

            ReportEvent( aEvent, null );

        }

        public void ReportEvent( TEvent aEvent, object aData )

        {

            PreProcessEvent( aEvent );

            // Cascade

            if ( EventHandler != null )

            {

                EventHandler( aEvent, this, aData );

            }

        }

        #endregion

        #region Properties

        public int Count

        {

            get { 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 CodeSourceProvider Provider

        {

            get

            {

                lock ( iProvider )

                {

                    return iProvider;

                }

            }

        }

        public CodeCollection this[ int aIndex ]

        {

            get { return iCollectionsAll[ aIndex ]; }

        }

        public virtual CodeCollection this[ CodeSegDefinition aCodeSegment ]

        {

            get

            {

                CodeCollection ret = iCollectionsAll[ aCodeSegment ];

                return ret;

            }

        }

        public virtual CodeCollection this[ PlatformFileName aFileName ]

        {

            get

            {

                lock ( iCollectionsAll )

                {

                    CodeCollection ret = iCollectionsAll[ aFileName ];

                    return ret;

                }

            }

        }

        public bool IsReady

        {

            get

            {

                lock ( iFlagsSyncRoot )

                {

                    bool ret = ( iFlags & TFlags.EFlagsIsReady ) != 0;

                    return ret;

                }

            }

            set

            {

                lock ( iFlagsSyncRoot )

                {

                    if ( value )

                    {

                        iFlags |= TFlags.EFlagsIsReady;

                    }

                    else

                    {

                        iFlags &= ~TFlags.EFlagsIsReady;

                    }

                }

            }

        }

        public bool IsReadInProgress

        {

            get

            {

                lock ( iFlagsSyncRoot )

                {

                    bool ret = ( iFlags & TFlags.EFlagsIsReadInProgress ) != 0;

                    return ret;

                }

            }

            set

            {

                lock ( iFlagsSyncRoot )

                {

                    if ( value )

                    {

                        iFlags |= TFlags.EFlagsIsReadInProgress;

                    }

                    else

                    {

                        iFlags &= ~TFlags.EFlagsIsReadInProgress;

                    }

                }

            }

        }

        #endregion

        #region Event handlers

        private void Collection_RelocationStatusChanged( CodeCollection aCollection )

        {

            CategoriseCollection( aCollection );

        }

        #endregion

        #region Internal methods

        internal int CountActivated

        {

            get { return iAlwaysActivatedCollections.Count; }

        }

        internal void AddedToCollection( CodeSourceCollection aCollection )

        {

            OnAddedToCollection( aCollection );

        }

        internal void RemovedFromCollection( CodeSourceCollection aCollection )

        {

            OnRemovedFromCollection( aCollection );

        }

        private void CategoriseCollection( CodeCollection 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

            {

                // Otherwise, we must wait until the client relocates the code

                // and then we will be called back. During the callback processing

                // we'll load the code (if needed) and fixup the base address.

                aCollection.IfaceRelocationHandler = this;

            }

        }

        private void PreProcessEvent( TEvent aEvent )

        {

            switch ( aEvent )

            {

            case TEvent.EReadingStarted:

                IsReady = false;

                IsReadInProgress = true;

                break;

            case TEvent.EReadingComplete:

                IsReady = true;

                IsReadInProgress = false;

                OnReadComplete();

                break;

            }

        }

        #endregion

        #region Internal enumerations

        [Flags]

        private enum TFlags

        {

            EFlagsNone = 0,

            EFlagsIsReady = 1,

            EFlagsIsReadInProgress = 2

        }

        #endregion

        #region From ICodeCollectionRelocationHandler

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

        {

            OnPrepareForRelocation( aCollection, aOldBase, aNewBase );

        }

        #endregion

        #region From ICodeCollectionInstructionConverter

        public IArmInstruction[] ConvertRawValuesToInstructions( TArmInstructionSet aInstructionSet, uint[] aRawValues, uint aStartingAddress )

        {

            IArmInstruction[] ret = iProvider.ConvertToInstructions( aInstructionSet, aRawValues, aStartingAddress );

            return ret;

        }

        #endregion

        #region From IEnumerable<CodeCollection>

        public IEnumerator<CodeCollection> GetEnumerator()

        {

            foreach ( CodeCollection col in iCollectionsAll )

            {

                yield return col;

            }

        }

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

        {

            foreach ( CodeCollection 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-- )

                {

                    CodeCollection 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 CodeSource )

            {

                CodeSource other = (CodeSource) aObject;

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

                return ret;

            }

            //

            return base.Equals( aObject );

        }

        #endregion

        #region Data members

        private readonly CodeSourceProvider iProvider;

        private string iURI = string.Empty;

        private int iReferenceCount = 0;

        private TTimeToRead iTimeToRead = TTimeToRead.EReadWhenPriming;

        private CodeCollectionList iCollectionsAll = new CodeCollectionList();

        private CodeCollectionList iAlwaysActivatedCollections = new CodeCollectionList();

        private object iFlagsSyncRoot = new object();

        private TFlags iFlags = TFlags.EFlagsNone;

        #endregion

    }

}