using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Tango.Core.Threading
{
    /// <summary>
    /// Represents a message queue dispatcher for delivering messages at a constant interval.
    /// </summary>
    /// <typeparam name="TMessage"></typeparam>
    /// <seealso cref="System.IDisposable" />
    public class IntervalMessageDispatcher<TMessage> : IDisposable
    {
        private Thread _queueThread;
        private ProducerConsumerQueue<TMessage> _queue;
        private Action<TMessage> _onNext;
        private long _framesPushed;
        private long _framesDelivered;

        /// <summary>
        /// Gets or sets the interval.
        /// </summary>
        public int Interval { get; set; }

        /// <summary>
        /// Gets or sets the drift compensation interval in milliseconds.
        /// Meaning, when frames are pushed in a faster rate than delivery interval.
        /// This will trigger a compensation mechanism which will deliver frames faster until it reaches balance
        /// Between pushed and delivered frames.
        /// </summary>
        public int? DriftCompensationInterval { get; set; }

        /// <summary>
        /// Gets or sets the maximum frames count for drift compensation calculation (default 100).
        /// </summary>
        public int MaximumFramesForDriftCompensation { get; set; }

        /// <summary>
        /// Gets or sets the maximum allowed drift before starting to balance 0-1. default 0.1.
        /// </summary>
        public double MaximumDrift { get; set; }

        /// <summary>
        /// Gets a value indicating whether this instance has started.
        /// </summary>
        public bool IsStarted { get; private set; }

        /// <summary>
        /// Gets the number of queued messages.
        /// </summary>
        public int Count
        {
            get { return _queue.Count; }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="IntervalMessageDispatcher{T}"/> class.
        /// </summary>
        /// <param name="onNext">The delivery callback.</param>
        public IntervalMessageDispatcher(Action<TMessage> onNext)
        {
            _onNext = onNext;
            _queue = new ProducerConsumerQueue<TMessage>();
            MaximumDrift = 0.1;
            MaximumFramesForDriftCompensation = 100;
        }

        /// <summary>
        /// Starts the dispatching of messages.
        /// </summary>
        public void Start()
        {
            if (!IsStarted)
            {
                _framesPushed = 0;
                _framesDelivered = 0;
                IsStarted = true;
                _queueThread = new Thread(QueueThreadMethod);
                _queueThread.Name = "Sequencer Thread";
                _queueThread.IsBackground = true;
                _queueThread.Start();
            }
        }

        /// <summary>
        /// Pushes the specified message.
        /// </summary>
        /// <param name="message">The message.</param>
        public void Push(TMessage message)
        {
            _framesPushed++;
            _queue.BlockEnqueue(message);
        }

        private void QueueThreadMethod()
        {
            DateTime lastDriftCompensation = DateTime.Now;
            double requiredDriftCompensation = 0;
            bool balancing = false;
            double balancingFactor = 1;


            Stopwatch watch = new Stopwatch();
            watch.Start();

            while (IsStarted)
            {
                var item = _queue.BlockDequeue();

                if (!IsStarted) break;

                watch.Restart();

                try
                {
                    _onNext?.Invoke(item);
                    _framesDelivered++;
                }
                catch { }

                //Compensate drift between pushed frames and delivered frames if any.
                if (DriftCompensationInterval.HasValue)
                {
                    if (balancing || (DateTime.Now - lastDriftCompensation).TotalMilliseconds > DriftCompensationInterval)
                    {
                        lastDriftCompensation = DateTime.Now;

                        if (_framesPushed > MaximumFramesForDriftCompensation)
                        {
                            var reduction = _framesPushed - MaximumFramesForDriftCompensation;
                            _framesPushed = MaximumFramesForDriftCompensation;
                            _framesDelivered = _framesDelivered - reduction;
                        }

                        requiredDriftCompensation = (double)(_framesDelivered / _framesPushed);

                        if (1d - requiredDriftCompensation >= MaximumDrift)
                        {
                            balancing = true;
                            balancingFactor = Math.Max(0, balancingFactor - 0.1);
                        }
                        else
                        {
                            balancing = false;
                            balancingFactor = 1;
                        }

                        //Debug.WriteLine($"Frames Pushed: {_framesPushed}, Frames Delivered: {_framesDelivered}, Required Compensation: {requiredDriftCompensation}, Balancing: {balancing}, Balancing Factor: {balancingFactor}");
                        //Debug.WriteLine("Sleep before: " + (int)(Interval - watch.ElapsedMilliseconds));
                        //Debug.WriteLine("Sleep After: " + (int)((Interval - watch.ElapsedMilliseconds) * requiredDriftCompensation * balancingFactor));
                    }
                }

                Thread.Sleep(Math.Max(0, (int)((Interval - watch.ElapsedMilliseconds) * requiredDriftCompensation * balancingFactor)));
            }
        }

        /// <summary>
        /// Releases unmanaged and - optionally - managed resources.
        /// </summary>
        public void Dispose()
        {
            IsStarted = false;
        }

        /// <summary>
        /// Creates a new instance of <see cref="IntervalMessageDispatcher{T}"/> and starts it immediately.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="onNext">The on next.</param>
        /// <param name="interval">The interval.</param>
        /// <returns></returns>
        public static IntervalMessageDispatcher<T> StartNew<T>(Action<T> onNext, int interval)
        {
            IntervalMessageDispatcher<T> dispatcher = new IntervalMessageDispatcher<T>(onNext);
            dispatcher.Interval = interval;
            dispatcher.Start();
            return dispatcher;
        }
    }
}