using System;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;

namespace Implab.Components {
    /// <summary>
    /// Base class for implementing components which support start and stop operations,
    /// such components may represent running services.
    /// </summary>
    /// <remarks>
    /// This class provides a basic lifecycle from the creation to the
    /// termination of the component.
    /// </remarks>
    public class RunnableComponent : IRunnable, IInitializable, IDisposable {

        /// <summary>
        /// This class bounds <see cref="CancellationTokenSource"/> lifetime to the task,
        /// when the task completes the associated token source will be disposed.
        /// </summary>
        class AsyncOperationDescriptor {

            public static AsyncOperationDescriptor None { get; } = new AsyncOperationDescriptor();

            readonly CancellationTokenSource m_cts;

            bool m_done;

            public CancellationToken Token {
                get { return m_cts == null ? CancellationToken.None : m_cts.Token; }
            }

            public Task Task { get; private set; }

            private AsyncOperationDescriptor(Task task, CancellationTokenSource cts) {
                m_cts = cts;
                Task = Chain(task);
            }

            private AsyncOperationDescriptor() {
                Task = Task.CompletedTask;
            }

            public void Cancel() {
                if (m_cts != null) {
                    lock (m_cts) {
                        if (!m_done)
                            m_cts.Cancel();
                    }
                }
            }

            void Done() {
                if (m_cts != null) {
                    lock (m_cts) {
                        m_done = true;
                        m_cts.Dispose();
                    }
                } else {
                    m_done = true;
                }
            }

            async Task Chain(Task other) {
                try {
                    await other;
                } finally {
                    Done();
                }
            }

            public static AsyncOperationDescriptor Create(Func<CancellationToken, Task> factory, CancellationToken ct) {
                var cts = ct.CanBeCanceled ?
                    CancellationTokenSource.CreateLinkedTokenSource(ct) :
                    new CancellationTokenSource();

                return new AsyncOperationDescriptor(factory(cts.Token), cts);
            }

        }

        // this lock is used to synchronize state flow of the component during
        // completions or the operations.
        readonly object m_lock = new object();

        // current operation cookie, used to check wheather a call to
        // MoveSuccess/MoveFailed method belongs to the current
        // operation, if cookies didn't match ignore completion result.
        object m_cookie;

        AsyncOperationDescriptor m_current = AsyncOperationDescriptor.None;

        ExecutionState m_state;


        protected RunnableComponent(bool initialized) {
            State = initialized ? ExecutionState.Ready : ExecutionState.Created;
        }

        public Task Completion {
            get { return m_current.Task; }
        }

        public ExecutionState State {
            get { return m_state; }
            private set {
                if (m_state != value) {
                    m_state = value;
                    StateChanged.DispatchEvent(this, new StateChangeEventArgs {
                        State = value,
                        LastError = LastError
                    });
                }
            }
        }

        public Exception LastError { get; private set; }

        public event EventHandler<StateChangeEventArgs> StateChanged;

        /// <summary>
        /// Releases all resources used by the current component regardless of its
        /// execution state.
        /// </summary>
        /// <remarks>
        /// Calling to this method may result unexpedted results if the component
        /// isn't in the stopped state. Call this method after the component is
        /// stopped if needed or if the component is in the failed state.
        /// </remarks>
        public void Dispose() {
            bool dispose = false;
            if (dispose) {
                Dispose(true);
                GC.SuppressFinalize(this);
            }
        }

        ~RunnableComponent() {
            Dispose(false);
        }

        /// <summary>
        /// Releases all resources used by the current component regardless of its
        /// execution state.
        /// </summary>
        /// <param name="disposing">Indicates that the component is disposed
        /// during a normal disposing or during GC.</param>
        protected virtual void Dispose(bool disposing) {
        }

        public void Initialize() {
            var cookie = new object();
            if (MoveInitialize(cookie))
                ScheduleTask(InitializeInternalAsync, CancellationToken.None, cookie);
        }

        /// <summary>
        /// This method is used for initialization during a component creation.
        /// </summary>
        /// <param name="ct">A cancellation token for this operation</param>
        /// <remarks>
        /// This method should be used for short and mostly syncronous operations,
        /// other operations which require time to run shoud be placed in
        /// <see cref="StartInternalAsync(CancellationToken)"/> method.
        /// </remarks>
        protected virtual Task InitializeInternalAsync(CancellationToken ct) {
            return Task.CompletedTask;
        }

        public void Start(CancellationToken ct) {
            var cookie = new object();
            if (MoveStart(cookie))
                ScheduleTask(StartInternalAsync, ct, cookie);
        }

        protected virtual Task StartInternalAsync(CancellationToken ct) {
            return Task.CompletedTask;
        }

        public void Stop(CancellationToken ct) {
            var cookie = new object();
            if (MoveStop(cookie))
                ScheduleTask(StopAsync, ct, cookie);
        }

        async Task StopAsync(CancellationToken ct) {
            m_current.Cancel();
            await Completion;

            ct.ThrowIfCancellationRequested();

            await StopInternalAsync(ct);
        }

        protected virtual Task StopInternalAsync(CancellationToken ct) {
            return Task.CompletedTask;
        }


        #region state management

        bool MoveInitialize(object cookie) {
            lock (m_lock) {
                if (State != ExecutionState.Created)
                    return false;
                State = ExecutionState.Initializing;
                m_cookie = cookie;
                return true;
            }
        }

        bool MoveStart(object cookie) {
            lock (m_lock) {
                if (State != ExecutionState.Ready)
                    return false;
                State = ExecutionState.Starting;
                m_cookie = cookie;
                return true;
            }
        }

        bool MoveStop(object cookie) {
            lock (m_lock) {
                if (State != ExecutionState.Starting && State != ExecutionState.Running)
                    return false;
                State = ExecutionState.Stopping;
                m_cookie = cookie;
                return true;
            }
        }

        void MoveSuccess(object cookie) {
            lock (m_lock) {
                if (m_cookie != cookie)
                    return;
                switch (State) {
                    case ExecutionState.Initializing:
                        State = ExecutionState.Ready;
                        break;
                    case ExecutionState.Starting:
                        State = ExecutionState.Running;
                        break;
                    case ExecutionState.Stopping:
                        State = ExecutionState.Stopped;
                        break;
                }
            }
        }

        void MoveFailed(Exception err, object cookie) {
            lock (m_lock) {
                if (m_cookie != cookie)
                    return;
                LastError = err;
                State = ExecutionState.Failed;
            }
        }



        protected async void ScheduleTask(Func<CancellationToken, Task> next, CancellationToken ct, object cookie) {
            try {
                m_current = AsyncOperationDescriptor.Create(next, ct);
                await m_current.Task;
                MoveSuccess(cookie);
            } catch (Exception e) {
                MoveFailed(e, cookie);
            }
        }

        #endregion
    }
}