using System.Diagnostics;

using UnityEngine;

namespace Ubisoft
{
    public partial class HtLogger
    {
        /// <summary>
        /// This class is responsible for logging messages to a specific channel.
        /// You can use channels to keep your logs organized. You can enable/disable channels to reduce noise while debugging a given feature.
        /// </summary>
        public class Channel
        {
            private HtLogger Logger { get; set; }
            public string Name { get; set; }
            public string Color { get; set; }
            public bool IsEnabled { get; set; }
            public bool IsTagEnabled { get; set; } = true;

            protected Channel()
            {
            }

            /// <summary>
            /// Create a Channel.
            /// </summary>
            /// <param name="logger">Logger where the messages of this channel need to be logged to.</param>
            /// <param name="name">Name of the channel. It's also used as a tag for the message.</param>
            /// <param name="color">Color to use for the message. Two options:
            ///                     1)A string containing a hexadecimal value (i.e. "#FF5733")
            ///                     2)A string containing one of the defualt values defined in <c>UnityEngine.Color</c> (i.e. "magenta")
            /// </param>
            internal Channel(HtLogger logger, string name, string color = null)
            {
                Setup(logger, name, color);
            }

            private void Setup(HtLogger logger, string name, string color = null)
            {
                Logger = logger;
                Name = name;
                Color = color;
                IsEnabled = true;
            }

            //
            // Assert
            //

            /// <summary>
            /// Assert a condition and log a generic error message to all Logger streams on failure.
            ///
            /// Note that this method works only if <c>LoggerProperty.IsAssertEnabled</c> is enabled. Otherwise this method and the calls to this method will be
            /// stripped out avoiding all impact in performance and build size.
            /// 
            /// </summary>
            /// <param name="condition">Condition you expect to be true.</param>
            [Conditional(HT_LOGGER_ASSERT_ON)]
            public void Assert(bool condition)
            {
                Logger.Assert(condition);
            }

            //
            // Log
            //

            /// <summary>
            /// Log a Trace message to this channel for all Logger streams.
            ///
            /// Trace logs contain the most detailed messages. These messages may contain sensitive application data.
            /// These messages are disabled by default and should never be enabled in a production environment.
            ///
            /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Trace</c>. Otherwise this method and the calls to
            /// this method will be stripped out avoiding all impact in performance and build size.
            /// 
            /// More information on deciding the log level to use here:
            /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
            /// </summary>
            /// <param name="message">Message to log.</param>
            [Conditional(HT_LOGGER_TRACE_ON)]
            public void LogTrace(object message)
            {
                Logger.InternalLog(this, message, ELogLevel.Trace);
            }

            /// <summary>
            /// Log a Debug message to this channel for all Logger streams.
            ///
            /// Debug logs are used for interactive investigation during development. These logs should primarily contain information useful
            /// for debugging and have no long-term value.
            ///
            /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Debug</c> or less. Otherwise this method and the calls to
            /// this method will be stripped out avoiding all impact in performance and build size.
            /// 
            /// More information on deciding the log level to use here:
            /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
            /// </summary>
            /// <param name="message">Message to log.</param>
            [Conditional(HT_LOGGER_DEBUG_ON)]
            public void LogDebug(object message)
            {
                Logger.InternalLog(this, message, ELogLevel.Debug);
            }

            /// <summary>
            /// Log an Information message to this channel for all Logger streams.
            ///
            /// Information logs track the general flow of the application (breadcrumbs). These logs should have long-term value.
            ///
            /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Information</c> or less. Otherwise this method and the calls to
            /// this method will be stripped out avoiding all impact in performance and build size.
            /// 
            /// More information on deciding the log level to use here:
            /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
            /// </summary>
            /// <param name="message">Message to log.</param>
            [Conditional(HT_LOGGER_INFORMATION_ON)]
            public void LogInformation(object message)
            {
                Logger.InternalLog(this, message, ELogLevel.Information);
            }

            /// <summary>
            /// Log a Warning message to this channel for all Logger streams.
            ///
            /// Warning logs highlight an abnormal or unexpected event in the application flow, but do not otherwise cause the application execution to stop.
            ///
            /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Warning</c> or less. Otherwise this method and the calls to
            /// this method will be stripped out avoiding all impact in performance and build size.
            ///
            /// Channel color is ignored. Yellow is always used for Warning messages.
            ///
            /// More information on deciding the log level to use here:
            /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
            /// </summary>
            /// <param name="message">Message to log.</param>
            [Conditional(HT_LOGGER_WARNING_ON)]
            public void LogWarning(object message)
            {
                Logger.InternalLog(this, message, ELogLevel.Warning);
            }

            /// <summary>
            /// Log an Error message to this channel for all Logger streams.
            ///
            /// Error logs highlight when the current flow of execution is stopped due to a failure. These should indicate a failure in the current activity, not an application-wide failure.
            ///
            /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Error</c> or less. Otherwise this method and the calls to
            /// this method will be stripped out avoiding all impact in performance and build size.
            ///
            /// Channel color is ignored. Red is always used for Error messages.
            /// 
            /// More information on deciding the log level to use here:
            /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
            /// </summary>
            /// <param name="message">Message to log.</param>
            [Conditional(HT_LOGGER_ERROR_ON)]
            public void LogError(object message)
            {
                Logger.InternalLog(this, message, ELogLevel.Error);
            }

            /// <summary>
            /// Log a Critical message to this channel for all Logger streams.
            ///
            /// Critical logs describe an unrecoverable application or system crash, or a catastrophic failure that requires immediate attention.
            ///
            /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Critical</c> or less. Otherwise this method and the calls to
            /// this method will be stripped out avoiding all impact in performance and build size.
            ///
            /// Channel color is ignored. Red is always used for Critical messages.
            /// 
            /// More information on deciding the log level to use here:
            /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
            /// </summary>
            /// <param name="message">Message to log.</param>
            [Conditional(HT_LOGGER_CRITICAL_ON)]
            public void LogCritical(object message)
            {
                Logger.InternalLog(this, message, ELogLevel.Critical);
            }

            /// <summary>
            /// Assert a condition and log an error message to this channel for all Logger streams on failure.
            ///
            /// Note that this method works only if <c>LoggerProperty.IsAssertEnabled</c> is enabled. Otherwise this method and the calls to this method will be
            /// stripped out avoiding all impact in performance and build size.
            ///
            /// Channel color is ignored. Red is always used for Assertions.
            ///         
            /// </summary>
            /// <param name="condition">Condition you expect to be true.</param>
            /// <param name="message">Message to log.</param>
            [Conditional(HT_LOGGER_ASSERT_ON)]
            public void Assert(bool condition, object message)
            {
                Logger.InternalAssert(this, condition, message, null);
            }

            /// <summary>
            /// Log an assertion message to this channel for all Logger streams.
            ///
            /// Note that this method works only if <c>LoggerProperty.IsAssertEnabled</c> is enabled. Otherwise this method and the calls to this method will be
            /// stripped out avoiding all impact in performance and build size.
            ///
            /// Channel color is ignored. Red is always used for Assertions.
            ///
            /// </summary>
            /// <param name="message">Message to log.</param>
            [Conditional(HT_LOGGER_ASSERT_ON)]
            public void LogAssertion(object message)
            {
                Logger.InternalLogAssertion(this, message, null);
            }

            //
            // Log with context
            //

            /// <summary>
            /// Log a Trace message to this channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
            ///
            /// Trace logs contain the most detailed messages. These messages may contain sensitive application data.
            /// These messages are disabled by default and should never be enabled in a production environment.
            ///
            /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Trace</c>. Otherwise this method and the calls to
            /// this method will be stripped out avoiding all impact in performance and build size.
            /// 
            /// More information on deciding the log level to use here:
            /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
            /// </summary>
            /// <param name="message">Message to log.</param>
            /// <param name="context">Object to which the message applies.</param>
            [Conditional(HT_LOGGER_TRACE_ON)]
            public void LogTrace(object message, Object context)
            {
                Logger.InternalLog(this, message, ELogLevel.Trace, context);
            }

            /// <summary>
            /// Log a Debug message to this channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
            ///
            /// Debug logs are used for interactive investigation during development. These logs should primarily contain information useful
            /// for debugging and have no long-term value.
            ///
            /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Debug</c> or less. Otherwise this method and the calls to
            /// this method will be stripped out avoiding all impact in performance and build size.
            /// 
            /// More information on deciding the log level to use here:
            /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
            /// </summary>
            /// <param name="message">Message to log.</param>
            /// <param name="context">Object to which the message applies.</param>
            [Conditional(HT_LOGGER_DEBUG_ON)]
            public void LogDebug(object message, Object context)
            {
                Logger.InternalLog(this, message, ELogLevel.Debug, context);
            }

            /// <summary>
            /// Log an Information message to this channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
            ///
            /// Information logs track the general flow of the application (breadcrumbs). These logs should have long-term value.
            ///
            /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Information</c> or less. Otherwise this method and the calls to
            /// this method will be stripped out avoiding all impact in performance and build size.
            /// 
            /// More information on deciding the log level to use here:
            /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
            /// </summary>
            /// <param name="message">Message to log.</param>
            /// <param name="context">Object to which the message applies.</param>
            [Conditional(HT_LOGGER_INFORMATION_ON)]
            public void LogInformation(object message, Object context)
            {
                Logger.InternalLog(this, message, ELogLevel.Information, context);
            }

            /// <summary>
            /// Log a Warning message to this channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
            ///
            /// Warning logs highlight an abnormal or unexpected event in the application flow, but do not otherwise cause the application execution to stop.
            ///
            /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Warning</c> or less. Otherwise this method and the calls to
            /// this method will be stripped out avoiding all impact in performance and build size.
            ///
            /// Channel color is ignored. Yellow is always used for Warning messages.
            ///
            /// More information on deciding the log level to use here:
            /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
            /// </summary>
            /// <param name="message">Message to log.</param>
            /// <param name="context">Object to which the message applies.</param>
            [Conditional(HT_LOGGER_WARNING_ON)]
            public void LogWarning(object message, Object context)
            {
                Logger.InternalLog(this, message, ELogLevel.Warning, context);
            }

            /// <summary>
            /// Log an Error message to this channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
            ///      
            /// Error logs highlight when the current flow of execution is stopped due to a failure. These should indicate a failure in the current activity, not an application-wide failure.
            ///
            /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Error</c> or less. Otherwise this method and the calls to
            /// this method will be stripped out avoiding all impact in performance and build size.
            ///
            /// Channel color is ignored. Red is always used for Error messages.
            /// 
            /// More information on deciding the log level to use here:
            /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
            /// </summary>
            /// <param name="message">Message to log.</param>
            /// <param name="context">Object to which the message applies.</param>
            [Conditional(HT_LOGGER_ERROR_ON)]
            public void LogError(object message, Object context)
            {
                Logger.InternalLog(this, message, ELogLevel.Error, context);
            }

            /// <summary>
            /// Log a Critical message to this channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
            ///
            /// Critical logs describe an unrecoverable application or system crash, or a catastrophic failure that requires immediate attention.
            ///
            /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Critical</c> or less. Otherwise this method and the calls to
            /// this method will be stripped out avoiding all impact in performance and build size.
            ///
            /// Channel color is ignored. Red is always used for Critical messages.
            /// 
            /// More information on deciding the log level to use here:
            /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
            /// </summary>
            /// <param name="message">Message to log.</param>
            /// <param name="context">Object to which the message applies.</param>
            [Conditional(HT_LOGGER_CRITICAL_ON)]
            public void LogCritical(object message, Object context)
            {
                Logger.InternalLog(this, message, ELogLevel.Critical, context);
            }

            /// <summary>
            /// Assert a condition, log an error message to this channel for all Logger streams on failure and highlight in the hierarchy the object that the message applies to.
            ///
            /// Note that this method works only if <c>LoggerProperty.IsAssertEnabled</c> is enabled. Otherwise this method and the calls to this method will be
            /// stripped out avoiding all impact in performance and build size.
            ///
            /// Channel color is ignored. Red is always used for Assertions.
            ///
            /// </summary>
            /// <param name="condition">Condition you expect to be true.</param>
            /// <param name="message">Message to log.</param>
            /// <param name="context">Object to which the message applies.</param>
            [Conditional(HT_LOGGER_ASSERT_ON)]
            public void Assert(bool condition, object message, Object context)
            {
                Logger.InternalAssert(this, condition, message, context);
            }

            /// <summary>
            /// Log an assertion message to this channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
            ///
            /// Note that this method works only if <c>LoggerProperty.IsAssertEnabled</c> is enabled. Otherwise this method and the calls to this method will be
            /// stripped out avoiding all impact in performance and build size.
            ///
            /// Channel color is ignored. Red is always used for Assertions.
            ///
            /// </summary>
            /// <param name="message">Message to log.</param>
            /// <param name="context">Object to which the message applies.</param>
            [Conditional(HT_LOGGER_ASSERT_ON)]
            public void LogAssertion(object message, Object context)
            {
                Logger.InternalLogAssertion(this, message, context);
            }

            //
            // Log with format
            //

            /// <summary>
            /// Log a formated Trace message to this channel for all Logger streams.
            ///
            /// Trace logs contain the most detailed messages. These messages may contain sensitive application data.
            /// These messages are disabled by default and should never be enabled in a production environment.
            ///
            /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Trace</c>. Otherwise this method and the calls to
            /// this method will be stripped out avoiding all impact in performance and build size.
            /// 
            /// More information on deciding the log level to use here:
            /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
            /// </summary>
            /// <param name="format">A composite format string.</param>
            /// <param name="args">Format arguments.</param>
            [Conditional(HT_LOGGER_TRACE_ON)]
            public void LogTraceFormat(string format, params object[] args)
            {
                Logger.InternalLog(this, string.Format(format, args), ELogLevel.Trace);
            }

            /// <summary>
            /// Log a formatted Debug message to this channel for all Logger streams.
            /// 
            /// Debug logs are used for interactive investigation during development. These logs should primarily contain information useful
            /// for debugging and have no long-term value.
            ///
            /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Debug</c> or less. Otherwise this method and the calls to
            /// this method will be stripped out avoiding all impact in performance and build size.
            /// 
            /// More information on deciding the log level to use here:
            /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
            /// </summary>
            /// <param name="format">A composite format string.</param>
            /// <param name="args">Format arguments.</param>
            [Conditional(HT_LOGGER_DEBUG_ON)]
            public void LogDebugFormat(string format, params object[] args)
            {
                Logger.InternalLog(this, string.Format(format, args), ELogLevel.Debug);
            }

            /// <summary>
            /// Log a formatted Information message to this channel for all Logger streams.
            /// 
            /// Information logs track the general flow of the application (breadcrumbs). These logs should have long-term value.
            ///
            /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Information</c> or less. Otherwise this method and the calls to
            /// this method will be stripped out avoiding all impact in performance and build size.
            /// 
            /// More information on deciding the log level to use here:
            /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
            /// </summary>
            /// <param name="format">A composite format string.</param>
            /// <param name="args">Format arguments.</param>
            [Conditional(HT_LOGGER_INFORMATION_ON)]
            public void LogInformationFormat(string format, params object[] args)
            {
                Logger.InternalLog(this, string.Format(format, args), ELogLevel.Information);
            }

            /// <summary>
            /// Log a formatted Warning message to this channel for all Logger streams.
            ///
            /// Warning logs highlight an abnormal or unexpected event in the application flow, but do not otherwise cause the application execution to stop.
            ///
            /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Warning</c> or less. Otherwise this method and the calls to
            /// this method will be stripped out avoiding all impact in performance and build size.
            ///
            /// Channel color is ignored. Yellow is always used for Warning messages.
            ///
            /// More information on deciding the log level to use here:
            /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
            /// </summary>
            /// <param name="format">A composite format string.</param>
            /// <param name="args">Format arguments.</param>
            [Conditional(HT_LOGGER_WARNING_ON)]
            public void LogWarningFormat(string format, params object[] args)
            {
                Logger.InternalLog(this, string.Format(format, args), ELogLevel.Warning);
            }

            /// <summary>
            /// Log a formatted Error message to this channel for all Logger streams.
            /// 
            /// Error logs highlight when the current flow of execution is stopped due to a failure. These should indicate a failure in the current activity, not an application-wide failure.
            ///
            /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Error</c> or less. Otherwise this method and the calls to
            /// this method will be stripped out avoiding all impact in performance and build size.
            ///
            /// Channel color is ignored. Red is always used for Error messages.
            /// 
            /// More information on deciding the log level to use here:
            /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
            /// </summary>
            /// <param name="format">A composite format string.</param>
            /// <param name="args">Format arguments.</param>
            [Conditional(HT_LOGGER_ERROR_ON)]
            public void LogErrorFormat(string format, params object[] args)
            {
                Logger.InternalLog(this, string.Format(format, args), ELogLevel.Error);
            }

            /// <summary>
            /// Log a formatted Critical message to this channel for all Logger streams.
            /// 
            /// Critical logs describe an unrecoverable application or system crash, or a catastrophic failure that requires immediate attention.
            ///
            /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Critical</c> or less. Otherwise this method and the calls to
            /// this method will be stripped out avoiding all impact in performance and build size.
            ///
            /// Channel color is ignored. Red is always used for Critical messages.
            /// 
            /// More information on deciding the log level to use here:
            /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
            /// </summary>
            /// <param name="format">A composite format string.</param>
            /// <param name="args">Format arguments.</param>
            [Conditional(HT_LOGGER_CRITICAL_ON)]
            public void LogCriticalFormat(string format, params object[] args)
            {
                Logger.InternalLog(this, string.Format(format, args), ELogLevel.Critical);
            }

            /// <summary>
            /// Assert a condition and log a formatted error message to this channel for all Logger streams on failure.
            ///
            /// Note that this method works only if <c>LoggerProperty.IsAssertEnabled</c> is enabled. Otherwise this method and the calls to this method will be
            /// stripped out avoiding all impact in performance and build size.
            ///
            /// Channel color is ignored. Red is always used for Assertions.
            ///
            /// </summary>
            /// <param name="condition">Condition you expect to be true.</param>
            /// <param name="format">A composite format string.</param>
            /// <param name="args">Format arguments.</param>
            [Conditional(HT_LOGGER_ASSERT_ON)]
            public void AssertFormat(bool condition, string format, params object[] args)
            {
                Logger.InternalAssert(this, condition, string.Format(format, args), null);
            }

            /// <summary>
            /// Log a formatted assertion message to this channel for all Logger streams.
            /// 
            /// Note that this method works only if <c>LoggerProperty.IsAssertEnabled</c> is enabled. Otherwise this method and the calls to this method will be
            /// stripped out avoiding all impact in performance and build size.
            ///
            /// Channel color is ignored. Red is always used for Assertions.
            ///
            /// </summary>
            /// <param name="format">A composite format string.</param>
            /// <param name="args">Format arguments.</param>
            [Conditional(HT_LOGGER_ASSERT_ON)]
            public void LogAssertionFormat(string format, params object[] args)
            {
                Logger.InternalLogAssertion(this, string.Format(format, args), null);
            }

            //
            // Log with context and format
            //

            /// <summary>
            /// Log a formated Trace message to this channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
            /// 
            /// Trace logs contain the most detailed messages. These messages may contain sensitive application data.
            /// These messages are disabled by default and should never be enabled in a production environment.
            ///
            /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Trace</c>. Otherwise this method and the calls to
            /// this method will be stripped out avoiding all impact in performance and build size.
            /// 
            /// More information on deciding the log level to use here:
            /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
            /// </summary>
            /// <param name="context">Object to which the message applies.</param>
            /// <param name="format">A composite format string.</param>
            /// <param name="args">Format arguments.</param>
            [Conditional(HT_LOGGER_TRACE_ON)]
            public void LogTraceFormat(Object context, string format, params object[] args)
            {
                Logger.InternalLog(this, string.Format(format, args), ELogLevel.Trace, context);
            }

            /// <summary>
            /// Log a formatted Debug message to this channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
            /// 
            /// Debug logs are used for interactive investigation during development. These logs should primarily contain information useful
            /// for debugging and have no long-term value.
            ///
            /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Debug</c> or less. Otherwise this method and the calls to
            /// this method will be stripped out avoiding all impact in performance and build size.
            /// 
            /// More information on deciding the log level to use here:
            /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
            /// </summary>
            /// <param name="context">Object to which the message applies.</param>
            /// <param name="format">A composite format string.</param>
            /// <param name="args">Format arguments.</param>
            [Conditional(HT_LOGGER_DEBUG_ON)]
            public void LogDebugFormat(Object context, string format, params object[] args)
            {
                Logger.InternalLog(this, string.Format(format, args), ELogLevel.Debug, context);
            }

            /// <summary>
            /// Log a formatted Information message to this channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
            ///
            /// Information logs track the general flow of the application (breadcrumbs). These logs should have long-term value.
            ///
            /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Information</c> or less. Otherwise this method and the calls to
            /// this method will be stripped out avoiding all impact in performance and build size.
            /// 
            /// More information on deciding the log level to use here:
            /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
            /// </summary>
            /// <param name="context">Object to which the message applies.</param>
            /// <param name="format">A composite format string.</param>
            /// <param name="args">Format arguments.</param>
            [Conditional(HT_LOGGER_INFORMATION_ON)]
            public void LogInformationFormat(Object context, string format, params object[] args)
            {
                Logger.InternalLog(this, string.Format(format, args), ELogLevel.Information, context);
            }

            /// <summary>
            /// Log a formatted Warning message to this channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
            ///
            /// Warning logs highlight an abnormal or unexpected event in the application flow, but do not otherwise cause the application execution to stop.
            ///
            /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Warning</c> or less. Otherwise this method and the calls to
            /// this method will be stripped out avoiding all impact in performance and build size.
            ///
            /// Channel color is ignored. Yellow is always used for Warning messages.
            ///
            /// More information on deciding the log level to use here:
            /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
            /// </summary>
            /// <param name="context">Object to which the message applies.</param>
            /// <param name="format">A composite format string.</param>
            /// <param name="args">Format arguments.</param>
            [Conditional(HT_LOGGER_WARNING_ON)]
            public void LogWarningFormat(Object context, string format, params object[] args)
            {
                Logger.InternalLog(this, string.Format(format, args), ELogLevel.Warning, context);
            }

            /// <summary>
            /// Log a formatted Error message to this channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
            ///
            /// Error logs highlight when the current flow of execution is stopped due to a failure. These should indicate a failure in the current activity, not an application-wide failure.
            ///
            /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Error</c> or less. Otherwise this method and the calls to
            /// this method will be stripped out avoiding all impact in performance and build size.
            ///
            /// Channel color is ignored. Red is always used for Error messages.
            /// 
            /// More information on deciding the log level to use here:
            /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
            /// </summary>
            /// <param name="context">Object to which the message applies.</param>
            /// <param name="format">A composite format string.</param>
            /// <param name="args">Format arguments.</param>
            [Conditional(HT_LOGGER_ERROR_ON)]
            public void LogErrorFormat(Object context, string format, params object[] args)
            {
                Logger.InternalLog(this, string.Format(format, args), ELogLevel.Error, context);
            }

            /// <summary>
            /// Log a formatted Critical message to this channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
            /// 
            /// Critical logs describe an unrecoverable application or system crash, or a catastrophic failure that requires immediate attention.
            ///
            /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Critical</c> or less. Otherwise this method and the calls to
            /// this method will be stripped out avoiding all impact in performance and build size.
            ///
            /// Channel color is ignored. Red is always used for Critical messages.
            /// 
            /// More information on deciding the log level to use here:
            /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
            /// </summary>
            /// <param name="context">Object to which the message applies.</param>
            /// <param name="format">A composite format string.</param>
            /// <param name="args">Format arguments.</param>
            [Conditional(HT_LOGGER_CRITICAL_ON)]
            public void LogCriticalFormat(Object context, string format, params object[] args)
            {
                Logger.InternalLog(this, string.Format(format, args), ELogLevel.Critical, context);
            }

            /// <summary>
            /// Assert a condition, log a formatted error message to this channel for all Logger streams on failure and highlight in the hierarchy the object that the message applies to.
            /// 
            /// Note that this method works only if <c>LoggerProperty.IsAssertEnabled</c> is enabled. Otherwise this method and the calls to this method will be
            /// stripped out avoiding all impact in performance and build size.
            ///
            /// Channel color is ignored. Red is always used for Assertions.
            ///
            /// </summary>
            /// <param name="condition">Condition you expect to be true.</param>
            /// <param name="context">Object to which the message applies.</param>
            /// <param name="format">A composite format string.</param>
            /// <param name="args">Format arguments.</param>
            [Conditional(HT_LOGGER_ASSERT_ON)]
            public void AssertFormat(bool condition, Object context, string format, params object[] args)
            {
                Logger.InternalAssert(this, condition, string.Format(format, args), context);
            }

            /// <summary>
            /// Log a formatted assertion message to this channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
            /// 
            /// Note that this method works only if <c>LoggerProperty.IsAssertEnabled</c> is enabled. Otherwise this method and the calls to this method will be
            /// stripped out avoiding all impact in performance and build size.
            ///
            /// Channel color is ignored. Red is always used for Assertions.
            ///
            /// </summary>
            /// <param name="context">Object to which the message applies.</param>
            /// <param name="format">A composite format string.</param>
            /// <param name="args">Format arguments.</param>
            [Conditional(HT_LOGGER_ASSERT_ON)]
            public void LogAssertionFormat(Object context, string format, params object[] args)
            {
                Logger.InternalLogAssertion(this, string.Format(format, args), context);
            }
        }
    }
}