//******************************************************************************************************
//  LoggerInternal.cs - Gbtc
//
//  Copyright © 2016, 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 Eclipse Public License -v 1.0 (the "License"); you may
//  not use this file except in compliance with the License. You may obtain a copy of the License at:
//
//      http://www.opensource.org/licenses/eclipse-1.0.php
//
//  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:
//  ----------------------------------------------------------------------------------------------------
//  10/24/2016 - Steven E. Chisholm
//       Generated original version of source code. 
//       
//
//******************************************************************************************************

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using GSF.Collections;
using GSF.Threading;

namespace GSF.Diagnostics
{
    /// <summary>
    /// The fundamental functionality of <see cref="Logger"/>.
    /// </summary>
    internal class LoggerInternal
        : IDisposable
    {
        private bool m_disposing;
        private readonly object m_syncRoot;
        private readonly Dictionary<Type, LogPublisherInternal> m_typeIndexCache;
        private readonly List<LogPublisherInternal> m_allPublishers;
        private readonly List<NullableWeakReference> m_subscribers;
        private readonly ConcurrentQueue<Tuple<LogMessage, LogPublisherInternal>> m_messages;
        private readonly ScheduledTask m_routingTask;
        private readonly ScheduledTask m_calculateRoutingTable;
        public bool RoutingTablesValid { get; private set; }

        /// <summary>
        /// Creates a <see cref="LoggerInternal"/>.
        /// </summary>
        public LoggerInternal(out LoggerInternal loggerClass)
        {
            //Needed to set the member variable of Logger. 
            //This is because ScheduleTask will call Logger before Logger's static constructor is completed.
            loggerClass = this;

            m_syncRoot = new object();
            m_typeIndexCache = new Dictionary<Type, LogPublisherInternal>();
            m_allPublishers = new List<LogPublisherInternal>();
            m_subscribers = new List<NullableWeakReference>();
            m_messages = new ConcurrentQueue<Tuple<LogMessage, LogPublisherInternal>>();

            // Since ScheduledTask calls ShutdownHandler, which calls Logger. This initialization method cannot occur
            // until after the Logger static class has finished initializing.
            m_calculateRoutingTable = new ScheduledTask();
            m_calculateRoutingTable.Running += CalculateRoutingTable;
            m_calculateRoutingTable.IgnoreShutdownEvent();
            m_routingTask = new ScheduledTask(ThreadingMode.DedicatedForeground);
            m_routingTask.Running += RoutingTask;
            m_routingTask.IgnoreShutdownEvent();
        }

        /// <summary>
        /// Recalculates the entire routing table on a separate thread.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void CalculateRoutingTable(object sender, EventArgs<ScheduledTaskRunningReason> e)
        {
            lock (m_syncRoot)
            {
                //Some other thread won on the race condition.
                if (RoutingTablesValid)
                    return;

                var subscribers = new List<LogSubscriberInternal>(m_subscribers.Count);
                m_subscribers.RemoveWhere(x =>
                    {
                        LogSubscriberInternal subscriber = (LogSubscriberInternal)x.Target;
                        if (subscriber != null)
                        {
                            subscribers.Add(subscriber);
                            return false;
                        }
                        return true;
                    });

                foreach (var pub in m_allPublishers)
                {
                    CalculateRoutingTableForPublisherSync(subscribers, pub);
                }
                RoutingTablesValid = true;
            }
        }

        /// <summary>
        /// This method should be called with a lock on m_syncRoot
        /// </summary>
        private void CalculateRoutingTableForPublisherSync(List<LogSubscriberInternal> subscribers, LogPublisherInternal publisher)
        {
            MessageAttributeFilterCollection filterCollection = new MessageAttributeFilterCollection();
            foreach (var sub in subscribers)
            {
                filterCollection.Add(sub.GetSubscription(publisher), sub);
            }
            publisher.SubscriptionFilterCollection = filterCollection;
        }

        private void RoutingTask(object sender, EventArgs<ScheduledTaskRunningReason> e)
        {
            lock (m_syncRoot)
            {
                if (!RoutingTablesValid)
                {
                    CalculateRoutingTable(null, null);
                }

                Tuple<LogMessage, LogPublisherInternal> messageTuple;
                while (m_messages.TryDequeue(out messageTuple))
                {
                    var publisher = messageTuple.Item2;
                    var message = messageTuple.Item1;

                    foreach (var route in publisher.SubscriptionFilterCollection.Routes)
                    {
                        var filter = route.Item1;
                        var subscriber = route.Item2.Target as LogSubscriberInternal;

                        if (subscriber == null)
                            RecalculateRoutingTable();
                        else if (filter.IsSubscribedTo(message.LogMessageAttributes))
                            subscriber.RaiseLogMessages(message);
                    }
                }
            }
        }

        /// <summary>
        /// Creates a <see cref="LogSubscriber"/> that can subscribe to log messages.
        /// </summary>
        /// <returns></returns>
        public LogSubscriberInternal CreateSubscriber()
        {
            lock (m_syncRoot)
            {
                if (m_disposing)
                    return LogSubscriberInternal.DisposedSubscriber;
                var s = new LogSubscriberInternal(RecalculateRoutingTable);
                m_subscribers.Add(s.Reference);
                return s;
            }
        }

        /// <summary>
        /// Invalidates the current routing table.
        /// </summary>
        private void RecalculateRoutingTable()
        {
            RoutingTablesValid = false;
            //Wait some time before recalculating the routing tables. This will be done automatically 
            //if a message is routed before the table is recalculated.
            m_calculateRoutingTable.Start(10);
        }

        /// <summary>
        /// Handles the routing of messages through the logging system.
        /// </summary>
        /// <param name="message">the message to route</param>
        /// <param name="publisher">the publisher that is originating this message.</param>
        public void OnNewMessage(LogMessage message, LogPublisherInternal publisher)
        {
            m_messages.Enqueue(Tuple.Create(message, publisher));
            m_routingTask.Start(50); //Allow a 50ms delay for multiple logs to queue if in a burst period.
        }

        /// <summary>
        /// Creates a type topic on a specified type.
        /// </summary>
        /// <param name="type">the type to create the topic from</param>
        /// <returns></returns>
        public LogPublisherInternal CreateType(Type type)
        {
            if ((object)type == null)
                throw new ArgumentNullException(nameof(type));

            LogPublisherInternal publisher;
            lock (m_syncRoot)
            {
                if (!m_typeIndexCache.TryGetValue(type, out publisher))
                {
                    publisher = new LogPublisherInternal(this, type);
                    m_typeIndexCache.Add(type, publisher);
                    if (!m_disposing)
                    {
                        m_allPublishers.Add(publisher);
                        var lst = new List<LogSubscriberInternal>();
                        foreach (var logSubscriberInternal in m_subscribers)
                        {
                            LogSubscriberInternal target = logSubscriberInternal.Target as LogSubscriberInternal;
                            if (target != null)
                            {
                                lst.Add(target);
                            }
                        }
                        CalculateRoutingTableForPublisherSync(lst, publisher);
                    }
                }
            }
            return publisher;
        }

        /// <summary>
        /// Gracefully terminate all message routing. Function blocks until all termination is successful.
        /// </summary>
        public void Dispose()
        {
            if (m_disposing)
                return;

            lock (m_syncRoot)
            {
                //Ensure that setting disposing is in a synchronized context.
                m_disposing = true;
            }

            //These scheduled tasks block when dispose is called. Therefore do not put these in a lock on the base class.
            m_calculateRoutingTable.Dispose();
            m_routingTask.Dispose();

            lock (m_syncRoot)
            {
                m_allPublishers.Clear();
                foreach (var sub in m_subscribers)
                {
                    (sub.Target as LogSubscriberInternal)?.Dispose();
                }
                m_subscribers.Clear();
            }
        }


    }
}