using NLog;
using NLog.Config;
using NLog.Targets;
using NLog.Targets.Wrappers;
using System;
using System.IO;
using System.Linq;
using Xylem.Common.CommonCore.Consts;

namespace Xylem.Common.Utils.Logging
{
    [Serializable]
    public static class NLogHelper
    {
        private static readonly String CurrentConfigDir =
            Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
                ProgramConfig.GenesisBaseFolder);
        private const String CurrentConfigFile = ProgramConfig.NlogConfig;

        public static String GetCurrentApplicationFolder()
        {
            return Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location),
                    CurrentConfigFile);
        }
        public static String GetApplicationDataPath()
        {
            return Path.Combine(CurrentConfigDir, CurrentConfigFile);
        }

        public static readonly Lazy<XmlLoggingConfiguration> XmlConfig = new Lazy<XmlLoggingConfiguration>(() =>
         {
             //if file exist in ApplicationData use this
             try
             {
                 if (File.Exists(GetApplicationDataPath()))
                 {
                     return new XmlLoggingConfiguration(GetApplicationDataPath());
                 }
             }
             catch (Exception)
             {
             }

             try
             {
                 if (File.Exists(GetCurrentApplicationFolder()))
                 {
                     return new XmlLoggingConfiguration(GetCurrentApplicationFolder());
                 }
             }
             catch (Exception)
             {
             }


             return null;
         });

        public static string GetPath(ILogger logger)
        {
            string fileName = "";
            var target = logger.Factory.Configuration.FindTargetByName(logger.Name);
            if (target != null)
            {
                if (target is BufferingTargetWrapper buffTarget)
                {
                    target = buffTarget.WrappedTarget;
                }


                if (target is FileTarget fileTarget)
                {
                    var logEventInfo = new LogEventInfo { TimeStamp = DateTime.Now };
                    fileName = fileTarget.FileName.Render(logEventInfo);
                }

            }
            
            else
            {

               
            }


           return fileName;

        }
        public static ILogger CreateOrGetLogger(String name)
        {
            return new LogFactory(XmlConfig.Value).GetLogger(name);
        }
        public static ILogger CreateOrGetMultiLogger(String ident, String identText = "Slot", String type = "Meter", String baseTarget = null, String baseRule = null)
        {

            //var loggerTargetName = $"Target_{type}_{identText}{ident}";
            //var loggerRuleName = $"Rule_{type}_{identText}{ident}";
            var loggerTargetName = $"{ident}";
            var loggerRuleName = $"{ident}";
            if (XmlConfig.Value.FindTargetByName(loggerTargetName) == null || !XmlConfig.Value.LoggingRules.Any(a => a.LoggerNamePattern.Equals(loggerRuleName)))
            {
                //No logger matches, create a new one
                if (string.IsNullOrEmpty(baseTarget))
                {
                    baseTarget = $"{type}Base";
                }
                if (string.IsNullOrEmpty(baseRule))
                {
                    baseRule = $"{type}Base";
                }
                BufferingTargetWrapper newWrapper = null;
                FileTarget newTarget;
                var baseLogger = XmlConfig.Value.FindTargetByName(baseTarget);
                if (baseLogger == null)
                {
                    newTarget = new FileTarget(loggerTargetName)
                    {
                        FileName = $"{ProgramConfig.BaseLoggingPath}{type}_{identText}{ident}.log"
                    };
                }
                else
                {
                    newTarget = new FileTarget(loggerTargetName);

                    if (baseLogger is BufferingTargetWrapper)
                    {
                        var baseWrapperLogger = ((BufferingTargetWrapper)baseLogger);
                        newWrapper = new BufferingTargetWrapper(loggerTargetName, newTarget);
                        newWrapper.SlidingTimeout = baseWrapperLogger.SlidingTimeout;
                        newWrapper.OptimizeBufferReuse = baseWrapperLogger.OptimizeBufferReuse;
                        newWrapper.FlushTimeout = baseWrapperLogger.FlushTimeout;
                        newWrapper.BufferSize = baseWrapperLogger.BufferSize;


                        baseLogger = ((BufferingTargetWrapper)baseLogger).WrappedTarget;
                    }

                    if (baseLogger is FileTarget)
                    {
                        var baseFileLogger = ((FileTarget)baseLogger);
                        newTarget.FileName = baseFileLogger.FileName.ToString().Replace("'", "").Replace("BASE", $"{identText}{ident.Replace("LedRawData", "")}");
                        newTarget.ArchiveFileName = baseFileLogger.ArchiveFileName.ToString().Replace("'", "").Replace("BASE", $"{identText}{ident.Replace("LedRawData", "")}");

                        newTarget.ArchiveAboveSize = baseFileLogger.ArchiveAboveSize;
                        newTarget.ArchiveDateFormat = baseFileLogger.ArchiveDateFormat;
                        newTarget.ArchiveEvery = baseFileLogger.ArchiveEvery;
                        newTarget.ArchiveFileKind = baseFileLogger.ArchiveFileKind;
                        newTarget.ArchiveNumbering = baseFileLogger.ArchiveNumbering;
                        newTarget.ArchiveOldFileOnStartup = baseFileLogger.ArchiveOldFileOnStartup;
                        newTarget.AutoFlush = baseFileLogger.AutoFlush;
                        newTarget.BufferSize = baseFileLogger.BufferSize;
                        newTarget.CleanupFileName = baseFileLogger.CleanupFileName;
                        newTarget.ConcurrentWriteAttemptDelay = baseFileLogger.ConcurrentWriteAttemptDelay;

                        newTarget.ConcurrentWriteAttempts = baseFileLogger.ConcurrentWriteAttempts;
                        newTarget.ConcurrentWrites = baseFileLogger.ConcurrentWrites;
                        newTarget.CreateDirs = baseFileLogger.CreateDirs;
                        newTarget.DeleteOldFileOnStartup = baseFileLogger.DeleteOldFileOnStartup;
                        newTarget.DiscardAll = baseFileLogger.DiscardAll;
                        newTarget.EnableArchiveFileCompression = baseFileLogger.EnableArchiveFileCompression;
                        newTarget.EnableFileDelete = baseFileLogger.EnableFileDelete;
                        newTarget.Encoding = baseFileLogger.Encoding;
                        newTarget.FileAttributes = baseFileLogger.FileAttributes;
                        newTarget.FileNameKind = baseFileLogger.FileNameKind;
                        newTarget.Footer = baseFileLogger.Footer;
                        newTarget.ForceManaged = baseFileLogger.ForceManaged;
                        newTarget.ForceMutexConcurrentWrites = baseFileLogger.ForceMutexConcurrentWrites;
                        newTarget.Header = baseFileLogger.Header;
                        newTarget.KeepFileOpen = baseFileLogger.KeepFileOpen;
                        newTarget.Layout = baseFileLogger.Layout;
                        newTarget.LineEnding = baseFileLogger.LineEnding;
                        newTarget.MaxArchiveFiles = baseFileLogger.MaxArchiveFiles;
                        //newTarget.maxLogFilenames = baseFileLogger.maxLogFilenames;

                        newTarget.NetworkWrites = baseFileLogger.NetworkWrites;
                        newTarget.OpenFileCacheSize = baseFileLogger.OpenFileCacheSize;
                        newTarget.OpenFileCacheTimeout = baseFileLogger.OpenFileCacheTimeout;
                        newTarget.OptimizeBufferReuse = baseFileLogger.OptimizeBufferReuse;
                        newTarget.ReplaceFileContentsOnEachWrite = baseFileLogger.ReplaceFileContentsOnEachWrite;
                        newTarget.WriteFooterOnArchivingOnly = baseFileLogger.WriteFooterOnArchivingOnly;



                    }
                }

                Target setupDoneOnTarget = newTarget;
                if (newWrapper != null)
                {
                    XmlConfig.Value.AddTarget(newWrapper.Name, newWrapper);
                    setupDoneOnTarget = newWrapper;
                }
                else
                {
                    XmlConfig.Value.AddTarget(newTarget.Name, newTarget);
                }

                var newBaseRule = XmlConfig.Value.LoggingRules.FirstOrDefault(f => f.LoggerNamePattern.Equals(baseRule));
                LoggingRule newRule;
                if (newBaseRule == null)
                {
                    newRule = new LoggingRule(loggerRuleName, LogLevel.Debug, setupDoneOnTarget);
                }
                else
                {
                    newRule = new LoggingRule(loggerRuleName, newBaseRule.Levels.Min(), setupDoneOnTarget);
                }

                XmlConfig.Value.LoggingRules.Add(newRule);

            }


            var t = new LogFactory(XmlConfig.Value).GetLogger(loggerRuleName);

            return t;

        }
    }
}