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 used by the library to emit diagnostics.
    /// - By default <see cref="Current"/> points to a <see cref="NullLogger"/> (no-op). Callers can replace
    ///   <see cref="Current"/> with any <see cref="IAppLogger"/> implementation to redirect logs (tests, hosts).
    /// - Logging is best-effort: implementations of <see cref="IAppLogger"/> should avoid throwing from log calls
    ///   because logging must not change application control flow.
    /// - Assignment to <see cref="Current"/> is atomic for the reference type, but code does not synchronize concurrent
    ///   set/get operations. Replace the global logger early during startup or from a single thread to avoid races.
    /// </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 { return _current; }
            set { _current = value ?? new NullLogger(); }
        }

        /// <summary>
        /// Enable logging to a rolling file using log4net.
        /// Logs all levels (DEBUG, INFO, WARN, ERROR, FATAL).
        /// </summary>
        /// <param name="logFilePath">Path to the log file (e.g., "logs/run.log").</param>
        /// <remarks>
        /// - This method configures a 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 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/locked-path issues.
        ///   It immediately closes the file; the actual appender will reopen it when logging.
        /// - Locking model: we select <see cref="FileAppender.MinimalLock"/> to allow concurrent readers. If your
        ///   environment requires exclusive locking, change the locking model accordingly.
        /// - Exceptions:
        ///   - Throws <see cref="ArgumentException"/> when <paramref name="logFilePath"/> is null/empty.
        ///   - Throws <see cref="IOException"/> on path or permission errors (wraps 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>
        public static void SetFile(string logFilePath)
        {
            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
            };
            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);

            // Always enable all levels on the root logger for maximum diagnostic coverage
            if (hierarchy != null)
            {
                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); }
    }
}