//-----------------------------------------------------------------------
// <copyright file="LogHelper.cs" company="Deltares">
//  Copyright (c) 2012 Deltares. All rights reserved.
// </copyright>
// <author>B. Faassen</author>
// <email>barry.faassen@deltares.nl</email>
// <date>29-7-2012</date>
// <summary>See class header</summary>
//-----------------------------------------------------------------------

using System;
using System.Collections.Generic;
using log4net;
using log4net.Appender;
using log4net.Repository;

namespace Deltares.Standard.Application
{
    /// <summary>
    /// LogHelper is a utility class to simplify logging to different appenders. 
    /// This class uses log4net to delegate the actual logging. See the log4net 
    /// documentation to configure this API in the client application using either
    /// the configuration file or programmaticaly.
    /// 
    /// TODO: This logger should be able to log to EntLib too! 
    /// see http://stackoverflow.com/questions/710863/log4net-vs-nlog 
    /// </summary>
    public class LogHelper
    {
        private readonly object sync = new object();
        private readonly List<Exception> exceptions = new List<Exception>();

        /// <summary>
        /// Creates a LogHelper class to simplify logging
        /// </summary>
        /// <param name="obj">The target object to log for. This object type name will be used in the log</param>
        /// <returns>An instance of this helper</returns>
        public static LogHelper Create(object obj)
        {
            if (obj == null) throw new ArgumentNullException("obj");
            return Create(obj.GetType());
        }

        /// <summary>
        /// Creates a LogHelper to simplify logging.
        /// </summary>
        /// <param name="type">The target type to log for.</param>
        /// <returns>An instance of this helper</returns>
        public static LogHelper Create(Type type)
        {
            return new LogHelper(log4net.LogManager.GetLogger(type));
        }

        /// <summary>
        /// Creates a LogHelper class to simplify logging
        /// </summary>
        /// <typeparam name="T">The target type to log for.</typeparam>
        /// <returns>An instance of this helper</returns>
        public static LogHelper Create<T>()
        {
            return Create(typeof(T));
        }

        /// <summary>
        /// Creates a LogHelper class to simplify logging
        /// </summary>
        /// <param name="name">The name.</param>
        /// <returns></returns>
        public static LogHelper Create(string name)
        {
            return new LogHelper(log4net.LogManager.GetLogger(name));
        }

        /// <summary>
        /// Holds a reference to the log4net logger
        /// </summary>
        private readonly ILog logger;

        public LogHelper(ILog logger)
        {
            this.logger = logger;
        }

        /// <summary>
        /// Logs fatal messages if ALL, DEBUG, INFO, WARN, ERROR or FATAL is enabled in the config.
        /// </summary>
        /// <param name="message">The message.</param>
        /// <param name="exception">The exception.</param>
        public void LogFatal(string message, Exception exception = null)
        {
            if (logger != null && logger.IsFatalEnabled)
                logger.Fatal(message, exception);

            Add(exception);
        }

        /// <summary>
        /// Logs error messages if ALL, DEBUG, INFO, WARN or ERROR level is enabled in the config.
        /// </summary>
        /// <param name="message">The message.</param>
        /// <param name="exception">The exception.</param>
        public void LogError(string message, Exception exception = null)
        {
            if (logger != null && logger.IsErrorEnabled)
                logger.Error(message, exception);

            Add(exception);
        }

        /// <summary>
        /// Logs warning messages if ALL, DEBUG, INFO or WARN level is enabled in the config.
        /// </summary>
        /// <param name="message">The message.</param>
        /// <param name="exception">The exception.</param>
        public void LogWarning(string message, Exception exception = null)
        {
            if (logger != null && logger.IsWarnEnabled)
                logger.Warn(message, exception);

            Add(exception);
        }

        /// <summary>
        /// Logs info messages if ALL, DEBUG or INFO is enabled in the config.
        /// </summary>
        /// <param name="message">The message.</param>
        /// <param name="exception">The exception.</param>
        public void LogInfo(string message, Exception exception = null)
        {
            if (logger != null && logger.IsInfoEnabled)
                logger.Info(message, exception);

            Add(exception);
        }

        /// <summary>
        /// Logs debug messages if ALL or DEBUG is enabled in the config.
        /// </summary>
        /// <param name="message">The message.</param>
        /// <param name="exception">The exception.</param>
        public void LogDebug(string message, Exception exception = null)
        {
            if (logger != null && logger.IsDebugEnabled)
                logger.Debug(message, exception);

            Add(exception);
        }

        /// <summary>
        ///  Flushes all appenders across the whole logging repository
        /// </summary>
        /// <remarks>This call is in most cases not needed</remarks>
        public void Flush()
        {
            lock(sync)
            {
                ILoggerRepository rep = log4net.LogManager.GetRepository();
                foreach (IAppender appender in rep.GetAppenders())
                {
                    var buffered = appender as BufferingAppenderSkeleton;
                    if (buffered != null)
                    {
                        buffered.Flush();
                    }
                }

                exceptions.Clear();
            }
        }

        /// <summary>
        /// Clears the internal exception list
        /// </summary>
        public void Clear()
        {
            lock(sync)
            {
                exceptions.Clear();
            }
        }

        /// <summary>
        /// Gets a value indicating whether this instance has logged exceptions.
        /// </summary>
        /// <value>
        /// 	<c>true</c> if this instance has logged exceptions; otherwise, <c>false</c>.
        /// </value>
        public bool HasLoggedExceptions
        {
            get { return exceptions.Count > 0; }
        }

        /// <summary>
        /// Adds the specified exception the internal list.
        /// </summary>
        /// <param name="exception">The exception.</param>
        private void Add(Exception exception)
        {
            if (exception != null)
                lock (sync)
                    exceptions.Add(exception);
        }

    }
}