using log4net;
using log4net.Appender;
using log4net.Layout;
using System;
using System.Collections.Generic;
using System.IO;
using System.Reflection;

namespace GitConverter.Lib.Logging
{
    /// <summary>
    /// Static entry point for library diagnostics.
    /// </summary>
    /// <remarks>
    /// <para>
    /// The <c>Log</c> class provides a simple, test-friendly logging façade used throughout the
    /// library. It exposes a single mutable <see cref="Current"/> logger reference (an
    /// <see cref="IAppLogger"/>) and a set of convenience forwarding methods (<see cref="Debug"/>,
    /// <see cref="Info"/>, <see cref="Warn"/>, <see cref="Error"/>) so callers do not need to
    /// depend on a specific logging implementation.
    /// </para>
    /// <para>
    /// Important behavior and guidance:
    /// - Default behavior: when the process starts the active logger is a <see cref="NullLogger"/>,
    ///   which silently ignores log calls. Tests or hosts can replace <see cref="Current"/> with a
    ///   custom implementation (for example a <c>TestLogger</c> in unit tests or a file-based logger
    ///   in production) to capture diagnostics.
    /// - Non-throwing contract: implementations of <see cref="IAppLogger"/> MUST avoid throwing
    ///   from log methods. Logging is strictly best-effort and must not change application control flow.
    /// - Assignment semantics: the <see cref="Current"/> reference is assigned atomically but there is
    ///   no internal synchronization for concurrent set/get operations. Replace the global logger
    ///   early during startup or within a single thread. For per-component control prefer injecting
    ///   an <see cref="IAppLogger"/> instance into constructors instead of relying on the static.
    /// - Testability: unit tests should set <see cref="Current"/> to a deterministic test logger rather
    ///   than configure file-based logging. Use <see cref="Disable"/> to restore no-op behavior.
    /// </para>
    /// <para>
    /// File-based logging
    /// - Use <see cref="SetFile(string, string)"/> to configure a log4net rolling file appender programmatically.
    /// - The method performs defensive checks (path resolution, directory creation, permission probe) and
    ///   throws a clear <see cref="IOException"/> if the path is not writable.
    /// - When file logging is configured the global <see cref="Current"/> logger is set to a
    ///   <see cref="Log4NetAdapter"/> that forwards calls into log4net.
    /// </para>
    /// <para>
    /// When to call these helpers
    /// - Hosts should configure logging once at startup (before library calls) and rely on the injected
    ///   <see cref="IAppLogger"/> for any per-component needs. Tests should replace <see cref="Current"/>
    ///   with a lightweight test logger and avoid call sites that depend on file system state.
    /// </para>
    /// </remarks>
    public static class Log
    {
        private static IAppLogger _current = new NullLogger();

        /// <summary>
        /// Gets or sets the active logger. If set to null, a no-op logger is used.
        /// </summary>
        /// <remarks>
        /// <para>
        /// Consumers (tests, hosts) may set this property to supply a custom logger (for example a
        /// test logger). Assigning null will restore a <see cref="NullLogger"/> instance to preserve
        /// no-op behavior.
        /// </para>
        /// <para>
        /// Assignments are atomic for the reference; however concurrent read/write races are not
        /// synchronized. Set the global logger early during initialization to avoid race conditions.
        /// </para>
        /// </remarks>
        public static IAppLogger Current
        {
            get => _current;
            set => _current = value ?? new NullLogger();
        }

        /// <summary>
        /// Configure file-based logging using a programmatically-created log4net rolling appender.
        /// </summary>
        /// <param name="logFilePath">Target log file path. The method will create containing directories as needed.</param>
        /// <param name="logLevel">Optional log level name (All/Debug/Info/Warn/Error/Fatal/Off). Defaults to "All".</param>
        /// <remarks>
        /// <para>
        /// This helper performs the following defensive steps before enabling file logging:
        /// - Resolves and normalizes the supplied path.
        /// - Ensures the target directory exists.
        /// - Probes write access by opening the file for append and immediately closing it.
        /// - Creates a rolling file appender with a UTF-8 pattern layout and configures the log4net
        ///   repository for the current entry assembly.
        /// </para>
        /// <para>
        /// The method throws an <see cref="ArgumentException"/> for invalid arguments and an
        /// <see cref="IOException"/> when the path is not writable. Callers should catch and handle
        /// these exceptions during host startup; tests should avoid calling this method and instead
        /// set <see cref="Current"/> directly to a deterministic test logger.
        /// </para>
        /// </remarks>
        public static void SetFile(string logFilePath, string logLevel = "All")
        {
            if (string.IsNullOrWhiteSpace(logFilePath))
                throw new ArgumentException("logFilePath cannot be null or empty.", nameof(logFilePath));

            var fullPath = ResolvePath(logFilePath);
            EnsureDirectoryExists(fullPath);
            ProbeWriteAccess(fullPath);

            var appender = CreateRollingAppender(fullPath);
            var level = ParseLogLevel(logLevel);

            ConfigureRepository(appender, level);
            Current = new Log4NetAdapter(LogManager.GetLogger(typeof(Log)));
        }

        private static string ResolvePath(string logFilePath)
        {
            return Path.GetFullPath(logFilePath);
        }

        private static void EnsureDirectoryExists(string fullPath)
        {
            var directory = Path.GetDirectoryName(fullPath);
            if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
            {
                Directory.CreateDirectory(directory);
            }
        }

        private static void ProbeWriteAccess(string fullPath)
        {
            try
            {
                using (var fs = new FileStream(fullPath, FileMode.Append, FileAccess.Write, FileShare.Read))
                {
                    // just testing write access
                }
            }
            catch (Exception ex)
            {
                throw new IOException($"Cannot write to log file path '{fullPath}'. Check permissions and that the path is valid.", ex);
            }
        }

        private static RollingFileAppender CreateRollingAppender(string fullPath)
        {
            var layout = new PatternLayout
            {
                ConversionPattern = "%date %-5level %logger - %message%newline%exception"
            };
            layout.ActivateOptions();

            var roller = new RollingFileAppender
            {
                AppendToFile = true,
                File = fullPath,
                Layout = layout,
                MaxSizeRollBackups = 5,
                MaximumFileSize = "10MB",
                RollingStyle = RollingFileAppender.RollingMode.Size,
                StaticLogFileName = true,
                LockingModel = new FileAppender.MinimalLock(),
                Encoding = System.Text.Encoding.UTF8
            };
            roller.ActivateOptions();

            return roller;
        }

        private static log4net.Core.Level ParseLogLevel(string logLevel)
        {
            var levelMap = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
            {
                ["ALL"] = "ALL",
                ["DEBUG"] = "DEBUG",
                ["INFO"] = "INFO",
                ["WARN"] = "WARN",
                ["ERROR"] = "ERROR",
                ["FATAL"] = "FATAL",
                ["OFF"] = "OFF"
            };

            var normalizedLevel = (logLevel ?? "ALL").Trim().ToUpperInvariant();
            var levelName = levelMap.ContainsKey(normalizedLevel) ? levelMap[normalizedLevel] : "ALL";

            var entry = Assembly.GetEntryAssembly();
            var repoAssembly = (Assembly)(entry ?? Assembly.GetExecutingAssembly());
            var repo = LogManager.GetRepository(repoAssembly);
            var hierarchy = repo as log4net.Repository.Hierarchy.Hierarchy;

            return hierarchy?.LevelMap[levelName] ?? hierarchy?.LevelMap["ALL"];
        }

        private static void ConfigureRepository(RollingFileAppender appender, log4net.Core.Level level)
        {
            var entry = Assembly.GetEntryAssembly();
            var repoAssembly = (Assembly)(entry ?? Assembly.GetExecutingAssembly());
            var repo = LogManager.GetRepository(repoAssembly);

            var hierarchy = repo as log4net.Repository.Hierarchy.Hierarchy;
            if (hierarchy != null)
            {
                hierarchy.ResetConfiguration();
            }

            log4net.Config.BasicConfigurator.Configure(repo, appender);

            if (hierarchy != null)
            {
                hierarchy.Root.Level = level;
                hierarchy.Configured = true;
            }
        }

        /// <summary>
        /// Enable logging using the existing log4net configuration.
        /// </summary>
        /// <remarks>
        /// <para>
        /// Sets <see cref="Current"/> to a <see cref="Log4NetAdapter"/> that forwards all calls to the
        /// configured log4net repository. This is useful when the host configures log4net externally (for
        /// example via XML configuration or host wiring) and the library should piggy-back on the host's
        /// logging setup.
        /// </para>
        /// <para>
        /// For unit tests prefer setting <see cref="Current"/> directly to a test logger to keep tests
        /// deterministic and avoid file/IO side-effects.
        /// </para>
        /// </remarks>
        public static void Enable()
        {
            var logger = LogManager.GetLogger(typeof(Log));
            Current = new Log4NetAdapter(logger);
        }

        /// <summary>
        /// Disable logging and revert to a no-op logger.
        /// </summary>
        /// <remarks>
        /// <para>
        /// Sets <see cref="Current"/> to <see cref="NullLogger"/> so subsequent library log calls are no-ops.
        /// This is useful in tests to suppress noisy logs or to temporarily disable file logging.
        /// </para>
        /// <para>
        /// This method does not modify the log4net repository configuration; appenders remain registered. To fully
        /// reset log4net one would need to interact with the repository API directly (not performed here).
        /// </para>
        /// </remarks>
        public static void Disable()
        {
            Current = new NullLogger();
        }

        /// <summary>
        /// Log a debug message via the active logger.
        /// </summary>
        /// <remarks>
        /// Forwarding method to avoid callers referencing <see cref="Current"/> directly. Implementations of
        /// <see cref="IAppLogger.Debug"/> should be non-throwing and lightweight.
        /// </remarks>
        public static void Debug(string message) => _current.Debug(message);

        /// <summary>
        /// Log an informational message via the active logger.
        /// </summary>
        /// <remarks>
        /// Intended for high-level lifecycle and milestone messages.
        /// </remarks>
        public static void Info(string message) => _current.Info(message);

        /// <summary>
        /// Log a warning via the active logger.
        /// </summary>
        /// <remarks>
        /// Warnings indicate recoverable/unexpected conditions that merit attention.
        /// </remarks>
        public static void Warn(string message) => _current.Warn(message);

        /// <summary>
        /// Log an error via the active logger, optionally with an exception.
        /// </summary>
        /// <remarks>
        /// Error logging should be used for failures that affect operation. Avoid passing large exception
        /// objects across process boundaries; prefer serializing minimal diagnostic info when logs are
        /// collected by external systems.
        /// </remarks>
        public static void Error(string message, Exception ex = null) => _current.Error(message, ex);
    }
}