using System;
using System.Collections.Generic;
using System.Diagnostics;

using Ubisoft.Hotel.Logger;
using Ubisoft.Hotel.Package;

namespace Ubisoft
{
    /// <summary>
    /// HtLogger is used instead of simply Logger to avoid name collisions with UnityEngine.Logger when used with using clausules
    /// </summary>
    public partial class HtLogger
    {
        private static HtLogger s_instance;

        public static HtLogger Instance
        {
            get
            {
                if (s_instance == null)
                {
                    s_instance = new HtLogger();
                }

                return s_instance;
            }
        }

        public static string GetLoggerDefineSymbol(ELogLevel logLevel)
        {
            return $"HT_LOGGER_{logLevel.ToString().ToUpper()}_ON";
        }

        public const string HT_LOGGER_ASSERT_ON = "UNITY_ASSERTIONS";
        public const string HT_LOGGER_TRACE_ON = "HT_LOGGER_TRACE_ON";
        public const string HT_LOGGER_DEBUG_ON = "HT_LOGGER_DEBUG_ON";
        public const string HT_LOGGER_INFORMATION_ON = "HT_LOGGER_INFORMATION_ON";
        public const string HT_LOGGER_WARNING_ON = "HT_LOGGER_WARNING_ON";
        public const string HT_LOGGER_ERROR_ON = "HT_LOGGER_ERROR_ON";
        public const string HT_LOGGER_CRITICAL_ON = "HT_LOGGER_CRITICAL_ON";
        public const string HT_LOGGER_EXCEPTION_ON = "HT_LOGGER_EXCEPTION_ON";

        private const string CHANNEL_COLOR = "#4E85E1";

        [Serializable]
        public enum ELogLevel
        {
            Trace,
            Debug,
            Information,
            Warning,
            Error,
            Critical,
            None,
        }

        internal const string CHANNEL_GENERAL_NAME = "General";

        private HtLogger_Imp m_imp;

#pragma warning disable IDE0052 // Used only when HT_PACKAGE_PACKAGEMANAGER_PROD is defined
        private PlayerLoggerProperty m_property;
#pragma warning restore IDE0052 // 

        public List<Channel> Channels { get; set; }
        private Channel m_helperChannel;
        private HashSet<string> m_excludedChannels;
        private HashSet<string> m_includedChannels;

        private HtLogger()
        {
            GeneralChannel = CreateChannel(CHANNEL_GENERAL_NAME);
            GeneralChannel.IsTagEnabled = false;
        }

        private void Init()
        {
            PlayerLoggerProperty loggerProperty = null;

            PlayerPackageSuite packageSuite = PlayerPackageSuite.Load();
            if (packageSuite != null)
            {
                loggerProperty = packageSuite.GetProperty<PlayerLoggerProperty>() as PlayerLoggerProperty;
            }

            Init(loggerProperty);
        }

        protected void Init(PlayerLoggerProperty property)
        {
            if (!IsInitialized)
            {
                m_property = property;
                IsInitialized = true;
            }

            Imp.Init(property);

            if (property != null && property.ChannelsPreset != null)
            {
                ApplyChannelsPreset(property.ChannelsPreset);
            }
        }

        public void ApplyChannelsPreset(ChannelsPreset value)
        {
            if (value != null)
            {
                if (value.OtherChannels)
                {
                    EnableAllChannelsExcept(value.GetDisabledChannels());
                }
                else
                {
                    DisableAllChannelsExcept(value.GetEnabledChannels());
                }
            }
        }

        private HtLogger_Imp Imp
        {
            get
            {
                if (m_imp == null)
                {
#if HT_PACKAGE_ZLOGGER_PROD
                    m_imp = new HtLogger_ImpZLogger();
#else
                    m_imp = new HtLogger_ImpUnity();
#endif
                }

                return m_imp;
            }
        }

        private bool IsInitialized { get; set; }

        /// <summary>
        /// Return whether or not logging is enabled. This is a read-only information which is read from settings.
        /// If you need to disable logging just call <c>DisableAllChannels()</c>.
        /// </summary>
        public bool IsEnabled
        {
            get
            {
                // Make sure logging is enabled in editor mode.
#if UNITY_EDITOR
                if (m_property == null && !UnityEngine.Application.isPlaying)
                {
                    return true;
                }
#endif
                // The property is defined via PackageManager. PackageManager is usually disabled when contributing to a package for convenience reasons
#if HT_PACKAGE_PACKAGEMANAGER_PROD
                return m_property != null && m_property.MinLogLevel != ELogLevel.None;
#else
                return true;
#endif
            }
        }

        public interface IListener
        {
            void BeginLog(Channel channel, object message, ELogLevel logLevel, UnityEngine.Object context = null);
            void EndLog();
        }

        private List<IListener> m_listeners;

        public void AddListener(IListener listener)
        {
            if (m_listeners == null)
            {
                m_listeners = new List<IListener>();
            }

            m_listeners.Add(listener);
        }

        public void RemoveListener(IListener listener)
        {
            if (m_listeners != null && m_listeners.Contains(listener))
            {
                _ = m_listeners.Remove(listener);
            }
        }

        /// <summary>
        /// Create a channel. Channels help you keep your logs organized. You are not allowed to instantiate directly a channel, instead, you need to use this method,
        /// so Logger can track all channels created around.
        /// </summary>
        /// <param name="name">Name of the channel</param>
        /// <param name="color">Color for the messages logged to log levels ((Trace, Debug and Information)) that don't have their own color</param>
        /// <returns>The channel object</returns>
        public Channel CreateChannel(string name, string color = null)
        {
            Channel returnValue = new Channel(this, name, color);
            RegisterChannel(returnValue);

            return returnValue;
        }

        /// <summary>
        /// Create a channel using Hotel conventions for text format and color. This method is reserved to and should be used by all Hotel packages that want to log messages.
        /// </summary>
        /// <param name="name">Name of the channel</param>
        /// <returns>The channel object</returns>
        public Channel CreateHotelChannel(string name)
        {
            return CreateChannel($"[HT_{name}]", CHANNEL_COLOR);
        }

        private void RegisterChannel(Channel channel)
        {
            if (channel != null)
            {
                if (Channels == null)
                {
                    Channels = new List<Channel>();
                }

                Channels.Add(channel);
            }
        }

        /// <summary>
        /// Default channel to use with no channel is specified.
        /// </summary>
        public Channel GeneralChannel { get; }

        private Channel GetHelperChannel(string name)
        {
            if (m_helperChannel == null)
            {
                m_helperChannel = new Channel(this, name);
            }
            else
            {
                m_helperChannel.Name = name;
            }

            return m_helperChannel;
        }

        /// <summary>
        /// Enable all channels. By default all channels are enabled. Use this method after having used <c>DisableAllChannels()</c>
        /// when you want to go back to the default status.
        /// </summary>
        public void EnableAllChannels()
        {
            m_includedChannels = null;
            m_excludedChannels = null;
        }

        /// <summary>
        /// Disable all channels.
        /// </summary>
        public void DisableAllChannels()
        {
            m_includedChannels = new HashSet<string>();
            m_excludedChannels = null;
        }

        /// <summary>
        /// Enable all channels except the ones which names are passed in. Disabling channels may be useful when you want to reduce noise while debugging a given feature.
        /// </summary>
        /// <param name="channelNames">Set of channel names to disable.</param>
        public void EnableAllChannelsExcept(HashSet<string> channelNames)
        {
            m_includedChannels = null;
            m_excludedChannels = new HashSet<string>();
            _ = m_excludedChannels.AddRange(channelNames);
        }

        /// <summary>
        /// Disable all channels except the ones which names are passed in. Disabling channels may be useful when you want to reduce noise while debugging a given feature.
        /// </summary>
        /// <param name="channelNames">Set of channel names to enable.</param>
        public void DisableAllChannelsExcept(HashSet<string> channelNames)
        {
            m_excludedChannels = null;
            m_includedChannels = new HashSet<string>();
            _ = m_includedChannels.AddRange(channelNames);
        }

        /// <summary>
        /// Enable all channels except the ones which names are passed in. Disabling channels may be useful when you want to reduce noise while debugging a given feature.
        /// </summary>
        /// <param name="channels">Set of channels to disable.</param>
        public void EnableAllChannelsExcept(HashSet<Channel> channels)
        {
            EnableAllChannelsExcept(GetChannelNames(channels));
        }

        /// <summary>
        /// Disable all channels except the ones which names are passed in. Disabling channels may be useful when you want to reduce noise while debugging a given feature.
        /// </summary>
        /// <param name="channels">Set of channels to enable.</param>
        public void DisableAllChannelsExcept(HashSet<Channel> channels)
        {
            DisableAllChannelsExcept(GetChannelNames(channels));
        }

        private static HashSet<string> GetChannelNames(HashSet<Channel> channels)
        {
            HashSet<string> returnValue = new HashSet<string>();
            if (channels != null)
            {
                foreach (Channel channel in channels)
                {
                    _ = returnValue.Add(channel.Name);
                }
            }

            return returnValue;
        }

        internal void InternalLog(Channel channel, object message, ELogLevel logLevel, UnityEngine.Object context = null)
        {
            if (channel == null)
            {
                channel = GeneralChannel;
            }

            if (CanLog(channel))
            {
                // Notifies listeners before printing to Unity Logger so listeners can disable Unity Logger if
                // they're supposed to take over in order to avoid the same message to be logged twice
                if (m_listeners != null)
                {
                    int count = m_listeners.Count;
                    for (int i = 0; i < count; ++i)
                    {
                        m_listeners[i].BeginLog(channel, message, logLevel, context);
                    }
                }

                Imp.Log(channel, message, logLevel, context);

                // Notifies listeners after printing to Unity Logger so listeners can enable Unity Logger again
                if (m_listeners != null)
                {
                    int count = m_listeners.Count;
                    for (int i = 0; i < count; ++i)
                    {
                        m_listeners[i].EndLog();
                    }
                }
            }
        }

        internal void InternalAssert(string channel, bool condition, object message, UnityEngine.Object context = null)
        {
            InternalAssert(GetHelperChannel(channel), condition, message, context);
        }

        internal void InternalAssert(Channel channel, bool condition, object message, UnityEngine.Object context)
        {
            if (channel == null)
            {
                channel = GeneralChannel;
            }

            if (CanLog(channel))
            {
                Imp.Assert(channel, condition, message, context);
            }
        }

        internal void InternalLogAssertion(string channel, object message, UnityEngine.Object context)
        {
            InternalLogAssertion(GetHelperChannel(channel), message, context);
        }

        internal void InternalLogAssertion(Channel channel, object message, UnityEngine.Object context)
        {
            if (channel == null)
            {
                channel = GeneralChannel;
            }

            if (CanLog(channel))
            {
                Imp.LogAssertion(channel, message, context);
            }
        }

        internal void InternalLogException(Channel channel, System.Exception exception, UnityEngine.Object context)
        {
            if (channel == null)
            {
                channel = GeneralChannel;
            }

            if (CanLog(channel))
            {
                Imp.LogException(channel, exception, context);
            }
        }

        private bool CanLog(Channel channel)
        {
            bool returnValue = false;

            if (IsChannelEnabled(channel))
            {
                if (!IsInitialized)
                {
                    Init();

                    // If we're initialising then we need to verify that this channel is actually enabled
                    returnValue = IsChannelEnabled(channel);
                }
                else
                {
                    returnValue = true;
                }

                if (returnValue)
                {
                    returnValue = IsEnabled;
                }
            }

            return returnValue;
        }

        public bool IsChannelEnabled(Channel channel)
        {
            bool returnValue = channel.IsEnabled;
            if (returnValue)
            {
                if (m_excludedChannels != null && m_excludedChannels.Contains(channel.Name))
                {
                    returnValue = false;
                }
                else if (m_includedChannels != null && !m_includedChannels.Contains(channel.Name))
                {
                    returnValue = false;
                }
            }

            return returnValue;
        }

        //
        // Asset
        //

        // <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)
        {
            InternalAssert(GeneralChannel, condition, null, null);
        }

        //
        // Log
        //

        /// <summary>
        /// Log a Trace message to 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)
        {
            InternalLog(GeneralChannel, message, ELogLevel.Trace);
        }

        /// <summary>
        /// Log a Debug message to 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)
        {
            InternalLog(GeneralChannel, message, ELogLevel.Trace);
        }

        /// <summary>
        /// Log an Information message to 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)
        {
            InternalLog(GeneralChannel, message, ELogLevel.Information);
        }

        /// <summary>
        /// Log a Warning message to 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.
        ///
        /// 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)
        {
            InternalLog(GeneralChannel, message, ELogLevel.Warning);
        }

        /// <summary>
        /// Log an Error message to 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.
        ///
        /// 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)
        {
            InternalLog(GeneralChannel, message, ELogLevel.Error);
        }

        /// <summary>
        /// Log a Critical message to 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.
        ///
        /// 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)
        {
            InternalLog(GeneralChannel, message, ELogLevel.Critical);
        }

        /// <summary>
        /// Assert a condition and log an 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>
        /// <param name="message">Message to log.</param>
        [Conditional(HT_LOGGER_ASSERT_ON)]
        public void Assert(bool condition, object message)
        {
            Assert(condition, message, null);
        }

        /// <summary>
        /// Log an assertion message to 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.
        ///
        /// </summary>
        /// <param name="message">Message to log.</param>
        [Conditional(HT_LOGGER_ASSERT_ON)]
        public void LogAssertion(object message)
        {
            InternalLogAssertion(GeneralChannel, message, null);
        }

        /// <summary>
        /// Log an exception to all Logger streams and highlight in the hierarchy the object that the message applies to.
        ///
        /// 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.
        ///
        /// </summary>
        /// <param name="exception">Exception to log.</param>
        [Conditional(HT_LOGGER_EXCEPTION_ON)]
        public void LogException(System.Exception exception)
        {
            InternalLogException(GeneralChannel, exception, null);
        }

        //
        // Log with context
        //

        /// <summary>
        /// Log a Trace message to 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, UnityEngine.Object context)
        {
            InternalLog(GeneralChannel, message, ELogLevel.Trace, context);
        }

        /// <summary>
        /// Log a Debug message to 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, UnityEngine.Object context)
        {
            InternalLog(GeneralChannel, message, ELogLevel.Debug, context);
        }

        /// <summary>
        /// Log an Information message to 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, UnityEngine.Object context)
        {
            InternalLog(GeneralChannel, message, ELogLevel.Information, context);
        }

        /// <summary>
        /// Log a Warning message to 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.
        ///
        /// 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, UnityEngine.Object context)
        {
            InternalLog(GeneralChannel, message, ELogLevel.Warning, context);
        }

        /// <summary>
        /// Log an Error message to 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.
        ///
        /// 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, UnityEngine.Object context)
        {
            InternalLog(GeneralChannel, message, ELogLevel.Error, context);
        }

        /// <summary>
        /// Log a Critical message to 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.
        ///
        /// 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, UnityEngine.Object context)
        {
            InternalLog(GeneralChannel, message, ELogLevel.Critical, context);
        }

        /// <summary>
        /// Assert a condition, log an error message to 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.
        ///
        /// </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, UnityEngine.Object context)
        {
            InternalAssert(GeneralChannel, condition, message, context);
        }

        /// <summary>
        /// Log an assertion message to 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.
        ///
        /// </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, UnityEngine.Object context)
        {
            InternalLogAssertion(GeneralChannel, message, context);
        }

        /// <summary>
        /// Log an exception to all Logger streams and highlight in the hierarchy the object that the message applies to.
        ///
        /// 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.
        ///
        /// </summary>
        /// <param name="exception">Exception to log.</param>
        /// <param name="context">Object to which the message applies.</param>
        [Conditional(HT_LOGGER_EXCEPTION_ON)]
        public void LogException(System.Exception exception, UnityEngine.Object context)
        {
            InternalLogException(GeneralChannel, exception, context);
        }

        //
        // Log with format
        //

        /// <summary>
        /// Log a formated Trace message to 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)
        {
            InternalLog(GeneralChannel, string.Format(format, args), ELogLevel.Trace);
        }

        /// <summary>
        /// Log a formatted Debug message to 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)
        {
            InternalLog(GeneralChannel, string.Format(format, args), ELogLevel.Debug);
        }

        /// <summary>
        /// Log a formatted Information message to 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)
        {
            InternalLog(GeneralChannel, string.Format(format, args), ELogLevel.Information);
        }

        /// <summary>
        /// Log a formatted Warning message to 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.
        ///
        /// 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)
        {
            InternalLog(GeneralChannel, string.Format(format, args), ELogLevel.Warning);
        }

        /// <summary>
        /// Log a formatted Error message to 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.
        ///
        /// 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)
        {
            InternalLog(GeneralChannel, string.Format(format, args), ELogLevel.Error);
        }

        /// <summary>
        /// Log a formatted Critical message to 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.
        ///
        /// 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)
        {
            InternalLog(GeneralChannel, string.Format(format, args), ELogLevel.Critical);
        }

        /// <summary>
        /// Assert a condition and log a formatted 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>
        /// <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)
        {
            Assert(condition, string.Format(format, args));
        }

        /// <summary>
        /// Log a formatted assertion message to 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.
        ///
        /// </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)
        {
            LogAssertion(string.Format(format, args));
        }

        //
        // Log with context and format
        //

        /// <summary>
        /// Log a formated Trace message to 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(UnityEngine.Object context, string format, params object[] args)
        {
            InternalLog(GeneralChannel, string.Format(format, args), ELogLevel.Trace, context);
        }

        /// <summary>
        /// Log a formatted Debug message to 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(UnityEngine.Object context, string format, params object[] args)
        {
            InternalLog(GeneralChannel, string.Format(format, args), ELogLevel.Debug, context);
        }

        /// <summary>
        /// Log a formatted Information message to 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(UnityEngine.Object context, string format, params object[] args)
        {
            InternalLog(GeneralChannel, string.Format(format, args), ELogLevel.Information, context);
        }

        /// <summary>
        /// Log a formatted Warning message to 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.
        ///
        /// 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(UnityEngine.Object context, string format, params object[] args)
        {
            InternalLog(GeneralChannel, string.Format(format, args), ELogLevel.Warning, context);
        }

        /// <summary>
        /// Log a formatted Error message to 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.
        ///
        /// 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(UnityEngine.Object context, string format, params object[] args)
        {
            InternalLog(GeneralChannel, string.Format(format, args), ELogLevel.Error, context);
        }

        /// <summary>
        /// Log a formatted Critical message to 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.
        ///
        /// 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(UnityEngine.Object context, string format, params object[] args)
        {
            InternalLog(GeneralChannel, string.Format(format, args), ELogLevel.Critical, context);
        }

        /// <summary>
        /// Assert a condition, log a formatted error message to 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.
        ///
        /// </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, UnityEngine.Object context, string format, params object[] args)
        {
            Assert(condition, string.Format(format, args), context);
        }

        /// <summary>
        /// Log a formatted assertion message to 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.
        ///
        /// </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(UnityEngine.Object context, string format, params object[] args)
        {
            LogAssertion(string.Format(format, args), context);
        }

        //
        // Log with channel
        //

        /// <summary>
        /// Log a Trace message to a channel for all Logger streams.
        ///
        /// Use <c>Channel.LogTrace()</c> instead if you need more control over the channel.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</param>
        /// <param name="message">Message to log.</param>
        [Conditional(HT_LOGGER_TRACE_ON)]
        public void ChannelLogTrace(string channel, object message)
        {
            InternalLog(GetHelperChannel(channel), message, ELogLevel.Trace);
        }

        /// <summary>
        /// Log a Debug message to a channel for all Logger streams.
        ///
        /// Use <c>Channel.LogDebug()</c> instead if you need more control over the channel.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</param>
        /// <param name="message">Message to log.</param>
        [Conditional(HT_LOGGER_DEBUG_ON)]
        public void ChannelLogDebug(string channel, object message)
        {
            InternalLog(GetHelperChannel(channel), message, ELogLevel.Debug);
        }

        /// <summary>
        /// Log an Information message to a channel for all Logger streams.
        ///
        /// Use <c>Channel.LogInformation()</c> instead if you need more control over the channel.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</param>
        /// <param name="message">Message to log.</param>
        [Conditional(HT_LOGGER_INFORMATION_ON)]
        public void ChannelLogInformation(string channel, object message)
        {
            InternalLog(GetHelperChannel(channel), message, ELogLevel.Information);
        }

        /// <summary>
        /// Log a Warning message to a channel for all Logger streams.
        ///
        /// Use <c>Channel.LogWarning()</c> instead if you need more control over the channel.
        ///
        /// 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.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</param>
        /// <param name="message">Message to log.</param>
        [Conditional(HT_LOGGER_WARNING_ON)]
        public void ChannelLogWarning(string channel, object message)
        {
            InternalLog(GetHelperChannel(channel), message, ELogLevel.Warning);
        }

        /// <summary>
        /// Log an Error message to a channel for all Logger streams.
        ///
        /// Use <c>Channel.LogError()</c> instead if you need more control over the channel.
        ///
        /// 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.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</param>
        /// <param name="message">Message to log.</param>
        [Conditional(HT_LOGGER_ERROR_ON)]
        public void ChannelLogError(string channel, object message)
        {
            InternalLog(GetHelperChannel(channel), message, ELogLevel.Error);
        }

        /// <summary>
        /// Log a Critical message to a channel for all Logger streams.
        ///
        /// Use <c>Channel.LogCritical()</c> instead if you need more control over the channel.
        ///
        /// 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.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</param>
        /// <param name="message">Message to log.</param>
        [Conditional(HT_LOGGER_CRITICAL_ON)]
        public void ChannelLogCritical(string channel, object message)
        {
            InternalLog(GetHelperChannel(channel), message, ELogLevel.Critical);
        }

        /// <summary>
        /// Assert a condition and log an error message to a channel for all Logger streams on failure.
        ///
        /// Use <c>Channel.Assert()</c> instead if you need more control over the channel.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</param>
        /// <param name="condition">Condition you expect to be true.</param>
        /// <param name="message">Message to log.</param>
        [Conditional(HT_LOGGER_ASSERT_ON)]
        public void ChannelAssert(string channel, bool condition, object message)
        {
            InternalAssert(channel, condition, message);
        }

        /// <summary>
        /// Log an assertion message to a channel for all Logger streams.
        ///
        /// Use <c>Channel.LogAssertion()</c> instead if you need more control over the channel.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</param>
        /// <param name="message">Message to log.</param>
        [Conditional(HT_LOGGER_ASSERT_ON)]
        public void ChannelLogAssertion(string channel, object message)
        {
            InternalLogAssertion(channel, message, null);
        }

        //
        // Log with channel and context
        //

        /// <summary>
        /// Log a Trace message to a channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
        ///
        /// Use <c>Channel.LogTrace()</c> instead if you need more control over the channel.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</param>
        /// <param name="message">Message to log.</param>
        /// <param name="context">Object to which the message applies.</param>
        [Conditional(HT_LOGGER_TRACE_ON)]
        public void ChannelLogTrace(string channel, object message, UnityEngine.Object context)
        {
            InternalLog(GetHelperChannel(channel), message, ELogLevel.Trace, context);
        }

        /// <summary>
        /// Log a Debug message to a channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
        ///
        /// Use <c>Channel.LogDebug()</c> instead if you need more control over the channel.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</param>
        /// <param name="message">Message to log.</param>
        /// <param name="context">Object to which the message applies.</param>
        [Conditional(HT_LOGGER_DEBUG_ON)]
        public void ChannelLogDebug(string channel, object message, UnityEngine.Object context)
        {
            InternalLog(GetHelperChannel(channel), message, ELogLevel.Debug, context);
        }

        /// <summary>
        /// Log an Information message to a channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
        ///
        /// Use <c>Channel.LogInformation()</c> instead if you need more control over the channel.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</param>
        /// <param name="message">Message to log.</param>
        /// <param name="context">Object to which the message applies.</param>
        [Conditional(HT_LOGGER_INFORMATION_ON)]
        public void ChannelLogInformation(string channel, object message, UnityEngine.Object context)
        {
            InternalLog(GetHelperChannel(channel), message, ELogLevel.Information, context);
        }

        /// <summary>
        /// Log a Warning message to a channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
        ///
        /// Use <c>Channel.LogWarning<()/c> instead if you need more control over the channel.
        ///
        /// 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.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</param>
        /// <param name="message">Message to log.</param>
        /// <param name="context">Object to which the message applies.</param>
        [Conditional(HT_LOGGER_WARNING_ON)]
        public void ChannelLogWarning(string channel, object message, UnityEngine.Object context)
        {
            InternalLog(GetHelperChannel(channel), message, ELogLevel.Warning, context);
        }

        /// <summary>
        /// Log an Error message to a channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
        ///
        /// Use <c>Channel.LogError()</c> instead if you need more control over the channel.
        ///
        /// 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.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</param>
        /// <param name="message">Message to log.</param>
        /// <param name="context">Object to which the message applies.</param>
        [Conditional(HT_LOGGER_ERROR_ON)]
        public void ChannelLogError(string channel, object message, UnityEngine.Object context)
        {
            InternalLog(GetHelperChannel(channel), message, ELogLevel.Error, context);
        }

        /// <summary>
        /// Log a Critical message to a channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
        ///
        /// Use <c>Channel.LogCritical()</c> instead if you need more control over the channel.
        ///
        /// 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.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</param>
        /// <param name="message">Message to log.</param>
        /// <param name="context">Object to which the message applies.</param>
        [Conditional(HT_LOGGER_CRITICAL_ON)]
        public void ChannelLogCritical(string channel, object message, UnityEngine.Object context)
        {
            InternalLog(GetHelperChannel(channel), message, ELogLevel.Critical, context);
        }

        /// <summary>
        /// Assert a condition, log an error message to a channel for all Logger streams on failure and highlight in the hierarchy the object that the message applies to.
        ///
        /// Use <c>Channel.Assert()</c> instead if you need more control over the channel.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</param>
        /// <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 ChannelAssert(string channel, bool condition, object message, UnityEngine.Object context)
        {
            InternalAssert(channel, condition, message, context);
        }

        /// <summary>
        /// Log an assertion message to a channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
        ///
        /// Use <c>Channel.LogAssertion()</c> instead if you need more control over the channel.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</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 ChannelLogAssertion(string channel, object message, UnityEngine.Object context)
        {
            InternalLogAssertion(channel, message, context);
        }

        //
        // Log with channel and format
        //

        /// <summary>
        /// Log a formated Trace message to a channel for all Logger streams.
        ///
        /// Use <c>Channel.LogTraceFormat()</c> instead if you need more control over the channel.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</param>
        /// <param name="format">A composite format string.</param>
        /// <param name="args">Format arguments.</param>
        [Conditional(HT_LOGGER_TRACE_ON)]
        public void ChannelLogTraceFormat(string channel, string format, params object[] args)
        {
            InternalLog(GetHelperChannel(channel), string.Format(format, args), ELogLevel.Trace);
        }

        /// <summary>
        /// Log a formatted Debug message to a channel for all Logger streams.
        ///
        /// Use <c>Channel.LogDebugFormat()</c> instead if you need more control over the channel.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</param>
        /// <param name="format">A composite format string.</param>
        /// <param name="args">Format arguments.</param>
        [Conditional(HT_LOGGER_DEBUG_ON)]
        public void ChannelLogDebugFormat(string channel, string format, params object[] args)
        {
            InternalLog(GetHelperChannel(channel), string.Format(format, args), ELogLevel.Debug);
        }

        /// <summary>
        /// Log a formatted Information message to a channel for all Logger streams.
        ///
        /// Use <c>Channel.LogInformationFormat()</c> instead if you need more control over the channel.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</param>
        /// <param name="format">A composite format string.</param>
        /// <param name="args">Format arguments.</param>
        [Conditional(HT_LOGGER_INFORMATION_ON)]
        public void ChannelLogInformationFormat(string channel, string format, params object[] args)
        {
            InternalLog(GetHelperChannel(channel), string.Format(format, args), ELogLevel.Information);
        }

        /// <summary>
        /// Log a formatted Warning message to a channel for all Logger streams.
        ///
        /// Use <c>Channel.LogWarningFormat()</c> instead if you need more control over the channel.
        ///
        /// 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.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</param>
        /// <param name="format">A composite format string.</param>
        /// <param name="args">Format arguments.</param>
        [Conditional(HT_LOGGER_WARNING_ON)]
        public void ChannelLogWarningFormat(string channel, string format, params object[] args)
        {
            InternalLog(GetHelperChannel(channel), string.Format(format, args), ELogLevel.Warning);
        }

        /// <summary>
        /// Log a formatted Error message to a channel for all Logger streams.
        ///
        /// Use <c>Channel.LogErrorFormat()</c> instead if you need more control over the channel.
        ///
        /// 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.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</param>
        /// <param name="format">A composite format string.</param>
        /// <param name="args">Format arguments.</param>
        [Conditional(HT_LOGGER_ERROR_ON)]
        public void ChannelLogErrorFormat(string channel, string format, params object[] args)
        {
            InternalLog(GetHelperChannel(channel), string.Format(format, args), ELogLevel.Error);
        }

        /// <summary>
        /// Log a formatted Critical message to a channel for all Logger streams.
        ///
        /// Use <c>Channel.LogCriticalFormat()</c> instead if you need more control over the channel.
        ///
        /// 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.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</param>
        /// <param name="format">A composite format string.</param>
        /// <param name="args">Format arguments.</param>
        [Conditional(HT_LOGGER_CRITICAL_ON)]
        public void ChannelLogCriticalFormat(string channel, string format, params object[] args)
        {
            InternalLog(GetHelperChannel(channel), string.Format(format, args), ELogLevel.Critical);
        }

        /// <summary>
        /// Assert a condition and log a formatted error message to a channel for all Logger streams on failure.
        ///
        /// Use <c>Channel.AssertFormat()</c> instead if you need more control over the channel.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</param>
        /// <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 ChannelAssertFormat(string channel, bool condition, string format, params object[] args)
        {
            InternalAssert(channel, condition, string.Format(format, args));
        }

        /// <summary>
        /// Log a formatted assertion message to a channel for all Logger streams.
        ///
        /// Use <c>Channel.LogAssertion()</c> instead if you need more control over the channel.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</param>
        /// <param name="format">A composite format string.</param>
        /// <param name="args">Format arguments.</param>
        [Conditional(HT_LOGGER_ASSERT_ON)]
        public void ChannelLogAssertion(string channel, string format, params object[] args)
        {
            InternalLogAssertion(channel, string.Format(format, args), null);
        }

        //
        // Log with channel, context and format
        //

        /// <summary>
        /// Log a formated Trace message to a channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
        ///
        /// Use <c>Channel.LogTraceFormat()</c> instead if you need more control over the channel.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</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_TRACE_ON)]
        public void ChannelLogTraceFormat(string channel, UnityEngine.Object context, string format, params object[] args)
        {
            InternalLog(GetHelperChannel(channel), string.Format(format, args), ELogLevel.Trace, context);
        }

        /// <summary>
        /// Log a formatted Debug message to a channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
        ///
        /// Use <c>Channel.LogDebugFormat()</c> instead if you need more control over the channel.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</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_DEBUG_ON)]
        public void ChannelLogDebugFormat(string channel, UnityEngine.Object context, string format, params object[] args)
        {
            InternalLog(GetHelperChannel(channel), string.Format(format, args), ELogLevel.Debug, context);
        }

        /// <summary>
        /// Log a formatted Information message to a channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
        ///
        /// Use <c>Channel.LogInformationFormat()</c> instead if you need more control over the channel.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</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_INFORMATION_ON)]
        public void ChannelLogInformationFormat(string channel, UnityEngine.Object context, string format, params object[] args)
        {
            InternalLog(GetHelperChannel(channel), string.Format(format, args), ELogLevel.Information, context);
        }

        /// <summary>
        /// Log a formatted Warning message to a channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
        ///
        /// Use <c>Channel.LogWarningFormat()</c> instead if you need more control over the channel.
        ///
        /// 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.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</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_WARNING_ON)]
        public void ChannelLogWarningFormat(string channel, UnityEngine.Object context, string format, params object[] args)
        {
            InternalLog(GetHelperChannel(channel), string.Format(format, args), ELogLevel.Warning, context);
        }

        /// <summary>
        /// Log a formatted Error message to a channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
        ///
        /// Use <c>Channel.LogErrorFormat()</c> instead if you need more control over the channel.
        ///
        /// 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.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</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_ERROR_ON)]
        public void ChannelLogErrorFormat(string channel, UnityEngine.Object context, string format, params object[] args)
        {
            InternalLog(GetHelperChannel(channel), string.Format(format, args), ELogLevel.Error, context);
        }

        /// <summary>
        /// Log a formatted Critical message to a channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
        ///
        /// Use <c>Channel.LogCriticalFormat()</c> instead if you need more control over the channel.
        ///
        /// 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.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</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_CRITICAL_ON)]
        public void ChannelLogCriticalFormat(string channel, UnityEngine.Object context, string format, params object[] args)
        {
            InternalLog(GetHelperChannel(channel), string.Format(format, args), ELogLevel.Critical, context);
        }

        /// <summary>
        /// Assert a condition, log a formatted error message to a channel for all Logger streams on failure and highlight in the hierarchy the object that the message applies to.
        ///
        /// Use <c>Channel.AssertFormat()</c> instead if you need more control over the channel.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</param>
        /// <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 ChannelAssertFormat(string channel, bool condition, UnityEngine.Object context, string format, params object[] args)
        {
            InternalAssert(channel, condition, string.Format(format, args), context);
        }

        /// <summary>
        /// Log a formatted assertion message to a channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
        ///
        /// Use <c>Channel.LogAssertion()</c> instead if you need more control over the channel.
        ///
        /// 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="channel">Used to identify the source of a log message so messages can be filtered out.</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 ChannelLogAssertion(string channel, UnityEngine.Object context, string format, params object[] args)
        {
            InternalLogAssertion(channel, string.Format(format, args), context);
        }
    }
}