//******************************************************************************************************
//  ProcessProgressHandler.cs - Gbtc
//
//  Copyright © 2012, Grid Protection Alliance.  All Rights Reserved.
//
//  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See
//  the NOTICE file distributed with this work for additional information regarding copyright ownership.
//  The GPA licenses this file to you under the MIT License (MIT), the "License"; you may
//  not use this file except in compliance with the License. You may obtain a copy of the License at:
//
//      http://www.opensource.org/licenses/MIT
//
//  Unless agreed to in writing, the subject software distributed under the License is distributed on an
//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the
//  License for the specific language governing permissions and limitations.
//
//  Code Modification History:
//  ----------------------------------------------------------------------------------------------------
//  11/04/2008 - J. Ritchie Carroll
//       Generated original version of source code.
//  09/14/2009 - Stephen C. Wills
//       Added new header and license agreement.
//  12/14/2012 - Starlynn Danyelle Gilliam
//       Modified Header.
//
//******************************************************************************************************

using System;

namespace GSF
{
    /// <summary>
    /// Defines a delegate handler for a <see cref="GSF.ProcessProgress{TUnit}"/> instance.
    /// </summary>
    /// <remarks>
    /// <para>
    /// This handler is used by methods with an <see cref="Action"/> delegate parameter (e.g., Action&lt;ProcessProgress&lt;long&gt;&gt;)
    /// providing a simple callback mechanism for reporting progress on a long operation.
    /// </para>
    /// <para>
    /// Examples include:
    /// <see cref="GSF.IO.Compression.CompressionExtensions.Compress(System.IO.Stream,System.IO.Stream,GSF.IO.Compression.CompressionStrength,Action{GSF.ProcessProgress{long}})"/>, 
    /// <see cref="GSF.Security.Cryptography.Cipher.Encrypt(System.IO.Stream,System.IO.Stream,byte[],byte[],GSF.Security.Cryptography.CipherStrength,Action{GSF.ProcessProgress{long}})"/> and
    /// <see cref="GSF.Security.Cryptography.Cipher.Decrypt(System.IO.Stream,System.IO.Stream,byte[],byte[],GSF.Security.Cryptography.CipherStrength,Action{GSF.ProcessProgress{long}})"/>
    /// </para>
    /// </remarks>
    /// <typeparam name="TUnit">Unit of progress used (long, double, int, etc.)</typeparam>
    public class ProcessProgressHandler<TUnit> where TUnit : struct
    {
        #region [ Members ]

        // Fields
        private Action<ProcessProgress<TUnit>> m_progressHandler;
        private readonly ProcessProgress<TUnit> m_progressInstance;

        #endregion

        #region [ Constructors ]

        /// <summary>
        /// Constructs a new process progress handler for the specified parameters.
        /// </summary>
        /// <param name="progressHandler">Delegate callback to invoke as process progresses.</param>
        /// <param name="processName">Descriptive name of process, if useful.</param>
        public ProcessProgressHandler(Action<ProcessProgress<TUnit>> progressHandler, string processName)
        {
            m_progressHandler = progressHandler;
            m_progressInstance = new ProcessProgress<TUnit>(processName);
        }

        /// <summary>
        /// Constructs a new process progress handler for the specified parameters.
        /// </summary>
        /// <param name="progressHandler">Delegate callback to invoke as process progresses.</param>
        /// <param name="processName">Descriptive name of process, if useful.</param>
        /// <param name="total">Total number of units to be processed.</param>
        public ProcessProgressHandler(Action<ProcessProgress<TUnit>> progressHandler, string processName, TUnit total)
            : this(progressHandler, processName)
        {
            m_progressInstance.Total = total;
        }

        #endregion

        #region [ Properties ]

        /// <summary>
        /// Gets instance of <see cref="GSF.ProcessProgress{TUnit}"/> used to track progress for this handler.
        /// </summary>
        public ProcessProgress<TUnit> ProcessProgress
        {
            get
            {
                return m_progressInstance;
            }
        }

        /// <summary>
        /// Gets or sets reference to delegate handler used as a callback to report process progress.
        /// </summary>
        public Action<ProcessProgress<TUnit>> ProgressHandler
        {
            get
            {
                return m_progressHandler;
            }
            set
            {
                m_progressHandler = value;
            }
        }

        /// <summary>
        /// Gets or sets current process progress (i.e., number of units completed processing so far) - note that when this
        /// property value is assigned, the callback function is automatically called with updated <see cref="GSF.ProcessProgress{TUnit}"/>
        /// instance so consumer can track progress.
        /// </summary>
        /// <value>Number of units completed processing so far.</value>
        public TUnit Complete
        {
            get
            {
                return m_progressInstance.Complete;
            }
            set
            {
                UpdateProgress(value);
            }
        }

        /// <summary>
        /// Gets or sets total number of units to be processed.
        /// </summary>
        public TUnit Total
        {
            get
            {
                return m_progressInstance.Total;
            }
            set
            {
                m_progressInstance.Total = value;
            }
        }

        #endregion

        #region [ Methods ]

        /// <summary>
        /// Calls callback function with updated <see cref="GSF.ProcessProgress{TUnit}"/> instance so consumer can track progress.
        /// </summary>
        /// <param name="completed">Number of units completed processing so far.</param>
        /// <remarks>
        /// Note that assigning a value to the <see cref="Complete"/> property will have the same effect as calling this method.
        /// </remarks>
        public void UpdateProgress(TUnit completed)
        {
            // Update bytes completed
            m_progressInstance.Complete = completed;

            // Call user function
            m_progressHandler(m_progressInstance);
        }

        #endregion
    }
}