using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Tango.Logging
{
    /// <summary>
    /// Represents a helper class for logging information and errors.
    /// </summary>
    public class LogManager
    {
        private List<ILogger> _loggers;
        private ProducerConsumerQueue<LogItemBase> _logs;
        private Thread _loggingThread;
        private bool _isStarted;

        /// <summary>
        /// Occurs when a new log as been received.
        /// </summary>
        public event EventHandler<LogItemBase> NewLog;

        /// <summary>
        /// Gets the registered loggers.
        /// </summary>
        public List<ILogger> RegisteredLoggers
        {
            get { return _loggers.ToList(); }
        }

        private static LogManager _default;
        /// <summary>
        /// Gets the default log manager instance.
        /// </summary>
        public static LogManager Default
        {
            get
            {
                if (_default == null)
                {
                    _default = new LogManager();
                }

                return _default;
            }
        }

        /// <summary>
        /// Initializes the <see cref="LogManager"/> class.
        /// </summary>
        public LogManager()
        {
            _loggers = new List<ILogger>();
            _logs = new ProducerConsumerQueue<LogItemBase>();
            Categories = new List<LogCategory>();

            Categories.Add(LogCategory.Critical);
            Categories.Add(LogCategory.Error);
            Categories.Add(LogCategory.Info);
            Categories.Add(LogCategory.Warning);
        }

        /// <summary>
        /// Gets or sets the logging categories filter.
        /// </summary>
        public List<LogCategory> Categories { get; private set; }

        /// <summary>
        /// Registers a logger.
        /// </summary>
        /// <param name="logger">The logger.</param>
        public void RegisterLogger(ILogger logger)
        {
            if (logger != null && !_loggers.Contains(logger))
            {
                _loggers.Add(logger);
            }
        }

        /// <summary>
        /// Unregisters a logger.
        /// </summary>
        /// <param name="logger">The logger.</param>
        public void UnregisterLogger(ILogger logger)
        {
            if (logger != null && _loggers.Contains(logger))
            {
                _loggers.Remove(logger);
            }
        }

        /// <summary>
        /// Add new exception log item.
        /// </summary>
        /// <param name="e">Exception.</param>
        /// <param name="description">Error description.</param>
        public Exception Log(Exception e, String description = null, [CallerMemberName] string caller = null, [CallerFilePath] string file = null, [CallerLineNumber] int lineNumber = 0)
        {
            return Log(e, LogCategory.Error, description, caller, file, lineNumber);
        }

        /// <summary>
        /// Add new exception log item.
        /// </summary>
        /// <param name="e">Exception.</param>
        /// <param name="description">Error description.</param>
        public Exception Log(Exception e, LogCategory category, String description = null, [CallerMemberName] string caller = null, [CallerFilePath] string file = null, [CallerLineNumber] int lineNumber = 0)
        {
            if (!Categories.Contains(category)) return e;

            ExceptionLogItem log = new ExceptionLogItem();
            log.CallerMethodName = caller;
            log.CallerFile = file;
            log.CallerLineNumber = lineNumber;
            log.TimeStamp = DateTime.Now;
            log.Exception = e;
            log.Category = category;
            log.Description = description;
            log.Message = log.Description + Environment.NewLine + log.Exception.FlattenException();

            AppendLog(log);

            return e;
        }

        /// <summary>
        /// Add new message log item.
        /// </summary>
        /// <param name="message">Message.</param>
        public String Log(String message, [CallerMemberName] string caller = null, [CallerFilePath] string file = null, [CallerLineNumber] int lineNumber = 0)
        {
            return Log(message, LogCategory.Info, null, caller, file, lineNumber);
        }

        /// <summary>
        /// Add new message log item.
        /// </summary>
        /// <param name="message">Message.</param>
        public String Log(String message, LogCategory category, [CallerMemberName] string caller = null, [CallerFilePath] string file = null, [CallerLineNumber] int lineNumber = 0)
        {
            return Log(message, category, null, caller, file, lineNumber);
        }

        /// <summary>
        /// Add new message log item.
        /// </summary>
        /// <param name="message">Message.</param>
        public String Log(String message, LogCategory category, Object logObject, [CallerMemberName] string caller = null, [CallerFilePath] string file = null, [CallerLineNumber] int lineNumber = 0)
        {
            if (!Categories.Contains(category)) return message;

            MessageLogItem log = new MessageLogItem();
            log.CallerMethodName = caller;
            log.CallerFile = file;
            log.CallerLineNumber = lineNumber;
            log.TimeStamp = DateTime.Now;
            log.Category = category;
            log.Message = message;
            log.LogObject = logObject;

            AppendLog(log);

            return message;
        }

        /// <summary>
        /// Appends the specified log item.
        /// </summary>
        /// <param name="logItem">The log item.</param>
        public void Log(LogItemBase logItem)
        {
            AppendLog(logItem);
        }

        /// <summary>
        /// Logs the current referenced assemblies in the app domain.
        /// </summary>
        public void LogReferencedAssemblies()
        {
            String log = "--------------------- Referenced Assemblies --------------------------" + Environment.NewLine + Environment.NewLine;

            try
            {
                string codeBase = typeof(LogManager).Assembly.CodeBase;
                UriBuilder uri = new UriBuilder(codeBase);
                string path = Uri.UnescapeDataString(uri.Path);
                String folder = Path.GetDirectoryName(path);

                foreach (var file in Directory.GetFiles(folder, "*.dll"))
                {
                    FileVersionInfo fvi = FileVersionInfo.GetVersionInfo(file);
                    string version = fvi.ProductVersion;
                    log += Path.GetFileNameWithoutExtension(file) + ", v" + version + Environment.NewLine;
                }

                log += Environment.NewLine + "--------------------- --------------------- --------------------------";

            }
            catch { }
            Log(log);
        }

        /// <summary>
        /// Add new message log item.
        /// </summary>
        /// <param name="message">Message.</param>
        public void Log(MessageLogItem log)
        {
            log.TimeStamp = DateTime.Now;
            AppendLog(log);
        }

        /// <summary>
        /// Appends the log.
        /// </summary>
        /// <param name="log">The log.</param>
        private void AppendLog(LogItemBase log)
        {
            _logs.BlockEnqueue(log);
            StartLoggingThread();
        }

        /// <summary>
        /// Starts the logging thread.
        /// </summary>
        private void StartLoggingThread()
        {
            if (!_isStarted)
            {
                _isStarted = true;
                _loggingThread = new Thread(LoggingThreadMethod);
                _loggingThread.IsBackground = true;
                _loggingThread.Start();
            }
        }

        /// <summary>
        /// Loggings thread method.
        /// </summary>
        //[DebuggerStepThrough]
        //[DebuggerHidden]
        private void LoggingThreadMethod()
        {
            while (_isStarted)
            {
                LogItemBase log = _logs.BlockDequeue();

                _loggers.Where(x => x.Enabled).ToList().ForEach(x => x.OnLog(log));
                NewLog?.Invoke(this, log);
            }
        }

        /// <summary>
        /// Creates a new log safe which can be used to keep logs and then be disposed.
        /// </summary>
        /// <returns></returns>
        public LogSafe CreateLogSafe()
        {
            return new LogSafe(this);
        }
    }
}