//******************************************************************************************************
//  LogPublisher.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;

// ReSharper disable InconsistentlySynchronizedField

namespace GSF.Diagnostics
{
    /// <summary>
    /// A publisher of log messages. 
    /// </summary>
    /// <remarks>
    /// <see cref="InitialStackMessages"/> and <see cref="InitialStackTrace"/> can be modified so messages that are generated 
    /// with this instance will have this data appended to the log message.
    /// 
    /// The user can either call one of the Publish overloads to lazily publish a message, or they
    /// can register a message with RegisterEvent so calling this message will incur little overhead.
    /// If registering an event, the user can check <see cref="LogEventPublisher.HasSubscribers"/> to determine if the log message can be skipped altogether. 
    /// Registering events also allows the user to specify the auto-suppression algorithm and the depth of the stack trace that will be recorded on a message being raised.
    /// 
    /// </remarks>
    public class LogPublisher
    {
        /// <summary>
        /// Occurs when a new <see cref="LogMessage"/> is ready to be published.
        /// </summary>
        private LoggerInternal m_logger;

        private readonly LogPublisherInternal m_publisherInstance;
        private readonly MessageClass m_classification;

        /// <summary>
        /// The stack messages that existed when this publisher was created. This can be modified by the user of this publisher.
        /// Any messages that get published by this class will automatically have this data added to the log message.
        /// </summary>
        public LogStackMessages InitialStackMessages;

        /// <summary>
        /// The stack trace that existed when this publisher was created. This can be modified by the user of this publisher.
        /// Any messages that get published by this class will automatically have this data added to the log message.
        /// </summary>
        public LogStackTrace InitialStackTrace;

        /// <summary>
        /// The maximum number of distinct events that this publisher can generate. (Default: 20)
        /// </summary>
        /// <remarks>
        /// Since message suppression and collection occurs at the event name level, it is important
        /// to have only a few distinct message types. This is the limit so misapplication
        /// of this publisher will not cause memory impacts on the system.
        /// 
        /// It is recommended to keep the event name as a fixed string and not report any other meta data
        /// with the event.
        /// </remarks>
        // ReSharper disable once ConvertToConstant.Global
        public int MaxDistinctEventPublisherCount { get; set; }

        /// <summary>
        /// Where the <see cref="LogEventPublisherInternal"/>s of specific events are cached.
        /// </summary>
        private readonly ConcurrentDictionary<Tuple<LogMessageAttributes, string>, LogEventPublisherInternal> m_lookupEventPublishers;

        private LogEventPublisherInternal m_excessivePublisherEventNames;

        internal LogPublisher(LoggerInternal logger, LogPublisherInternal publisherInstance, MessageClass classification)
        {
            m_logger = logger;
            m_publisherInstance = publisherInstance;
            m_classification = classification;
            InitialStackMessages = Logger.GetStackMessages();
            InitialStackTrace = new LogStackTrace(true, 1, 10);
            MaxDistinctEventPublisherCount = 20;
            m_lookupEventPublishers = new ConcurrentDictionary<Tuple<LogMessageAttributes, string>, LogEventPublisherInternal>();

        }

        /// <summary>
        /// Initializes an <see cref="LogEventPublisher"/> with the provided values.
        /// </summary>
        /// <param name="level">the level of the message and associated flags if any</param>
        /// <param name="eventName">the name of the event.</param>
        /// <returns></returns>
        public LogEventPublisher RegisterEvent(MessageLevel level, string eventName)
        {
            LogMessageAttributes flag = new LogMessageAttributes(m_classification, level, MessageSuppression.None, MessageFlags.None);
            LogEventPublisherInternal publisher = InternalRegisterEvent(flag, eventName);
            return new LogEventPublisher(this, publisher);
        }

        /// <summary>
        /// Initializes an <see cref="LogEventPublisher"/> with the provided values.
        /// </summary>
        /// <param name="level">the level of the message</param>
        /// <param name="flags">associated flags</param>
        /// <param name="eventName">the name of the event.</param>
        /// <returns></returns>
        public LogEventPublisher RegisterEvent(MessageLevel level, MessageFlags flags, string eventName)
        {
            LogMessageAttributes flag = new LogMessageAttributes(m_classification, level, MessageSuppression.None, flags);
            LogEventPublisherInternal publisher = InternalRegisterEvent(flag, eventName);
            return new LogEventPublisher(this, publisher);
        }

        /// <summary>
        /// Initializes an <see cref="LogEventPublisher"/> with the provided values.
        /// </summary>
        /// <param name="level">the level of the message</param>
        /// <param name="eventName"></param>
        /// <param name="stackTraceDepth"></param>
        /// <param name="messagesPerSecond"></param>
        /// <param name="burstLimit"></param>
        /// <returns></returns>
        public LogEventPublisher RegisterEvent(MessageLevel level, string eventName, int stackTraceDepth, MessageRate messagesPerSecond, int burstLimit)
        {
            LogMessageAttributes flag = new LogMessageAttributes(m_classification, level, MessageSuppression.None, MessageFlags.None);
            LogEventPublisherInternal publisher = InternalRegisterEvent(flag, eventName, stackTraceDepth, messagesPerSecond, burstLimit);
            return new LogEventPublisher(this, publisher);
        }

        /// <summary>
        /// Initializes an <see cref="LogEventPublisher"/> with the provided values.
        /// </summary>
        /// <param name="level">the level of the message</param>
        /// <param name="flags">associated flags</param>
        /// <param name="eventName"></param>
        /// <param name="stackTraceDepth"></param>
        /// <param name="messagesPerSecond"></param>
        /// <param name="burstLimit"></param>
        /// <returns></returns>
        public LogEventPublisher RegisterEvent(MessageLevel level, MessageFlags flags, string eventName, int stackTraceDepth, MessageRate messagesPerSecond, int burstLimit)
        {
            LogMessageAttributes flag = new LogMessageAttributes(m_classification, level, MessageSuppression.None, flags);
            LogEventPublisherInternal publisher = InternalRegisterEvent(flag, eventName, stackTraceDepth, messagesPerSecond, burstLimit);
            return new LogEventPublisher(this, publisher);
        }

        /// <summary>
        /// Gets the full name of the type.
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            return m_publisherInstance.TypeData.TypeName + " (" + m_publisherInstance.TypeData.AssemblyName + ")";
        }

        /// <summary>
        /// Raises a log message with the provided data.
        /// </summary>
        /// <param name="level">the level of the message</param>
        /// <param name="eventName">A short name about what this message is detailing. Typically this will be a few words.</param>
        /// <param name="message"> A longer message than <see param="eventName"/> giving more specifics about the actual message. 
        /// Typically, this will be up to 1 line of text.</param>
        /// <param name="details">A long text field with the details of the message.</param>
        /// <param name="exception">An exception object if one is provided.</param>
        public void Publish(MessageLevel level, string eventName, string message = null, string details = null, Exception exception = null)
        {
            LogMessageAttributes flag = new LogMessageAttributes(m_classification, level, MessageSuppression.None, MessageFlags.None);
            InternalRegisterEvent(flag, eventName).Publish(null, message, details, exception, InitialStackMessages, InitialStackTrace);
        }

        /// <summary>
        /// Raises a log message with the provided data.
        /// </summary>
        /// <param name="level">the level of the message</param>
        /// <param name="flags">associated flags</param>
        /// <param name="eventName">A short name about what this message is detailing. Typically this will be a few words.</param>
        /// <param name="message"> A longer message than <see param="eventName"/> giving more specifics about the actual message. 
        /// Typically, this will be up to 1 line of text.</param>
        /// <param name="details">A long text field with the details of the message.</param>
        /// <param name="exception">An exception object if one is provided.</param>
        public void Publish(MessageLevel level, MessageFlags flags, string eventName, string message = null, string details = null, Exception exception = null)
        {
            LogMessageAttributes flag = new LogMessageAttributes(m_classification, level, MessageSuppression.None, flags);
            InternalRegisterEvent(flag, eventName).Publish(null, message, details, exception, InitialStackMessages, InitialStackTrace);
        }


        /// <summary>
        /// Initializes an <see cref="LogEventPublisher"/> with a series of settings.
        /// </summary>
        /// <param name="attributes"></param>
        /// <param name="eventName">the name of the event.</param>
        /// <returns></returns>
        private LogEventPublisherInternal InternalRegisterEvent(LogMessageAttributes attributes, string eventName)
        {
            if (eventName == null)
                eventName = string.Empty;
            LogEventPublisherInternal publisher;
            if (m_lookupEventPublishers.TryGetValue(Tuple.Create(attributes, eventName), out publisher))
            {
                return publisher;
            }

            //If messages events are unclassified allow a higher message throughput rate.
            double messagesPerSecond = 1;
            int burstRate = 20;
            if (eventName.Length == 0)
            {
                messagesPerSecond = 5;
                burstRate = 100;
            }
            return InternalRegisterNewEvent(attributes, eventName, 0, messagesPerSecond, burstRate);
        }

        /// <summary>
        /// Initializes an <see cref="LogEventPublisher"/> with a series of settings.
        /// </summary>
        /// <param name="attributes"></param>
        /// <param name="eventName"></param>
        /// <param name="stackTraceDepth"></param>
        /// <param name="messagesPerSecond"></param>
        /// <param name="burstLimit"></param>
        /// <returns></returns>
        private LogEventPublisherInternal InternalRegisterEvent(LogMessageAttributes attributes, string eventName, int stackTraceDepth, MessageRate messagesPerSecond, int burstLimit)
        {
            if (eventName == null)
                eventName = string.Empty;
            LogEventPublisherInternal publisher;
            if (m_lookupEventPublishers.TryGetValue(Tuple.Create(attributes, eventName), out publisher))
            {
                return publisher;
            }
            return InternalRegisterNewEvent(attributes, eventName, stackTraceDepth, messagesPerSecond, burstLimit);
        }

        private LogEventPublisherInternal InternalRegisterNewEvent(LogMessageAttributes attributes, string eventName, int stackTraceDepth, double messagesPerSecond, int burstLimit)
        {
            //Note: A race condition can cause more then the maximum number of entries to exist, however, this is not a concern.
            if (m_lookupEventPublishers.Count > MaxDistinctEventPublisherCount)
            {
                if (m_excessivePublisherEventNames == null)
                {
                    var owner1 = new LogEventPublisherDetails(m_publisherInstance.TypeData,
                        "Excessive Event Names: Event names for this publisher has been limited to " + MaxDistinctEventPublisherCount.ToString() +
                        "Please adjust MaxDistinctEventPublisherCount if this is not a bug and this publisher can truly create this many publishers.");
                    m_excessivePublisherEventNames = new LogEventPublisherInternal(attributes, owner1, m_publisherInstance, m_logger, stackTraceDepth, messagesPerSecond, burstLimit);
                }
                return m_excessivePublisherEventNames;
            }

            LogEventPublisherInternal publisher;
            var owner = new LogEventPublisherDetails(m_publisherInstance.TypeData, eventName);
            publisher = new LogEventPublisherInternal(attributes, owner, m_publisherInstance, m_logger, stackTraceDepth, messagesPerSecond, burstLimit);
            publisher = m_lookupEventPublishers.GetOrAdd(Tuple.Create(attributes, eventName), publisher);
            return publisher;
        }

    }
}