//            Copyright Keysight Technologies 2012-2019
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Threading;

namespace OpenTap.Diagnostic
{
    /// <summary>
    /// Default timestamper.
    /// </summary>
    [Display("Local and Accurate", "Delivers timestamping that will be accurate to the system time over longer durations.")]
    public class AccurateStamper : ILogTimestampProvider
    {
        /// <summary> Prints a friendly name. </summary>
        /// <returns></returns>
        public override string ToString() => "Local and Accurate";
        long ILogTimestampProvider.Timestamp()
        {
            return DateTime.UtcNow.Ticks;
        }

        Stopwatch sw = Stopwatch.StartNew();
        long UtcOffset = TimeZoneInfo.Local.GetUtcOffset(DateTime.UtcNow).Ticks;
        const long ticksPerSecond = 10000000; // TimeSpan.FromSeconds(1).Ticks;
        long ILogTimestampProvider.ConvertToTicks(long timestamp)
        {
            if (sw.ElapsedTicks > ticksPerSecond)
            {
                UtcOffset = TimeZoneInfo.Local.GetUtcOffset(DateTime.UtcNow).Ticks;
                sw.Restart();
            }

            return (timestamp + UtcOffset);
        }
    }

    internal class LogContext : ILogContext, ILogContext2, IDisposable
    {
        
        readonly LogQueue LogQueue = new LogQueue();

        public bool HasListeners => listeners.Count > 0;

        readonly List<ILogListener> listeners = new List<ILogListener>();

        long processedMessages;
        long OutstandingMessages =>  LogQueue.PostedMessages - processedMessages;
        
        ILogTimestampProvider timeStamper = new AccurateStamper();
        
        readonly AutoResetEvent flushBarrier = new AutoResetEvent(false);

        readonly Thread processor;
        public LogContext(bool startProcessor = true)
        {
            if (startProcessor)
            {
                processor = new Thread(ProcessLog) { IsBackground = true, Name = "Log processing" };
                processor.Start();
            }
        }

        static LogContext EmptyLogContext()
        {
            return new LogContext(false);
        }

        readonly AutoResetEvent newEventOccured = new AutoResetEvent(false);

        void ProcessLog()
        {
            var copy = new List<ILogListener>();
            Event[] bunch = new Event[0];
            while (isDisposed == false)
            {
                newEventOccured.WaitOne();
                flushBarrier.WaitOne(100); // let things queue up unless flush is called.
                int count = LogQueue.DequeueBunch(ref bunch);

                if (count > 0)
                {
                    lock (listeners)
                    {
                        copy.Clear();
                        foreach (var thing in listeners)
                            copy.Add(thing);
                    }

                    if (copy.Count > 0)
                    {
                        if (timeStamper != null)
                            for (int i = 0; i < bunch.Length; i++)
                                bunch[i].Timestamp = timeStamper.ConvertToTicks(bunch[i].Timestamp);


                        foreach (var listener in copy)
                        {
                            try
                            {
                                using (var events = new EventCollection(bunch))
                                {
                                    listener.EventsLogged(events);
                                }
                            }
                            catch
                            {
                                // ignored
                            }
                        }
                    }

                    processedMessages += bunch.LongLength;    
                }
                
            }
        }

        public ILog CreateLog(string source)
        {
            return new Log(this, source);
        }

        public void RemoveLog(ILog logSource)
        {
            if (logSource is Log log)
                log.Context = EmptyLogContext();
        }

        public void AttachListener(ILogListener listener)
        {
            lock (listeners)
                listeners.Add(listener);
        }

        public void DetachListener(ILogListener listener)
        {
            lock (listeners)
                listeners.Remove(listener);
        }

        public ReadOnlyCollection<ILogListener> GetListeners()
        {
            return new ReadOnlyCollection<ILogListener>(listeners);
        }

        public bool Flush(int timeoutMs = 0)
        {
            if (isDisposed) return true;
            long posted = LogQueue.PostedMessages;

            flushBarrier.Set();
            newEventOccured.Set();

            if (timeoutMs == 0)
            {
                while (((processedMessages - posted)) < 0)
                {
                    Thread.Yield();
                    newEventOccured.Set();
                    flushBarrier.Set();
                }
                return true;
            }
            
            {
                var sw = Stopwatch.StartNew();

                while ((processedMessages - posted) < 0 && sw.ElapsedMilliseconds < timeoutMs)
                {
                    Thread.Yield();
                    newEventOccured.Set();
                    flushBarrier.Set();
                }

                return (processedMessages - posted) < 0;
            }
        }

        public bool Flush(TimeSpan timeout)
        {
            return Flush((int)timeout.TotalMilliseconds);
        }

        bool isDisposed;
        public void Dispose()
        {
            Flush();
            isDisposed = true;
            newEventOccured.Set();
            flushBarrier.Set();
        }

        public bool Async { get; set; }

        public int MessageBufferSize { get; set; }

        public ILogTimestampProvider Timestamper { get { return timeStamper; } set { timeStamper = value; } }


        void injectEvent(Event @event)
        {
            lock (listeners)
            {
                using (EventCollection eventCollection = new EventCollection(new [] { @event }))
                {
                    listeners.ForEach(l => l.EventsLogged(eventCollection));
                }
            }
        }
        
        public void AddEvent(Event evt)
        {
            if (Async)
            {
                int msgCnt = MessageBufferSize;
                if (msgCnt > 0)
                {
                    while (OutstandingMessages > msgCnt)
                        Thread.Sleep(1);
                }
                LogQueue.Enqueue(evt);
            }
            else
            {
                injectEvent(evt);
            }
            this.newEventOccured.Set();
        }

        internal class LogInjector
        {
            internal LogContext Context;
            public LogInjector(LogContext context) => Context = context;

            public void logEvent(Event evt) => Context.AddEvent(evt);
            
            public void LogEvent(string source, int eventType, string message)
            {
                if (Context.HasListeners)
                {
                    long timestamp = getTimestamp();
                    var evt = new Event(0, eventType, message, source, timestamp);
                    logEvent(evt);
                }
            }

            public void LogEvent(string source, int eventType, string message, params object[] args)
            {
                if (message == null)
                    throw new ArgumentNullException(nameof(message));
                if (args == null)
                    throw new ArgumentNullException(nameof(args));
                if (Context.HasListeners)
                {
                    var messageFmt = string.Format(message, args);
                    LogEvent(source, eventType, messageFmt);
                }
            }

            long getTimestamp()
            {
                long timestamp = 0;
                var timestamper = Context.Timestamper;
                if (timestamper != null)
                    timestamp = timestamper.Timestamp();
                return timestamp;
            }

            public void LogEvent(string source, int eventType, long durationNs, string message)
            {
                if (Context.HasListeners)
                {
                    long timestamp = getTimestamp();
                    var evt = new Event(durationNs, eventType, message, source, timestamp);
                    logEvent(evt);
                }
            }

            public void LogEvent(string source, int eventType, long durationNs, string message, params object[] args)
            {
                if (message == null)
                    throw new ArgumentNullException(nameof(message));
                if (args == null)
                    throw new ArgumentNullException(nameof(args));
                if (source == null)
                    throw new ArgumentNullException(nameof(source));
                if (Context.HasListeners)
                {
                    var messageFmt = string.Format(message, args);
                    LogEvent(source, eventType, durationNs, messageFmt);
                }
            }
        }
        
        internal class Log : LogInjector, ILog
        {
            private readonly string _source;

            public Log(LogContext context, string source) : base(context)
            {
                _source = source;
            }

            public void LogEvent(int eventType, string message)
            {
                LogEvent(_source, eventType, message);
            }

            public void LogEvent(int eventType, string message, params object[] args)
            {
                LogEvent(_source, eventType, message, args);
            }

            public void LogEvent(int eventType, long durationNs, string message)
            {
                LogEvent(_source, eventType, durationNs, message);
            }

            public void LogEvent(int eventType, long durationNs, string message, params object[] args)
            {
                LogEvent(_source, eventType, durationNs, message, args);
            }

            string ILog.Source =>  _source;
        }

        public long GetProcessedMessages() => processedMessages;
    }
}