Program.cs

using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using PostgresBackupConsole.Logging;
using PostgresBackupConsole.Services;

class Program
{
    // Shared between LogMessage and FileLoggerProvider so that direct writes
    // and ILogger writes never interleave in the log file.
    private static readonly object _logLock = new();

    public static async Task<int> Main(string[] args)  // Return int for exit code
    {
        // Read configuration up-front so we can honor PostgresSettings:LogPath
        // before opening the log file (the host re-reads the same JSON later).
        var configuration = new ConfigurationBuilder()
            .SetBasePath(AppDomain.CurrentDomain.BaseDirectory)
            .AddJsonFile("appsettings.json", optional: false, reloadOnChange: false)
            .AddEnvironmentVariables()
            .AddCommandLine(args)
            .Build();

        var (logsDir, logPath, logPathFallbackReason) = ResolveLogPath(configuration);

        StreamWriter fileStream;
        try
        {
            Directory.CreateDirectory(logsDir);
            fileStream = new StreamWriter(logPath, append: true);
        }
        catch (Exception ex)
        {
            Console.Error.WriteLine($"Failed to open log file '{logPath}': {ex.Message}");
            return 1;
        }

        using (fileStream)
        {
            try
            {
                LogMessage("Starting PostgreSQL Backup Process...", fileStream);
                if (logPathFallbackReason is not null)
                {
                    LogMessage($"Warning: {logPathFallbackReason}", fileStream);
                }

                var host = Host.CreateDefaultBuilder(args)
                    .ConfigureAppConfiguration(builder =>
                    {
                        // Reuse the already-built configuration so the host
                        // sees exactly the same values we used for LogPath.
                        builder.Sources.Clear();
                        builder.AddConfiguration(configuration);
                    })
                    .ConfigureLogging(logging =>
                    {
                        // Route ILogger output (from PostgresService, etc.) into the
                        // same backup_log file via a shared writer + lock.
                        logging.AddProvider(new FileLoggerProvider(fileStream, _logLock));
                    })
                    .ConfigureServices((hostContext, services) =>
                    {
                        services.Configure<PostgresSettings>(
                            hostContext.Configuration.GetSection("PostgresSettings"));
                        services.AddScoped<IPostgresService, PostgresService>();
                    })
                    .Build();

                var postgresService = host.Services.GetRequiredService<IPostgresService>();
                var settings = host.Services.GetRequiredService<IOptions<PostgresSettings>>().Value;

                // Display settings
                LogMessage($"Using settings:", fileStream);
                LogMessage($"Host: {settings.Host}", fileStream);
                LogMessage($"Port: {settings.Port}", fileStream);
                LogMessage($"Username: {settings.Username}", fileStream);
                LogMessage($"Database: {settings.Database}", fileStream);
                LogMessage($"Backup Type: {settings.BackupType}", fileStream);
                LogMessage($"Retention Days: {settings.BackupRetentionDays}", fileStream);
                LogMessage($"Log directory: {logsDir}", fileStream);

                // Create backup directory
                var backupPath = settings.BackupPath;
                if (string.IsNullOrEmpty(backupPath))
                {
                    backupPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Backups");
                    LogMessage($"Warning: No backup path configured, using default: {backupPath}", fileStream);
                }
                Directory.CreateDirectory(backupPath);
                LogMessage($"Backup directory: {backupPath}", fileStream);

                // Get all databases
                LogMessage("\nRetrieving database list...", fileStream);
                var databases = await postgresService.GetAllDatabaseNames();
                LogMessage($"Found {databases.Count} databases to backup:", fileStream);
                foreach (var db in databases)
                {
                    LogMessage($"- {db}", fileStream);
                }

                // Backup each database
                LogMessage("\nStarting backup process...", fileStream);
                foreach (var database in databases)
                {
                    LogMessage($"\nBacking up database: {database}", fileStream);
                    var success = await postgresService.BackupDatabase(database, backupPath);
                    if (success)
                        LogMessage($"✓ Successfully backed up database: {database}", fileStream);
                    else
                        LogMessage($"✗ Failed to backup database: {database}", fileStream);
                }

                // Cleanup old backups
                LogMessage("\nCleaning up old backups...", fileStream);
                postgresService.CleanupOldBackups(backupPath, settings.BackupRetentionDays);

                LogMessage("\nBackup process completed successfully!", fileStream);
                CleanupOldLogs(logsDir, 30);
                return 0; // Success exit code
            }
            catch (Exception ex)
            {
                // fileStream is still open here, so we can log directly to it
                // without trying to open a second StreamWriter on the same path.
                LogMessage($"\nERROR: {ex.Message}", fileStream);
                LogMessage(ex.StackTrace ?? "No stack trace available", fileStream);
                return 1; // Error exit code
            }
        }
    }

    /// <summary>
    /// Resolves the directory used for backup logs and the full path of the log
    /// file for this run. Honors <c>PostgresSettings:LogPath</c> from
    /// <c>appsettings.json</c>; falls back to <c>&lt;exe-dir&gt;\Logs</c> if the
    /// configured path is empty or unusable. Returns a non-null
    /// <paramref name="fallbackReason"/> when a fallback was used.
    /// </summary>
    private static (string LogsDir, string LogPath, string? FallbackReason) ResolveLogPath(IConfiguration configuration)
    {
        var defaultLogsDir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Logs");
        var configuredLogsDir = configuration["PostgresSettings:LogPath"];
        string logsDir = defaultLogsDir;
        string? fallbackReason = null;

        if (!string.IsNullOrWhiteSpace(configuredLogsDir))
        {
            try
            {
                // Path.GetFullPath validates the shape of the path without
                // touching disk; the directory itself is created later.
                logsDir = Path.GetFullPath(configuredLogsDir);
            }
            catch (Exception ex)
            {
                fallbackReason =
                    $"Configured LogPath '{configuredLogsDir}' is invalid ({ex.Message}); " +
                    $"falling back to '{defaultLogsDir}'.";
            }
        }

        var logPath = Path.Combine(logsDir, $"backup_log_{DateTime.Now:yyyyMMdd_HHmmss}.txt");
        return (logsDir, logPath, fallbackReason);
    }

    private static void CleanupOldLogs(string logsPath, int retentionDays)
    {
        try
        {
            var cutoffDate = DateTime.Now.AddDays(-retentionDays);
            var files = Directory.GetFiles(logsPath, "backup_log_*.txt");

            foreach (var file in files)
            {
                var fileInfo = new FileInfo(file);
                if (fileInfo.CreationTime < cutoffDate)
                {
                    File.Delete(file);
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Failed to cleanup old logs: {ex.Message}");
        }
    }

    private static void LogMessage(string message, StreamWriter fileStream)
    {
        var timestamp = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
        var logMessage = $"[{timestamp}] {message}";

        // Still write to console for debugging purposes
        Console.WriteLine(logMessage);

        // Serialize with FileLoggerProvider so direct writes and ILogger writes
        // never interleave a half-line in the log file.
        lock (_logLock)
        {
            try
            {
                fileStream.WriteLine(logMessage);
                fileStream.Flush();
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Failed to write to log file: {ex.Message}");
            }
        }
    }
}