/*

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

using System.ComponentModel;

namespace SymbianUtils.SerializedOperations

{

    public abstract class SerializedOperation : DisposableObject, IComparable<SerializedOperation>

    {

        #region Delegates & events

        public delegate void EventHandler( SerializedOperation aOperation );

        public event EventHandler Started;

        public event EventHandler Completed;

        #endregion

        #region Constructors

        protected SerializedOperation()

            : this( true )

        {

        }

        protected SerializedOperation( bool aEnabled )

        {

            Enabled = aEnabled;

            //

            iWorker.DoWork += new DoWorkEventHandler( DoWork );

        }

        #endregion

        #region Framework API

        protected abstract void PerformOperation();

        public virtual long Priority

        {

            get { return 0; }

        }

        #endregion

        #region API

        public void EnableAndWait()

        {

            Trace( "[{0}] EnableAndWait() - START - enabled: {1}, busy: {2}", this.GetType().Name, Enabled, IsBusy );

            System.Diagnostics.Debug.Assert( Enabled == false );

            System.Diagnostics.Debug.Assert( !IsBusy );

            if ( IsBusy )

            {

                while ( IsBusy )

                {

                    Trace( "[{0}] EnableAndWait() - still busy?: {1}", this.GetType().Name, IsBusy );

                    Thread.Sleep( 10 );

                }

            }

            else

            {

                SymbianUtils.SymDebug.SymDebugger.Assert( iWaitForCompletion == null );

                using ( iWaitForCompletion = new AutoResetEvent( false ) )

                {

                    // Enable the operation

                    Trace( "[{0}] EnableAndWait() - enabling item...", this.GetType().Name );

                    Enabled = true;

                    // And now block until it completes

                    Trace( "[{0}] EnableAndWait() - sleeping...", this.GetType().Name );

                    iWaitForCompletion.WaitOne();

                    Trace( "[{0}] EnableAndWait() - slept!", this.GetType().Name );

                }

            }

            Trace( "[{0}] EnableAndWait() - END", this.GetType().Name );

        }

        #endregion

        #region Properties

        public object Tag

        {

            get { return iTag; }

            set { iTag = value; }

        }

        public bool IsBusy

        {

            get { return iWorker.IsBusy; }

        }

        public bool Enabled

        {

            get { return iEnabled; }

            set

            {

                lock ( iEnabledLock )

                {

                    if ( value != iEnabled )

                    {

                        iEnabled = value;

                        if ( OperationManager != null )

                        {

                            OperationManager.OnOperationEnabledStatusChanged( this );

                        }

                    }

                }

            }

        }

        internal SerializedOperationManager OperationManager

        {

            get { return iManager; }

            set { iManager = value; }

        }

        #endregion

        #region Event handlers

        private void DoWork( object aSender, DoWorkEventArgs aArgs )

        {

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

            NotifyStarted();

            //

            try

            {

                PerformOperation();

            }

            catch ( Exception opException )

            {

                OperationManager.Trace( string.Format( "OPERATION EXCEPTION MSG - op: {0} ({1}) - msg: {2}", this.ToString(), this.GetType(), opException.Message ) );

                OperationManager.Trace( string.Format( "OPERATION EXCEPTION STK       {0}", opException.StackTrace ) );

            }

            //

            NotifyCompleted();

        }

        private void WorkerCompleted()

        {

            Trace( "[{0}] WorkerCompleted() - START", this.GetType().Name );

            //

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

            OperationManager.OperationCompleted( this );

            //

            if ( iWaitForCompletion != null )

            {

                Trace( "[{0}] WorkerCompleted() - unblocking main thread...", this.GetType().Name );

                iWaitForCompletion.Set();

            }

            //

            Trace( "[{0}] WorkerCompleted() - END", this.GetType().Name );

        }

        #endregion

        #region Internal methods

        protected void Trace( string aMessage )

        {

            iManager.Trace( aMessage );

        }

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

        {

            iManager.Trace( aFormat, aParams );

        }

        internal void Start()

        {

            Start( null );

        }

        internal void Start( object aParameter )

        {

            System.Diagnostics.Debug.Assert( Enabled );

            iWorker.RunWorkerAsync( aParameter );

        }

        private void NotifyStarted()

        {

            try

            {

                if ( Started != null )

                {

                    Started( this );

                }

            }

            catch ( Exception )

            {

            }

        }

        private void NotifyCompleted()

        {

            try

            {

                if ( Completed != null )

                {

                    Completed( this );

                }

                try

                {

                    WorkerCompleted();

                }

                catch ( Exception )

                {

                }

            }

            catch ( Exception )

            {

            }

        }

        #endregion

        #region From IComparable<SerializedOperation>

        public int CompareTo( SerializedOperation aOther )

        {

            int ret = 1;

            //

            if ( aOther != null )

            {

                ret = this.Priority.CompareTo( aOther.Priority );

            }

            //

            return ret;

        }

        #endregion

        #region From DisposableObject

        protected override void CleanupManagedResources()

        {

            try

            {

                base.CleanupManagedResources();

            }

            finally

            {

                if ( iWaitForCompletion != null )

                {

                    iWaitForCompletion.Close();

                    iWaitForCompletion = null;

                }

                if ( iWorker != null )

                {

                    iWorker.Dispose();

                    iWorker = null;

                }

            }

        }

        #endregion

        #region From System.Object

        public override string ToString()

        {

            return this.GetType().Name;

        }

        #endregion

        #region Data members

        private object iTag = null;

        private object iEnabledLock = new object();

        private bool iEnabled = true;

        private SerializedOperationManager iManager = null;

        private BackgroundWorker iWorker = new BackgroundWorker();

        private AutoResetEvent iWaitForCompletion = null;

        #endregion

    }

}