//******************************************************************************************************
//  TaskSynchronizedOperation.cs - Gbtc
//
//  Copyright © 2021, 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://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:
//  ----------------------------------------------------------------------------------------------------
//  02/26/2021 - Stephen C. Wills
//       Generated original version of source code.
//
//******************************************************************************************************

using System;
using System.Threading.Tasks;

namespace GSF.Threading
{
    /// <summary>
    /// Represents a task-based synchronized operation
    /// that cannot run while it is already in progress.
    /// </summary>
    /// <remarks>
    /// The action performed by the <see cref="TaskSynchronizedOperation"/> is executed using
    /// <see cref="Task.Run(Func{Task})"/>. Pending actions run when the task returned by the
    /// asynchronous action is completed. This synchronized operation only supports the async
    /// versions of the <see cref="ISynchronizedOperation"/> interface because the async action
    /// cannot be executed synchronously.
    /// </remarks>
    public class TaskSynchronizedOperation : ISynchronizedOperation
    {
        #region [ Members ]

        // Nested Types
        private class SynchronizedOperation : SynchronizedOperationBase
        {
            private Func<Task> AsyncAction { get; }
            private Action<Exception> ExceptionHandler { get; }

            public SynchronizedOperation(Func<Task> asyncAction, Action<Exception> exceptionHandler)
                : base(() => { })
            {
                if (asyncAction is null)
                    throw new ArgumentNullException(nameof(asyncAction));

                AsyncAction = asyncAction;
                ExceptionHandler = exceptionHandler;
            }

            protected override void ExecuteActionAsync()
            {
                _ = Task.Run(async () =>
                {
                    try { await AsyncAction(); }
                    catch (Exception ex) { TryHandleException(ex); }

                    if (ExecuteAction())
                        ExecuteActionAsync();
                });
            }

            private void TryHandleException(Exception ex)
            {
                try { ExceptionHandler?.Invoke(ex); }
                catch { /* No other way to handle exceptions at this point */ }
            }
        }

        #endregion

        #region [ Constructors ]

        /// <summary>
        /// Creates a new instance of the <see cref="TaskSynchronizedOperation"/> class.
        /// </summary>
        /// <param name="asyncAction">The action to be performed during this operation.</param>
        public TaskSynchronizedOperation(Func<Task> asyncAction)
            : this(asyncAction, null)
        {
        }

        /// <summary>
        /// Creates a new instance of the <see cref="TaskSynchronizedOperation"/> class.
        /// </summary>
        /// <param name="asyncAction">The action to be performed during this operation.</param>
        /// <param name="exceptionAction">The action to be performed if an exception is thrown from the action.</param>
        public TaskSynchronizedOperation(Func<Task> asyncAction, Action<Exception> exceptionAction) =>
            InternalSynchronizedOperation = new SynchronizedOperation(asyncAction, exceptionAction);

        #endregion

        #region [ Properties ]

        /// <summary>
        /// Gets a value to indicate whether the synchronized
        /// operation is currently executing its action.
        /// </summary>
        public bool IsRunning => InternalSynchronizedOperation.IsRunning;

        /// <summary>
        /// Gets a value to indiate whether the synchronized operation
        /// has an additional operation that is pending execution after
        /// the currently running action has completed.
        /// </summary>
        public bool IsPending => InternalSynchronizedOperation.IsPending;

        private SynchronizedOperation InternalSynchronizedOperation { get; }

        #endregion

        #region [ Methods ]

        /// <summary>
        /// Executes the action on another thread or marks the
        /// operation as pending if the operation is already running.
        /// </summary>
        /// <remarks>
        /// When the operation is marked as pending, it will run again after the
        /// operation that is currently running has completed. This is useful if
        /// an update has invalidated the operation that is currently running and
        /// will therefore need to be run again.
        /// </remarks>
        public void RunOnceAsync() =>
            InternalSynchronizedOperation.RunOnceAsync();

        /// <summary>
        /// Attempts to execute the action on another thread.
        /// Does nothing if the operation is already running.
        /// </summary>
        public void TryRunOnceAsync() =>
            InternalSynchronizedOperation.TryRunOnceAsync();

        void ISynchronizedOperation.Run() => RunOnceAsync();
        void ISynchronizedOperation.TryRun() => TryRunOnceAsync();
        void ISynchronizedOperation.RunOnce() => RunOnceAsync();
        void ISynchronizedOperation.TryRunOnce() => TryRunOnceAsync();

        #endregion
    }
}