/*

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

using SymbianUtils.Tracer;

namespace SymbianUtils.SerializedOperations

{

    public class SerializedOperationManager : DisposableObject, ITracer

    {

        #region Enumerations

        public enum TState

        {

            EStateOperationsStarted = 0,

            EStateOperationsSuspended,

            EStateOperationsCompleted

        }

        #endregion

        #region Delegates & events

        public delegate void QueueStateHandler( TState aState );

        public event QueueStateHandler StateHandler;

        #endregion

        #region Constructors

        public SerializedOperationManager()

            : this( null )

        {

        }

        public SerializedOperationManager( ITracer aTracer )

        {

            iTracer = aTracer;

        }

        #endregion

        #region API

        public virtual void Clear()

        {

            lock ( iQueue )

            {

                Stop();

                iQueue.Clear();

            }

        }

        public void Start()

        {

            Enabled = true;

            StartNextOperation();

        }

        public void Stop()

        {

            Enabled = false;

        }

        public void Queue( SerializedOperation aOperation )

        {

            Trace( "Queue() - START - enabled: {0}, count: {1}, OpInProg: {2}", Enabled, iQueue.Count, OperationInProgress );

            lock ( iQueue )

            {

                Trace( "Queue() - aOperation.Enabled: {0}, aOperation: {1}", aOperation.Enabled, aOperation.GetType().Name );

                aOperation.OperationManager = this;

                iQueue.Add( aOperation );

                // Sort the list so that the highest priority item is first

                Comparison<SerializedOperation> sortByPriority = delegate( SerializedOperation aLeft, SerializedOperation aRight )

                {

                    // We want highest-to-lowest sort order

                    int ret = aLeft.CompareTo( aRight );

                    return ret * -1;

                };

                iQueue.Sort( sortByPriority );

                Trace( "Queue() - {{{0}}} - Queue now contains {1} entries, amEnabled: {2}", aOperation.GetType(), Count, Enabled );

            }

            StartNextOperation();

            Trace( "Queue() - END - enabled: {0}, count: {1}, OpInProg: {2}", Enabled, iQueue.Count, OperationInProgress );

            Trace( "" );

            Trace( "" );

        }

        #endregion

        #region Properties

        public int Count

        {

            get

            {

                lock( iQueue )

                {

                    return iQueue.Count;

                }

            }

        }

        public bool Enabled

        {

            get { return iEnabled; }

            private set

            {

                lock ( iEnabledLock )

                {

                    if ( iEnabled != value )

                    {

                        Trace( "Enabled - current value: {0}, new value: {1}", iEnabled, value );

                        iEnabled = value;

                        //

                        TState e = value ? TState.EStateOperationsStarted : TState.EStateOperationsSuspended;

                        if ( StateHandler != null )

                        {

                            StateHandler( e );

                        }

                    }

                }

            }

        }

        public ITracer Tracer

        {

            get

            {

                ITracer ret = this;

                //

                if ( iTracer != null )

                {

                    ret = iTracer;

                }

                //

                return ret;

            }

            set { iTracer = value; }

        }

        public bool OperationInProgress

        {

            get

            {

                lock ( iQueue )

                {

                    return iPendingOperation;

                }

            }

            private set

            {

                lock ( iQueue )

                {

                    iPendingOperation = value;

                }

            }

        }

        public bool IsCompleteAndIdle

        {

            get

            {

                bool ret = false;

                //

                lock ( iQueue )

                {

                    int enabledCount = OperationCountEnabled;

                    if ( Enabled == false )

                    {

                        // To be complete when we are disabled, then there must be

                        // no items that are ready to run.

                        ret = ( enabledCount == 0 );

                    }

                    else

                    {

                        // If we are enabled, then we are complete when there are

                        // no more enabled items left to run.

                        ret = ( enabledCount == 0 );

                    }

                }

                //

                return ret;

            }

        }

        #endregion

        #region ITracer Members

        public void Trace( string aMessage )

        {

            if ( iTracer != null )

            {

                iTracer.Trace( "[" + this.GetType().Name + "] " + aMessage );

            }

        }

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

        {

            if ( iTracer != null )

            {

                string text = string.Format( aFormat, aParams );

                iTracer.Trace( "[" + this.GetType().Name + "] {0}", text );

            }

        }

        #endregion

        #region Internal methods

        internal void OnOperationEnabledStatusChanged( SerializedOperation aOperation )

        {

            StartNextOperation();

        }

        internal void OperationCompleted( SerializedOperation aOperation )

        {

            OperationInProgress = false;

            Trace( "OpComplete() - Operation completed {{{0}}}, queue contains {1} more entries, amEnabled: {2}", aOperation.GetType(), Count, Enabled );

            //

            StartNextOperation();

        }

        private void StartNextOperation()

        {

            TraceQueue( string.Format( "StartNextOperation() - START - Enabled: {0}", Enabled ) );

            lock ( iQueue )

            {

                Trace( "StartNextOperation() - count: {0}, OpInProg: {1}", iQueue.Count, OperationInProgress );

                bool enabled = Enabled;

                if ( enabled )

                {

                    if ( OperationInProgress )

                    {

                        Trace( "StartNextOperation() - Already running operation!" );

                    }

                    else

                    {

                        SerializedOperation op = FindNextOp();

                        if ( op != null )

                        {

                            iQueue.Remove( op );

                            //

                            Trace( string.Empty );

                            Trace( string.Empty );

                            Trace( "StartNextOperation() - ****************************************************************************" );

                            Trace( "StartNextOperation() - starting op: {0}/{1} [{2}]", 1, iQueue.Count + 1, op.GetType() + " - " + op.ToString() );

                            Trace( "StartNextOperation() - ****************************************************************************" );

                            //

                            op.Start();

                            OperationInProgress = true;

                        }

                        else

                        {

                            Trace( "StartNextOperation() - Queue is empty or no enabled items!" );

                            if ( StateHandler != null )

                            {

                                StateHandler( TState.EStateOperationsCompleted );

                            }

                        }

                    }

                }

                else

                {

                    Trace( "StartNextOperation() - Queue is disabled!" );

                }

            }

            Trace( "StartNextOperation() - END - count: {0}, OpInProg: {1}, Enabled: {2}", iQueue.Count, OperationInProgress, Enabled );

            Trace( "" );

        }

        private void TraceQueue( string aFrom )

        {

            StringBuilder text = new StringBuilder();

            text.AppendLine( string.Format( "========================== {0} ==========================", aFrom ) );

            text.AppendLine( string.Format( "opInPrgress: {0}", OperationInProgress ) );

            text.AppendLine( string.Format( "enabled:     {0}", Enabled ) );

            //

            lock ( iQueue )

            {

                int count = iQueue.Count;

                text.AppendLine( string.Format( "count:       {0}", count ) );

                text.AppendLine( "" );

                int i = 1;

                foreach ( SerializedOperation op in iQueue )

                {

                    text.AppendLine( string.Format( "[{0:d2}/{1:d2}] enabled: {2}, busy: {3}, pri: {4:d10}, name: {5}", i, count, System.Convert.ToInt32( op.Enabled ), System.Convert.ToInt32( op.IsBusy ), op.Priority, op.ToString() ) );

                    ++i;

                }

            }

            //

            text.AppendLine( "" );

            text.AppendLine( "" );

            //

            Trace( text.ToString() );

        }

        private SerializedOperation FindNextOp()

        {

            TraceQueue( "FindNextOp()" );

            SerializedOperation ret = null;

            //

            foreach ( SerializedOperation op in iQueue )

            {

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

                if ( op.Enabled )

                {

                    ret = op;

                    break;

                }

            }

            //

            return ret;

        }

        private int OperationCountEnabled

        {

            get

            {

                int ret = 0;

                //

                lock ( iQueue )

                {

                    Action<SerializedOperation> act = delegate(SerializedOperation op ) 

                    {

                        if ( op.Enabled ) 

                        { 

                            ++ret;

                        }

                    };

                    iQueue.ForEach( act ); 

                }

                //

                return ret;

            }

        }

        private int OperationCountDisabled

        {

            get

            {

                int ret = 0;

                //

                lock ( iQueue )

                {

                    Action<SerializedOperation> act = delegate( SerializedOperation op )

                    {

                        if ( !op.Enabled )

                        {

                            ++ret;

                        }

                    };

                    iQueue.ForEach( act );

                }

                //

                return ret;

            }

        }

        #endregion

        #region Data members

        private ITracer iTracer;

        private List<SerializedOperation> iQueue = new List<SerializedOperation>();

        private bool iPendingOperation = false;

        private bool iEnabled = false;

        private object iEnabledLock = new object();

        #endregion

    }

}