using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
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 ConcurrentQueue<LogItemBase> _logs;
        private Thread _loggingThread;
        private bool _isStarted;

        private static LogManager _default;

        public static LogManager Default
        {
            get
            {
                if (_default == null)
                {
                    _default = new LogManager();
                }

                return _default;
            }
        }


        /// <summary>
        /// Gets or sets a value indicating whether to propagate logs instantly (Warning - not thread safe).
        /// </summary>
        public bool OverrideQueue { get; set; }

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

            Categories.Add(LogCategory.Critical);
            Categories.Add(LogCategory.Debug);
            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 != null ? description : e.ToString();

            if (!OverrideQueue)
            {
                AppendLog(log);
            }
            else
            {
                AppendLogInstantly(log);
            }

            return e;
        }

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

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

        /// <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, 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)
        {
            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;

            if (!OverrideQueue)
            {
                AppendLog(log);
            }
            else
            {
                AppendLogInstantly(log);
            }

            return message;
        }

        /// <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)
        {
            if (log != null)
            {
                _loggers.Where(x => x.Enabled && x.Immediate).ToList().ForEach(x => x.OnLog(log));
            }

            _logs.Enqueue(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)
            {
                while (_logs.Count > 0)
                {
                    LogItemBase log;

                    if (_logs.TryDequeue(out log))
                    {
                        if (log != null)
                        {
                            _loggers.Where(x => x.Enabled && !x.Immediate).ToList().ForEach(x => x.OnLog(log));
                        }
                    }
                }

                Thread.Sleep(10);
            }
        }

        /// <summary>
        /// Appends the log instantly.
        /// </summary>
        /// <param name="log">The log.</param>
        [DebuggerStepThrough]
        [DebuggerHidden]
        private void AppendLogInstantly(LogItemBase log)
        {
            bool wroteLog = false;

            while (!wroteLog)
            {
                try
                {
                    _loggers.Where(x => x.Enabled).ToList().ForEach(x => x.OnLog(log));

                    wroteLog = true;
                }
                catch
                {
                    Thread.Sleep(5);
                }
            }
        }
    }
}