EonaCat.Logger/EonaCat.Logger/Managers/LogManager.cs

using EonaCat.logger.Managers;
using EonaCat.Logger.Exceptions;
using EonaCat.Logger.Extensions;
using EonaCat.Logger.Helpers;
using EonaCat.Logger.Syslog;
using EonaCatLogger.EonaCatCoreLogger.Models;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Threading;
using System.Threading.Tasks;

namespace EonaCat.Logger.Managers
{
    // This file is part of the EonaCat project(s) which is released under the Apache License.
    // See the LICENSE file or go to https://EonaCat.com/License for full license details.

    public partial class LogManager : ILogManager, IDisposable
    {
        private readonly object _batton = new object();
        private DateTime _logDate;
        public event LogDelegate OnLog;
        public delegate void LogDelegate(LogManager logger, ELogType logLevel, EonaCatLogMessage message);


        public ELogType LogType;
        private ILoggerProvider LoggerProvider { get; set; }
        private ILoggerFactory LoggerFactory { get; set; }
        private ILogger Logger { get; set; }
        public string CurrentLogFile => LoggerProvider != null ? ((FileLoggerProvider)LoggerProvider).LogFile : string.Empty;

        public bool IsRunning { get; private set; }

        public StreamWriter Output { get; private set; }
        
        public string CategoryName { get; set; }

        public readonly string Id;

        private bool _disposed;
        private static LogManager _instance;
        private LoggerSettings _settings;
        private CancellationTokenSource _TokenSource = new CancellationTokenSource();
        private CancellationToken _Token;

        /// <summary>
        /// Default Logger Instance with it's default configuration
        /// </summary>
        public static LogManager Instance => InstanceInit();

        /// <summary>
        /// Logging settings.
        /// </summary>
        public LoggerSettings Settings
        {
            get
            {
                if (_settings == null)
                {
                    _settings = new LoggerSettings();
                }
                return _settings;
            }

            set
            {
                _settings = value;
            }
        }

        private static LogManager InstanceInit()
        {
            if (_instance == null)
            {
                _instance = new LogManager(null, id: "EonaCat");
            }
            return _instance;
        }

        protected virtual void Dispose(bool disposing)
        {
            lock (this)
            {
                if (_disposed)
                {
                    return;
                }

                if (disposing)
                {
                    StopLogging();
                    _TokenSource.Cancel();
                }

                _disposed = true;
            }
        }

        private void StartNewLog()
        {
            if (_TokenSource.IsCancellationRequested)
            {
                return;
            }

            DateTime now = DateTime.Now;

            if (IsRunning && now.Date > _logDate.Date)
            {
                StopLogging();
            }
            IsRunning = true;

            IServiceCollection serviceCollection = new ServiceCollection();
            serviceCollection.AddLogging(builder => builder.AddEonaCatFileLogger(configuration =>
            {
                configuration = Settings.FileLoggerOptions;
            }));

            var serviceProvider = serviceCollection.BuildServiceProvider();
            LoggerProvider = serviceProvider.GetService<ILoggerProvider>();
            LoggerFactory = serviceProvider.GetService<ILoggerFactory>();

            CategoryName = CategoryName ?? string.Empty;
            Logger = LoggerFactory.CreateLogger(CategoryName);

            if (!Directory.Exists(Settings.FileLoggerOptions.LogDirectory))
            {
                Directory.CreateDirectory(Settings.FileLoggerOptions.LogDirectory);
            }

            _logDate = now;

            Write(now, $"{DllInfo.ApplicationName} started.");
        }

        public void Assert(bool condition, string message)
        {
            if (!condition)
            {
                throw new EonaCatLoggerAssertionException(message);
            }
        }

        private void Write(DateTime dateTime, string message, ELogType logType = ELogType.INFO)
        {
            if (string.IsNullOrWhiteSpace(message)) return;
            if (logType < ELogType.INFO) return;

            string remainder = "";
            string currentMessage;

            if (message.Length > _settings.MaxMessageLength)
            {
                currentMessage = message.Substring(0, _settings.MaxMessageLength);
                remainder = message.Substring(_settings.MaxMessageLength, (message.Length - _settings.MaxMessageLength));
            }
            else
            {
                currentMessage = message;
            }

            var fullMessage = LogHelper.FormatMessageWithHeader(_settings, logType, currentMessage);

            LogHelper.SendConsole(_settings, logType, fullMessage);

            LogHelper.SendFile(Logger, _settings, logType, fullMessage);

            LogHelper.SendToSysLogServers(_settings, fullMessage);

            if (!string.IsNullOrEmpty(remainder))
            {
                Write(dateTime, remainder, logType);
            }

            var EonaCatMessage = new EonaCatLogMessage { DateTime = dateTime, Message = currentMessage, LogType = logType };
            OnLog?.Invoke(this, logType, EonaCatMessage);
        }

        public void Reset() => OnLog = null;

        public LogManager(LoggerSettings settings, string serverIp, int serverPort, string id = "EonaCatLogger")
        {
            if (string.IsNullOrEmpty(serverIp)) throw new ArgumentNullException(nameof(serverIp));
            if (serverPort < 0) throw new ArgumentException("Server port must be zero or greater.");

            settings.SysLogServers = new List<SyslogServer>();
            settings.SysLogServers.Add(new SyslogServer(serverIp, serverPort));

            Id = id;
            Settings = settings;
            SetupLogManager();
        }

        public LogManager(LoggerSettings settings, string id = "EonaCatLogger")
        {
            Id = id;
            Settings = settings;
            SetupFileLogger(settings, null, true);
            SetupLogManager();
        }

        private void SetupFileLogger(LoggerSettings settings = null, string logFolder = null, bool defaultPrefix = true)
        {
            if (settings == null)
            {
                // Create default loggingSettings
                Settings = settings;
                settings = Settings;
            }

            if (!settings.EnableFileLogging) return;
            
            if (logFolder != null)
            {
                Settings.FileLoggerOptions.LogDirectory = logFolder;
            }

            if (defaultPrefix)
            {
                Settings.FileLoggerOptions.FileNamePrefix = "EonaCat";
            }
            else
            {
                Settings.FileLoggerOptions.FileNamePrefix = string.Empty;
            }
        }

        private void SetupLogManager()
        {
            _Token = _TokenSource.Token;
            AppDomain.CurrentDomain.ProcessExit += ProcessExit;

            Console.CancelKeyPress += new ConsoleCancelEventHandler(Console_CancelKeyPress);

            _logDate = DateTime.Now;
        }

        void Console_CancelKeyPress(object sender, ConsoleCancelEventArgs e)
        {
            Dispose(true);
        }

        private void ProcessExit(object sender, EventArgs e)
        {
            Dispose(true);
        }

        private void StopLogging()
        {
            IsRunning = false;
            Write(DateTime.Now, $"{DllInfo.ApplicationName} stopped.");
            Task.Delay(500);
        }

        public LogManager(string logFolder = null, bool defaultPrefix = true)
        {
            SetupFileLogger(null, logFolder, defaultPrefix);
            SetupLogManager();
        }

        public void Write(Exception exception, string module = null, string method = null, bool criticalException = false)
        {
            if (exception != null) return;
            Write(exception.FormatExceptionToMessage(module, method), criticalException ? ELogType.CRITICAL : ELogType.ERROR);
        }

        public void Write(string message, ELogType logType = ELogType.INFO, ELogType? logLevel = null)
        {
            lock (_batton)
            {
                if (logLevel == null)
                {
                    logLevel = DllInfo.LogLevel;
                }

                if (logType == ELogType.CRITICAL || logLevel.GetValueOrDefault() <= logType)
                {
                    DateTime now = DateTime.Now;

                    if (!IsRunning)
                    {
                        StartNewLog();
                    }

                    Write(now, message, logType);
                }
            }
        }

        public void DeleteCurrentLogFile()
        {
            lock (this)
            {
                if (!string.IsNullOrWhiteSpace(CurrentLogFile))
                {
                    File.Delete(CurrentLogFile);
                }
            }
        }

        void IDisposable.Dispose()
        {
            Dispose(true);
        }
    }
}