/*

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

using System.Text;

using System.IO;

using System.ComponentModel;

using System.Threading;

using SymbianUtils;

using SymbianUtils.Tracer;

using SymbianUtils.PluginManager;

using SymbianStructuresLib.Uids;

using SymbianStructuresLib.Compression.Common;

using SymbianImageLib.Common.Image;

using SymbianImageLib.Common.Header;

using SymbianImageLib.Common.Streams;

using SymbianImageLib.Common.Factory;

namespace SymbianImageLib.Common.Content

{

    public abstract class SIContent : DisposableObject, ITracer

    {

        #region Enumerations

        public enum TDecompressionEvent

        {

            EEventDecompressionStarting = 0,

            EEventDecompressionProgress,

            EEventDecompressionComplete

        }

        #endregion

        #region Delegates & events

        public delegate void DecompressionEventHandler( TDecompressionEvent aEvent, SIContent aFile, object aData );

        public event DecompressionEventHandler DecompressionEvent;

        #endregion

        #region Constructors

        protected SIContent( SIImage aImage )

        {

            iImage = aImage;

        }

        #endregion

        #region Framework API

        public abstract TSymbianCompressionType CompressionType

        {

            get;

        }

        public abstract string FileName

        {

            get;

        }

        public abstract uint FileSize

        {

            get;

        }

        public abstract uint ContentSize

        {

            get;

        }

        public virtual bool IsRelocationSupported

        {

            get { return true; }

        }

        public virtual TCheckedUid Uid

        {

            get { return new TCheckedUid(); }

        }

        public virtual byte[] GetAllData()

        {

            return new byte[ 0 ];

        }

        public virtual uint ProvideDataUInt32( uint aAddress )

        {

            uint ret = 0;

            //

            if ( IsContentPrepared == false )

            {

                // Cannot provide data if we've not prepared it yet

            }

            else if ( iDecompressionException == false )

            {

                WaitForAsyncOperationCompletion();

                uint resolvedAddress = FixupAddress( aAddress );

                ret = DoProvideDataUInt32( resolvedAddress );

            }

            //

            return ret;

        }

        public virtual ushort ProvideDataUInt16( uint aAddress )

        {

            ushort ret = 0;

            //

            if ( IsContentPrepared == false )

            {

                // Cannot provide data if we've not prepared it yet

            }

            else if ( iDecompressionException == false )

            {

                WaitForAsyncOperationCompletion();

                uint resolvedAddress = FixupAddress( aAddress );

                ret = DoProvideDataUInt16( resolvedAddress );

            }

            //

            return ret;

        }

        public virtual bool IsCode

        {

            get { return true; }

        }

        protected virtual void OnRelocationAddressChanged( uint aOld, uint aNew )

        {

        }

        protected virtual void DoDecompress()

        {

        }

        protected virtual uint DoProvideDataUInt32( uint aTranslatedAddress )

        {

            throw new NotImplementedException();

        }

        protected virtual ushort DoProvideDataUInt16( uint aTranslatedAddress )

        {

            throw new NotImplementedException();

        }

        protected abstract bool GetIsContentPrepared();

        #endregion

        #region API

        public void PrepareContent( TSynchronicity aSynchronicity )

        {

            if ( CompressionType == TSymbianCompressionType.ENone )

            {

                // No content preparation required, so just indicate completion

                // immediately.

                ReportDecompressionEvent( TDecompressionEvent.EEventDecompressionStarting );

                ReportDecompressionEvent( TDecompressionEvent.EEventDecompressionComplete );

            }

            else

            {

                switch ( aSynchronicity )

                {

                case TSynchronicity.ESynchronous:

                    RunDecompressor();

                    break;

                case TSynchronicity.EAsynchronous:

                    // Must take the lock to either create or destroy waiter

                    lock ( iWaiterSyncRoot )

                    {

                        if ( iWaiter == null )

                        {

                            iWaiter = new AutoResetEvent( false );

                            ThreadPool.QueueUserWorkItem( new WaitCallback( RunDecompressionInBackgroundThread ), null );

                            break;

                        }

                        else

                        {

                            // Wait is active, so we are presumably busy...

                            throw new Exception( "Content is already in preparation" );

                        }

                    }

                }

            }

        }

        public uint RelocationAddress

        {

            get { return iRelocationAddress; }

            set

            {

                if ( value != iRelocationAddress )

                {

                    uint old = iRelocationAddress;

                    iRelocationAddress = value;

                    OnRelocationAddressChanged( old, iRelocationAddress );

                }

            }

        }

        public virtual bool IsContentPrepared

        {

            get

            {

                bool ret = true;

                //

                if ( CompressionType != TSymbianCompressionType.ENone )

                {

                    ret = GetIsContentPrepared();

                }

                //

                return ret;

            }

        }

        #endregion

        #region Properties

        public SIImage Image

        {

            get { return iImage; }

        }

        public SIHeader ImageHeader

        {

            get { return iImage.Header; }

        }

        internal SIStream ImageStream

        {

            get 

            {

                return iImage.Stream; 

            }

            set { iImage.Stream = value; }

        }

        #endregion

        #region Event handlers

        private void RunDecompressionInBackgroundThread( object aNotUsed )

        {

            System.Diagnostics.Debug.Assert( iWaiter != null );

            // Call derived class to do decompression. Must not throw.

            RunDecompressor();

            // Must do this last so that anybody that is waiting for code to become

            // ready is resumed.

            //

            // Also, we might have been disposed of as a result of the "completion" callback

            // so in that case, we will have already set the auto-reset-event during the cleanup.

            if ( iWaiter != null )

            {

                iWaiter.Set();

            }

        }

        #endregion

        #region Internal methods

        protected void ReportDecompressionEvent( TDecompressionEvent aEvent )

        {

            ReportDecompressionEvent( aEvent, null );

        }

        protected void ReportDecompressionEvent( TDecompressionEvent aEvent, object aData )

        {

            if ( DecompressionEvent != null )

            {

                DecompressionEvent( aEvent, this, aData );

            }

        }

        private void RunDecompressor()

        {

            Trace( "[SIImageContent] RunDecompressor() - START - this: " + FileName );

            ReportDecompressionEvent( TDecompressionEvent.EEventDecompressionStarting );

            //

            try

            {

                DoDecompress();

            }

            catch ( Exception e )

            {

                Trace( "[SIImageContent] RunDecompressor() - Exception - this: {0}, message: {1}", this.FileName, e.Message );

                Trace( "[SIImageContent] RunDecompressor() - Exception - this: {0}, stack  : {1}", this.FileName, e.StackTrace );

                iDecompressionException = true;

            }

            // Doing this might cause the disposal of the object

            ReportDecompressionEvent( TDecompressionEvent.EEventDecompressionComplete );

            Trace( "[SIImageContent] RunDecompressor() - END - this: " + FileName );

        }

        private void WaitForAsyncOperationCompletion()

        {

            // If the worker doesn't exist then we've already completed the operation

            if ( iWaiter != null )

            {

                // Just wait on the auto-reset event. If it's already been signalled, then

                // we will continue immediately.

                iWaiter.WaitOne();

                // Must take the lock to either create or destroy waiter

                lock ( iWaiterSyncRoot )

                {

                    iWaiter.Close();

                    iWaiter = null;

                }

            }

        }

        private uint FixupAddress( uint aAddress )

        {

            uint ret = aAddress - iRelocationAddress;

            return ret;

        }

        #endregion

        #region From ITracer

        public void Trace( string aMessage )

        {

            iImage.Trace( aMessage );

        }

        public void Trace( string aFormat, params object[] aParams )

        {

            iImage.Trace( aFormat, aParams );

        }

        #endregion

        #region From DisposableObject

        protected override void CleanupManagedResources()

        {

            try

            {

                base.CleanupManagedResources();

            }

            finally

            {

                iImage.Remove( this );

                //

                if ( iWaiter != null )

                {

                    iWaiter.Set();

                    iWaiter.Close();

                    iWaiter = null;

                }

            }

        }

        #endregion

        #region From System.Object

        public override string ToString()

        {

            return FileName;

        }

        public override int GetHashCode()

        {

            return FileName.GetHashCode();

        }

        #endregion

        #region Data members

        private readonly SIImage iImage;

        private uint iRelocationAddress = 0;

        private bool iDecompressionException = false;

        private AutoResetEvent iWaiter = null;

        private object iWaiterSyncRoot = new object();

        #endregion

    }

}