using System;
using System.Threading;
using Implab.Diagnostics;

namespace Implab.Components {
    public class PollingComponent : RunnableComponent {
        readonly Timer m_timer;
        readonly Func<Func<ICancellationToken, IPromise>, IPromise> m_dispatcher;
        readonly TimeSpan m_interval;

        readonly object m_lock = new object();

        ActionTask m_pending;

        protected PollingComponent(TimeSpan interval, Func<Func<ICancellationToken, IPromise>, IPromise> dispatcher, bool initialized) : base(initialized) {
            m_timer = new Timer(OnInternalTick);

            m_interval = interval;
            m_dispatcher = dispatcher;
        }

        protected override IPromise OnStart() {
            m_timer.Change(TimeSpan.Zero, m_interval);

            return base.OnStart();
        }

        void OnInternalTick(object state) {
            if (StartTick()) {
                try {
                    if (m_dispatcher != null) {
                        var result = m_dispatcher(OnTick);
                        m_pending.CancellationRequested(result.Cancel);
                        AwaitTick(result);
                    } else {
                        AwaitTick(OnTick(m_pending));
                    }
                } catch (Exception error) {
                    HandleTickError(error);
                }
            }   
        }

        /// <summary>
        /// Checks wheather there is no running handler in the component and marks that the handler is starting.
        /// </summary>
        /// <returns>boolean value, true - the new tick handler may be invoked, false - a tick handler is already running or a component isn't running.</returns>
        /// <remarks>
        /// If the component is stopping no new handlers can be run. Every successful call to this method must be completed with either AwaitTick or HandleTickError handlers.
        /// </remarks>
        protected virtual bool StartTick() {
            lock (m_lock) {
                if (State != ExecutionState.Running || m_pending != null)
                    return false;
                // actually the component may be in a not running state here (stopping, disposed or what ever),
                // but OnStop method also locks on the same object and will handle operation in m_pending
                m_pending = new ActionTask(
                    () => {
                        // only one operation is running, it's safe to assing m_pending from it
                        m_pending = null;
                    },
                    ex => {
                        try {
                            OnTickError(ex);
                            // Analysis disable once EmptyGeneralCatchClause
                        } catch {
                        } finally {
                            m_pending = null;
                        }
                        // suppress error
                    },
                    ex => {
                        try {
                            OnTickCancel(ex);
                            // Analysis disable once EmptyGeneralCatchClause
                        } catch {
                        } finally {
                            m_pending = null;
                        }
                        // supress cancellation
                    },
                    false
                );
                return true;
            }
        }

        /// <summary>
        /// Awaits the tick.
        /// </summary>
        /// <param name="tick">Tick.</param>
        /// <remarks>
        /// This method is called only after StartTick method and m_pending will hold the promise which should be fulfilled.
        /// </remarks>
        void AwaitTick(IPromise tick) {
            if (tick == null) {
                m_pending.Resolve();
            } else {
                tick.On(
                    m_pending.Resolve,
                    m_pending.Reject,
                    m_pending.CancelOperation
                );
            }
        }

        /// <summary>
        /// Handles the tick error.
        /// </summary>
        /// <remarks>
        /// This method is called only after StartTick method and m_pending will hold the promise which should be fulfilled.
        /// </remarks>
        void HandleTickError(Exception error) {
            m_pending.Reject(error);
        }

        protected virtual void OnTickError(Exception error) {
        }

        protected virtual void OnTickCancel(Exception error) {
        }

        /// <summary>
        /// Invoked when the timer ticks, use this method to implement your logic
        /// </summary>
        protected virtual IPromise OnTick(ICancellationToken cancellationToken) {
            return Promise.Success;
        }

        protected override IPromise OnStop() {
            m_timer.Change(-1, -1);

            // the component is in the stopping state
            lock (m_lock) {
                // after this lock no more pending operations could be created
                var pending = m_pending;
                // m_pending could be fulfilled and set to null already
                if (pending != null) {
                    pending.Cancel();
                    return pending.Then(base.OnStop);
                }
            }

            return base.OnStop();
        }

        protected override void Dispose(bool disposing, Exception lastError) {
            if (disposing)
                Safe.Dispose(m_timer);
            
            base.Dispose(disposing, lastError);
        }
    }
}