using log4net;
using log4net.Appender;
using log4net.Layout;
using log4net.Repository;
using System;
using System.IO;
using System.Reflection;

namespace GitConverter.Lib.Logging
{
    /// <summary>
    /// Static entry point for logging.
    /// Default is a no-op logger; call SetFile(...) to configure log4net-based file logging.
    /// </summary>
    /// <remarks>
    /// - The static <see cref="Current"/> logger is the library's primary diagnostics sink.
    /// - By default <see cref="Current"/> references a <see cref="NullLogger"/> (no-op). Callers
    ///   may replace <see cref="Current"/> with any <see cref="IAppLogger"/> implementation to
    ///   redirect logs (tests, hosts, custom integrations).
    /// - Logging is strictly best-effort: implementations of <see cref="IAppLogger"/> MUST avoid
    ///   throwing from logging calls because logging must not change application control flow.
    /// - Assignment to <see cref="Current"/> is atomic for the reference type, but there is no
    ///   internal synchronization for concurrent set/get operations. Replace the global logger
    ///   early during application startup or from a single thread to avoid races. For fine-grained
    ///   testability or per-component logging prefer injecting an <see cref="IAppLogger"/> instance.
    /// </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>
        /// - Consumers (tests, hosts) may set this property to supply a custom logger (for example a test logger).
        /// - Prefer setting this at application startup to avoid races; assignments are atomic but not synchronized.
        /// - Setting to null will implicitly replace the active logger with a <see cref="NullLogger"/> to preserve
        ///   no-op behavior.
        /// </remarks>
        public static IAppLogger Current
        {
            get => _current;
            set => _current = value ?? new NullLogger();
        }

        /// <summary>
        /// Enable logging to a rolling file using log4net with configurable log level.
        /// </summary>
        /// <param name="logFilePath">Path to the log file (e.g., "logs/run.log").</param>
        /// <param name="logLevel">
        /// Minimum log level threshold. Supported values (case-insensitive):
        /// "All" (default), "Debug", "Info", "Warn", "Error", "Fatal", "Off".
        /// Invalid values default to "All".
        /// </param>
        /// <remarks>
        /// - This method configures a <see cref="RollingFileAppender"/> programmatically and replaces
        ///   the global <see cref="Current"/> logger with a <see cref="Log4NetAdapter"/> that writes
        ///   to the configured file.
        /// - Directory creation: the method ensures the parent directory exists because log4net will
        ///   create the file but not the directory.
        /// - Write probing: the method attempts to open the file for append to fail fast on permission
        ///   or locked-path issues. It closes the probe stream immediately; the appender re-opens the
        ///   file when logging.
        /// - Locking model: <see cref="FileAppender.MinimalLock"/> is used by default to allow concurrent
        ///   readers. If exclusive locking is required change the locking model accordingly.
        /// - Encoding: the appender is configured to use UTF-8 so log files support international text
        ///   and emoji.
        /// - Log levels: the provided <paramref name="logLevel"/> controls the root threshold for emitted
        ///   messages. Passing "Off" disables emission; invalid values fall back to "All".
        /// - Exceptions:
        ///   - Throws <see cref="ArgumentException"/> when <paramref name="logFilePath"/> is null or empty.
        ///   - Throws <see cref="IOException"/> when the file cannot be created or written (wraps the underlying exception).
        /// - Thread-safety: call from single-threaded startup; concurrent calls may race to replace repository configuration.
        /// - Tests: in unit tests prefer injecting a test logger (set <see cref="Current"/> directly) instead of configuring file logging.
        /// </remarks>
        /// <example>
        /// <code>
        /// // Log all levels (default)
        /// Log.SetFile("logs/app.log");
        /// 
        /// // Log only INFO and above
        /// Log.SetFile("logs/app.log", "Info");
        /// 
        /// // Log only errors
        /// Log.SetFile("logs/errors.log", "Error");
        /// </code>
        /// </example>
        public static void SetFile(string logFilePath, string logLevel = "All")
        {
            if (string.IsNullOrWhiteSpace(logFilePath))
                throw new ArgumentException("logFilePath cannot be null or empty.", nameof(logFilePath));

            // Resolve full path and ensure directory exists. log4net will create the file if not exists.
            var fullPath = Path.GetFullPath(logFilePath);
            var directory = Path.GetDirectoryName(fullPath);
            if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
            {
                Directory.CreateDirectory(directory);
            }

            // Probe write access by opening the file for append. This will create the file if it doesn't exist.
            // We close immediately; log4net will open the file when logging.
            try
            {
                using (var fs = new FileStream(fullPath, FileMode.Append, FileAccess.Write, FileShare.Read))
                {
                    // no-op; just testing access
                }
            }
            catch (Exception ex)
            {
                throw new IOException($"Cannot write to log file path '{fullPath}'. Check permissions and that the path is valid.", ex);
            }

            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(), // better for concurrent reads
                Encoding = System.Text.Encoding.UTF8 // Explicit UTF-8 for international characters and emoji
            };
            roller.ActivateOptions();

            // Select repository associated with the entry assembly if available; otherwise use executing assembly.
            var entry = Assembly.GetEntryAssembly();
            var repoAssembly = (object)entry ?? (object)Assembly.GetExecutingAssembly();
            ILoggerRepository repo = LogManager.GetRepository((Assembly)repoAssembly);

            // Reset configuration when using the hierarchy to avoid duplicate appenders across multiple SetFile calls.
            var hierarchy = repo as log4net.Repository.Hierarchy.Hierarchy;
            if (hierarchy != null)
            {
                hierarchy.ResetConfiguration();
            }

            // Configure basic logger with the rolling appender
            log4net.Config.BasicConfigurator.Configure(repo, roller);

            if (hierarchy != null)
            {
                var normalizedLevel = (logLevel ?? "All").Trim().ToUpperInvariant();
                var levelName = normalizedLevel switch
                {
                    "ALL" => "ALL",
                    "DEBUG" => "DEBUG",
                    "INFO" => "INFO",
                    "WARN" => "WARN",
                    "ERROR" => "ERROR",
                    "FATAL" => "FATAL",
                    "OFF" => "OFF",
                    _ => "ALL"
                };
                var level = hierarchy.LevelMap[levelName];
                if (level != null)
                {
                    hierarchy.Root.Level = level;
                }
                else
                {
                    hierarchy.Root.Level = hierarchy.LevelMap["ALL"];
                }
                hierarchy.Configured = true;
            }
            // Replace the current logger with a log4net-backed adapter
            var logger = LogManager.GetLogger(typeof(Log));
            Current = new Log4NetAdapter(logger);
        }

        /// <summary>
        /// Enable logging using the existing log4net configuration.
        /// </summary>
        /// <remarks>
        /// - This method does not change log4net appenders or layout; it simply sets <see cref="Current"/> to a
        ///   <see cref="Log4NetAdapter"/> that forwards library log calls to log4net.
        /// - Use when log4net is configured externally (XML config, host wiring) and you want the library to emit logs.
        /// - Does not throw for normal operation; if log4net is not configured the adapter will still forward calls but
        ///   no output may be produced.
        /// - For unit tests prefer setting <see cref="Current"/> directly to a test logger.
        /// </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>
        /// - Sets <see cref="Current"/> to <see cref="NullLogger"/> so subsequent library log calls are no-ops.
        /// - This does not modify log4net's global repository configuration (appenders remain registered). To fully
        ///   reset log4net you would need to call into the repository (not performed here).
        /// - Useful in tests to suppress noisy logs or to temporarily disable file logging.
        /// </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);
    }
}