using NLog;
using System;

namespace Sony.Filtr.Tasks.Helpers
{
    public class LoggerAdapter
    {
        private readonly Logger Logger;

        private readonly Action<Func<string>> TraceLoggingFunc;
        private readonly Action<Func<string>> InformationLoggingFunc;
        private readonly Action<Func<string>> WarnLoggingFunc;
        private readonly Action<Func<string>> DebugLoggingFunc;
        private readonly Action<Func<string>> ErrorLoggingFunc;
        private readonly Action<Func<string>> FatalLoggingFunc;
        private readonly Action<Exception, Func<string>> ErrorWithExceptionLoggingFunc;

        public static LoggerAdapter GetLogger(string name)
        {
            return new LoggerAdapter(LogManager.GetLogger(name));
        }

        public LoggerAdapter(Logger logger)
        {
            this.Logger = logger;

            this.InformationLoggingFunc = this.CreateFuncForLevel(LogLevel.Info);
            this.WarnLoggingFunc = this.CreateFuncForLevel(LogLevel.Warn);
            this.DebugLoggingFunc = this.CreateFuncForLevel(LogLevel.Debug);
            this.ErrorLoggingFunc = this.CreateFuncForLevel(LogLevel.Error);
            this.FatalLoggingFunc = this.CreateFuncForLevel(LogLevel.Fatal);
            this.TraceLoggingFunc = this.CreateFuncForLevel(LogLevel.Trace);
            this.ErrorWithExceptionLoggingFunc = this.GetErrorLoggingWithExceptionFunc();
        }

        public void Trace(Func<string> getString)
        {
            this.TraceLoggingFunc(getString);
        }

        public void Information(Func<string> getString)
        {
            this.InformationLoggingFunc(getString);
        }

        public void Warn(Func<string> getString)
        {
            this.WarnLoggingFunc(getString);
        }

        public void Debug(Func<string> getString)
        {
            this.DebugLoggingFunc(getString);
        }

        public void Fatal(Func<string> getString)
        {
            this.FatalLoggingFunc(getString);
        }

        public void Error(Func<string> getString)
        {
            this.ErrorLoggingFunc(getString);
        }

        public void Error(Exception ex, Func<string> getString)
        {
            this.ErrorWithExceptionLoggingFunc(ex, getString);
        }

        private Action<Func<string>> CreateFuncForLevel(LogLevel level)
        {
            return this.Logger.IsEnabled(level) ? this.GetLoggerFunctionForLevel(level) : getString => { };
        }

        private Action<Func<string>> GetLoggerFunctionForLevel(LogLevel level)
        {
            if(level == LogLevel.Info) { return getString => this.Logger.Info(getString()); }

            if (level == LogLevel.Debug) { return getString => this.Logger.Debug(getString()); }

            if (level == LogLevel.Warn) { return getString => this.Logger.Warn(getString()); }

            if (level == LogLevel.Error) { return getString => this.Logger.Error(getString()); }

            if (level == LogLevel.Fatal) { return getString => this.Logger.Fatal(getString()); }

            if (level == LogLevel.Trace) { return getString => this.Logger.Trace(getString()); }

            return getString => { };
        }

        private Action<Exception, Func<string>> GetErrorLoggingWithExceptionFunc()
        {
            if (this.Logger.IsErrorEnabled)
            {
                return (ex, getString) => this.Logger.Error(ex, getString());
            }
                
            return (ex, getString) => { };
        }
    }
}