/*

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

using System.Text;

using System.Threading;

using System.Collections;

using SymbianUtils.Tracer;

namespace SymbianUtils

{

	public abstract class AsyncReaderBase : DisposableObject, ITracer

	{

		#region Events

		public enum TEvent

		{

			EReadingStarted = 0,

			EReadingProgress,

			EReadingComplete

		}

		public delegate void Observer( TEvent aEvent, AsyncReaderBase aSender );

		public event Observer iObserver;

        public delegate void ExceptionHandler( Exception aException, AsyncReaderBase aSender );

        public event ExceptionHandler iExceptionHandler;

        #endregion

		#region Construct & destruct

        protected AsyncReaderBase()

            : this( null )

        {

        }

		protected AsyncReaderBase( ITracer aTracer )

		{

            iTracer = aTracer;

            // Make sure the thread has a unique name...

            iWorkerThread = new Thread( new System.Threading.ThreadStart( WorkerThreadFunction ) );

            iWorkerThread.Name = "WorkerThreadFunction_" + SymbianUtils.Strings.StringUtils.MakeRandomString();

			iWorkerThread.Priority = System.Threading.ThreadPriority.BelowNormal;

			iWorkerThread.IsBackground = true;

		}

		#endregion

		#region API

        protected virtual void StartRead( TSynchronicity aSynchronicity )

        {

            switch ( aSynchronicity )

            {

            default:

            case TSynchronicity.EAsynchronous:

                AsyncRead();

                break;

            case TSynchronicity.ESynchronous:

                SyncRead();

                break;

            }

        }

		protected virtual void AsyncRead()

		{

			lock( this )

			{

				iWorkerThread.Start();

			}

		}

        protected virtual void SyncRead()

		{

			WorkerThreadFunction();

		}

		#endregion

		#region From DisposableObject - Cleanup Framework

		protected override void CleanupManagedResources()

		{

            try

            {

            }

            finally

            {

                base.CleanupManagedResources();

            }

		}

		protected override void CleanupUnmanagedResources()

		{

            try

            {

            }

            finally

            {

                base.CleanupUnmanagedResources();

            }

		}

		#endregion

		#region Properties

		public bool IsReady

		{

			get

			{

				lock(this)

				{

					return iReady;

				}

			}

		}

		public int Progress

		{

			get

			{

				lock(this)

				{

					int progress = 0;

					//

					if	( Size == 0 )

					{

						progress = 0;

					}

					else

					{

						progress = CalculateProgress();

					}

					//

					return progress;

				}

			}

		}

        public object Tag

        {

            get { return iTag; }

            set { iTag = value; }

        }

		#endregion

		#region Read handlers

		protected virtual void HandleReadStarted()

		{

		}

		protected virtual void HandleReadCompleted()

		{

		}

		protected virtual void HandleReadException( Exception aException )

		{

            if  ( iExceptionHandler != null )

            {

                iExceptionHandler( aException, this );

            }

		}

		#endregion

		#region Abstract reading framework

		protected abstract void PerformOperation();

		protected abstract long Size { get; }

		protected abstract long Position { get; }

		#endregion

		#region Framework methods

		protected virtual int CalculateProgress()

		{

			float positionAsFloat = (float)Position;

			float sizeAsFloat = (float)Size;

			int progress = (int)((positionAsFloat / sizeAsFloat) * 100.0);

			//

			return System.Math.Max(1, System.Math.Min(100, progress));

		}

		protected virtual void NotifyEvent( TEvent aEvent )

		{

            // Prevents reporting the same progress repeatedly...

            if ( aEvent == TEvent.EReadingProgress )

            {

                int progress = Progress;

                if ( progress == iLastProgress )

                {

                    return;

                }

                iLastProgress = progress;

            }

			if	( iObserver != null )

			{

				iObserver( aEvent, this );

			}

		}

		#endregion

		#region Internal methods

		private void WorkerThreadFunction()

		{

			try

			{

				lock( this )

				{

                    iLastProgress = -1;

					iReady = false;

					HandleReadStarted();

					NotifyEvent( TEvent.EReadingStarted );

				}

                // Record start time

                iOperationStartTime = DateTime.Now;

                PerformOperation();

			}

			catch( Exception exception )

			{

				lock( this )

				{

					HandleReadException( exception );

				}

			}

			finally

			{

				Dispose();

				//

				lock( this )

				{

					try

					{

						HandleReadCompleted();

					}

					catch( Exception exception )

					{

						HandleReadException( exception );

					}

					iReady = true;

					NotifyEvent( TEvent.EReadingComplete );

				}

			}

		}

		#endregion

        #region ITracer Members

        public void Trace( string aMessage )

        {

            if ( iTracer != null )

            {

                iTracer.Trace( aMessage );

            }

        }

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

        {

            Trace( string.Format( aFormat, aParams ) );

        }

        #endregion

        #region Internal data members

        protected bool iReady = true;

        protected DateTime iOperationStartTime;

        #endregion

        #region Data members

        private readonly ITracer iTracer;

        private readonly Thread iWorkerThread;

        private object iTag = null;

        private int iLastProgress = -1;

		#endregion

    }

}