#if HT_PACKAGE_ZLOGGER_PROD
using System.Collections.Generic;
using Microsoft.Extensions.Logging;

using UnityEngine;

using Cysharp.Text;
using ZLogger;

namespace Ubisoft.Hotel.Logger
{
    internal class HtLogger_ImpZLogger : HtLogger_Imp
    {
        private ILoggerFactory m_loggerFactory;
        private Dictionary<string, Microsoft.Extensions.Logging.ILogger> m_loggers;
        private HtLogger_ImpUnity m_loggerUnity;

        internal override void Init(PlayerLoggerProperty property)
        {
            if (property != null && property.MinLogLevel != HtLogger.ELogLevel.None)
            {
                LogLevel minLogLevel = ELogLevelToLogLevel(property.MinLogLevel);

                if (property.IsUnityLoggerEnabled)
                {
                    m_loggerUnity = new HtLogger_ImpUnity();
                }

                // Standard LoggerFactory does not work on IL2CPP,
                // But you can use ZLogger's UnityLoggerFactory instead,
                // it works on IL2CPP, all platforms(includes mobile).
                m_loggerFactory = UnityLoggerFactory.Create(builder =>
                {
                    // or more configuration, you can use builder.AddFilter
                    _ = builder.SetMinimumLevel(minLogLevel);

                    //ILoggingBuilder loggingBuilder = builder.AddZLoggerConsole();
                    //builder.AddZLoggerUnityDebug();

                    if (property.MaxSizeFile > 0)
                    {
                        _ = builder.AddZLoggerFile(GetFileNamePath("hotel.log"), "file-plain", x =>
                        {
                            x.PrefixFormatter = (writer, info) => ZString.Utf8Format(writer, "{0}ϩ{1}ϩ{2}ϩ", info.Timestamp.ToLocalTime().DateTime, info.LogLevel, info.CategoryName);
                            //x.MaxSize = property.MaxSizeFile * 1024;
                            //x.SuffixFormatter = (writer, info) => ZString.Utf8Format(writer, "ϩ{0}¬", info.Callstack);
                        });

                        /*
                        builder.AddZLoggerRollingFile(fileNameSelector: (dt, x) => $"zlogs/{dt.ToLocalTime():yyyy-MM-dd}_{x:000}.log",
                        timestampPattern: x => x.ToLocalTime().Date,
                        rollSizeKB: 64);*/
                    }
                });

                Application.quitting += () =>
                {
                    // when quit, flush unfinished log entries.
                    m_loggerFactory.Dispose();
                };
            }
        }

        private string GetFileNamePath(string fileName)
        {
            bool isEditor = Application.isEditor;
            string root = isEditor ? string.Empty : Application.persistentDataPath;
            string separator = isEditor ? string.Empty : "/";
            string returnValue = ZString.Format("{0}{1}{2}", root, separator, fileName);

            return returnValue;
        }

        private Microsoft.Extensions.Logging.ILogger CreateLogger(string channel) => m_loggerFactory.CreateLogger(channel);

        private Microsoft.Extensions.Logging.ILogger GetLogger(string channel)
        {
            if (string.IsNullOrEmpty(channel))
            {
                channel = HtLogger.CHANNEL_GENERAL_NAME;
            }

            if (m_loggers == null)
            {
                m_loggers = new Dictionary<string, Microsoft.Extensions.Logging.ILogger>();
            }

            if (!m_loggers.TryGetValue(channel, out Microsoft.Extensions.Logging.ILogger returnValue))
            {
                returnValue = CreateLogger(channel);
                m_loggers.Add(channel, returnValue);
            }

            return returnValue;
        }

        private LogLevel ELogLevelToLogLevel(HtLogger.ELogLevel value)
        {
            LogLevel returnValue = LogLevel.None;

            switch (value)
            {
                case HtLogger.ELogLevel.Trace:
                    returnValue = LogLevel.Trace;
                    break;

                case HtLogger.ELogLevel.Debug:
                    returnValue = LogLevel.Debug;
                    break;

                case HtLogger.ELogLevel.Information:
                    returnValue = LogLevel.Information;
                    break;

                case HtLogger.ELogLevel.Warning:
                    returnValue = LogLevel.Warning;
                    break;

                case HtLogger.ELogLevel.Error:
                    returnValue = LogLevel.Error;
                    break;

                case HtLogger.ELogLevel.Critical:
                    returnValue = LogLevel.Critical;
                    break;
            }

            return returnValue;
        }

        internal override void Log(HtLogger.Channel channel, object message, HtLogger.ELogLevel logLevel, Object context = null)
        {
            Microsoft.Extensions.Logging.ILogger logger = GetLogger(channel.Name);
            logger.ZLog(ELogLevelToLogLevel(logLevel), (string)message);

            if (m_loggerUnity != null)
            {
                m_loggerUnity.Log(channel, message, logLevel, context);
            }
        }

        internal override void Assert(HtLogger.Channel channel, bool condition, object message, Object context = null)
        {
            if (message == null)
            {
                message = "Assertion failed";
            }

            Microsoft.Extensions.Logging.ILogger logger = GetLogger(channel.Name);
            logger.ZLog(ELogLevelToLogLevel(HtLogger.ELogLevel.Error), (string)message);

            if (m_loggerUnity != null)
            {
                m_loggerUnity.Assert(channel, condition, message, context);
            }
        }

        internal override void LogAssertion(HtLogger.Channel channel, object message, Object context)
        {
            Microsoft.Extensions.Logging.ILogger logger = GetLogger(channel.Name);
            logger.ZLog(ELogLevelToLogLevel(HtLogger.ELogLevel.Error), (string)message);

            if (m_loggerUnity != null)
            {
                m_loggerUnity.LogAssertion(channel, message, context);
            }
        }

        internal override void LogException(HtLogger.Channel channel, System.Exception exception, Object context)
        {
            string message = exception.ToString();
            Log(channel, message, HtLogger.ELogLevel.Error, context);
        }
    }
}
#endif