Program.cs

using System;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using System.Diagnostics;
using System.Linq;

namespace FolderStateConsole
{
    class Program
    {
        private const string version = "2.2";

        private static volatile bool _running = false;
        private static long _totalFiles = 0;
        private static long _copiedFiles = 0;
        private static long _totalBytes = 0;
        private static long _copiedBytes = 0;
        private static string _currentFile = "";
        private static string _phase = "Idle";

        private static long _scannedFiles = 0;
        private static long _scannedBytes = 0;
        private static string _currentScanDir = "";

        private static readonly object _lock = new();
        private static int _displayStartRow = 0;
        private const int DisplayRows = 8;

        static async Task<int> Main(string[] args)
        {
            Console.Title = $"RDKN - Backup Tool v{version} | © 2026 Redknack Interactive";
            PrintBanner();

            bool autoYes = args.Any(a =>
                a.Equals("-y", StringComparison.OrdinalIgnoreCase) ||
                a.Equals("--yes", StringComparison.OrdinalIgnoreCase));

            string? targetArg = args.FirstOrDefault(a => !a.StartsWith("-", StringComparison.Ordinal));
            string targetPath = string.IsNullOrWhiteSpace(targetArg)
                ? Directory.GetCurrentDirectory()
                : targetArg;

            try
            {
                if (!Directory.Exists(targetPath))
                {
                    WriteColor($"Error: Directory not found: {targetPath}", ConsoleColor.Red);
                    return 1;
                }

                Directory.SetCurrentDirectory(targetPath);

                _running = true;
                _phase = "Scanning";
                var displayTask = Task.Run(LiveDisplayLoop);

                var config = await BuildConfigWithLiveScan();

                _running = false;
                await displayTask;

                ShowConfiguration(config);

                if (!autoYes)
                {
                    WriteColor("\nStart backup? (Y/N): ", ConsoleColor.Yellow, newline: false);
                    var key = Console.ReadKey(intercept: true).Key;
                    Console.WriteLine();
                    if (key != ConsoleKey.Y)
                    {
                        WriteColor("Backup cancelled.", ConsoleColor.Yellow);
                        return 0;
                    }
                }
                else
                {
                    WriteColor("Auto-confirm enabled (-y). Starting backup...\n", ConsoleColor.Yellow);
                }

                await PerformBackup(config);
                return 0;
            }
            catch (Exception ex)
            {
                WriteColor($"Fatal error: {ex}", ConsoleColor.Red);
                return 1;
            }
            finally
            {
                Console.ForegroundColor = ConsoleColor.Gray;
                if (!autoYes)
                {
                    Console.WriteLine("\nPress any key to exit...");
                    Console.ResetColor();
                    Console.ReadKey(intercept: true);
                }
            }
        }

        private static void LiveDisplayLoop()
        {
            lock (_lock) _displayStartRow = Console.CursorTop;
            for (int i = 0; i < DisplayRows; i++) Console.WriteLine();

            var startTime = DateTime.Now;
            var lastUpdate = DateTime.MinValue;

            while (_running)
            {
                if (DateTime.Now - lastUpdate < TimeSpan.FromMilliseconds(150))
                {
                    Thread.Sleep(50);
                    continue;
                }
                lastUpdate = DateTime.Now;

                var elapsed = DateTime.Now - startTime;

                lock (_lock)
                {
                    Console.SetCursorPosition(0, _displayStartRow);

                    if (_phase == "Scanning")
                        DrawScanFrame(elapsed);
                    else
                        DrawBackupFrame(elapsed);
                }
            }

            Console.SetCursorPosition(0, _displayStartRow + DisplayRows);
        }

        private static void DrawScanFrame(TimeSpan elapsed)
        {
            ClearLine(); Console.ForegroundColor = ConsoleColor.Cyan;
            Console.WriteLine($" {SpinChar(elapsed)} Scanning directory...  [{elapsed:mm\\:ss}]");

            ClearLine(); Console.ForegroundColor = ConsoleColor.White;
            Console.WriteLine($"   Files found  : {_scannedFiles:N0}");

            ClearLine(); Console.ForegroundColor = ConsoleColor.White;
            Console.WriteLine($"   Size so far  : {FormatBytes(_scannedBytes)}");

            ClearLine(); Console.ForegroundColor = ConsoleColor.Gray;
            Console.WriteLine($"   Current      : {TruncateLeft(_currentScanDir, 60)}");

            for (int i = 4; i < DisplayRows; i++) ClearLine();

            Console.ResetColor();
        }

        private static void DrawBackupFrame(TimeSpan elapsed)
        {
            int percent = _totalFiles > 0
                ? (int)Math.Min(100, (_copiedFiles * 100) / _totalFiles)
                : 0;

            ClearLine(); Console.ForegroundColor = ConsoleColor.Yellow;
            Console.Write(" Progress: ");
            DrawBar(percent);
            Console.WriteLine();

            ClearLine(); Console.ForegroundColor = ConsoleColor.White;
            Console.WriteLine($"   Files    : {_copiedFiles:N0} / {_totalFiles:N0}  ({percent}%)");

            ClearLine(); Console.ForegroundColor = ConsoleColor.White;
            Console.WriteLine($"   Data     : {FormatBytes(_copiedBytes),10} / {FormatBytes(_totalBytes)}");

            ClearLine(); Console.ForegroundColor = ConsoleColor.Gray;
            Console.WriteLine($"   Elapsed  : {elapsed:mm\\:ss}");

            if (percent > 2 && elapsed.TotalSeconds > 0)
            {
                double speed = _copiedBytes / elapsed.TotalSeconds;
                var eta = TimeSpan.FromSeconds(
                    elapsed.TotalSeconds * (100 - percent) / Math.Max(1, percent));

                ClearLine(); Console.ForegroundColor = ConsoleColor.DarkCyan;
                Console.WriteLine($"   Speed    : {FormatBytes((long)speed)}/s     ETA: {eta:mm\\:ss}");
            }
            else
            {
                ClearLine(); Console.ForegroundColor = ConsoleColor.DarkGray;
                Console.WriteLine("   Speed    : Calculating...");
            }

            ClearLine();
            Console.WriteLine();

            ClearLine(); Console.ForegroundColor = ConsoleColor.Gray;
            Console.WriteLine($"   {_currentFile}");

            Console.ResetColor();
        }

        private static async Task<BackupConfig> BuildConfigWithLiveScan()
        {
            var config = new BackupConfig();
            var dirInfo = new DirectoryInfo(Directory.GetCurrentDirectory());

            config.ProjectName = dirInfo.Name;
            config.ProjectPath = dirInfo.FullName;
            config.ParentPath = dirInfo.Parent?.FullName ?? dirInfo.FullName;
            config.BackupFolderName = $"{config.ProjectName}_BACKUP_{DateTime.Now:yyyy-MM-dd_HH-mm-ss}";
            config.BackupPath = Path.Combine(config.ParentPath, config.BackupFolderName);

            await Task.Run(() =>
            {
                try { WalkDirectory(dirInfo); }
                catch { }
            });

            lock (_lock)
            {
                config.TotalFiles = _scannedFiles;
                config.TotalSize = _scannedBytes;
            }

            return config;
        }

        private static void WalkDirectory(DirectoryInfo dir)
        {
            lock (_lock) _currentScanDir = dir.FullName;

            try
            {
                foreach (var file in dir.EnumerateFiles())
                    lock (_lock) { _scannedFiles++; _scannedBytes += file.Length; }

                foreach (var sub in dir.EnumerateDirectories())
                    WalkDirectory(sub);
            }
            catch { }
        }

        private static async Task PerformBackup(BackupConfig config)
        {
            Console.Clear();
            PrintBanner();

            var stopwatch = Stopwatch.StartNew();

            _running = true;
            _phase = "Backup";
            _totalFiles = config.TotalFiles;
            _totalBytes = config.TotalSize;
            _copiedFiles = 0;
            _copiedBytes = 0;
            _currentFile = "";

            var displayTask = Task.Run(LiveDisplayLoop);

            try
            {
                Directory.CreateDirectory(config.BackupPath);
                await RunRobocopy(config);

                stopwatch.Stop();
                _running = false;
                await displayTask;

                ShowSuccessMessage(stopwatch.Elapsed, config);
            }
            catch (Exception ex)
            {
                _running = false;
                WriteColor($"\nBackup error: {ex.Message}", ConsoleColor.Red);
            }
        }

        private static async Task RunRobocopy(BackupConfig config)
        {
            var startInfo = new ProcessStartInfo
            {
                FileName = "robocopy",
                Arguments = $"\"{config.ProjectPath}\" \"{config.BackupPath}\" " +
                                         $"/MIR /XD \"{config.BackupPath}\" /XF \"*.bat\" /R:3 /W:1 /BYTES /NP /MT:1",
                UseShellExecute = false,
                RedirectStandardOutput = true,
                RedirectStandardError = true,
                CreateNoWindow = true
            };

            using var process = Process.Start(startInfo)
                ?? throw new Exception("Failed to start Robocopy.");

            _ = Task.Run(() => ParseRobocopyOutput(process));
            await process.WaitForExitAsync();
            _running = false;

            if (process.ExitCode > 7)
                throw new Exception($"Robocopy exited with code {process.ExitCode}");
        }

        private static void ParseRobocopyOutput(Process process)
        {
            while (!process.StandardOutput.EndOfStream)
            {
                var line = process.StandardOutput.ReadLine();
                if (string.IsNullOrWhiteSpace(line)) continue;

                bool isCopy = line.Contains("New File") || line.Contains("Newer")
                           || line.Contains("Neuer") || line.Contains("Neue Datei");

                if (!isCopy) continue;

                var parts = line.Split('\t', StringSplitOptions.RemoveEmptyEntries);
                string fileName = parts.Length > 0 ? Path.GetFileName(parts.Last().Trim()) : "";

                long fileBytes = 0;
                foreach (var part in parts)
                {
                    var clean = part.Trim().Replace(",", "").Replace(".", "");
                    if (long.TryParse(clean, out long b)) { fileBytes = b; break; }
                }

                lock (_lock)
                {
                    _copiedFiles++;
                    _copiedBytes += fileBytes;
                    _currentFile = fileName;
                }
            }
        }

        private static void PrintBanner()
        {
            Console.ForegroundColor = ConsoleColor.Cyan;
            Console.WriteLine("===============================================================");
            Console.WriteLine("                      Backup Tool v" + version);
            Console.WriteLine("===============================================================");
            Console.ResetColor();
            Console.WriteLine();
        }

        private static void ShowConfiguration(BackupConfig config)
        {
            Console.Clear();
            PrintBanner();
            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine("============ BACKUP CONFIGURATION ============");
            Console.ResetColor();
            Console.WriteLine();

            void Row(string label, string value, ConsoleColor col)
            {
                Console.ForegroundColor = ConsoleColor.Gray;
                Console.Write($"  {label,-15}");
                Console.ForegroundColor = col;
                Console.WriteLine(value);
                Console.ResetColor();
            }

            Row("Project:", config.ProjectName, ConsoleColor.Yellow);
            Row("Source:", TruncateLeft(config.ProjectPath, 50), ConsoleColor.White);
            Row("Destination:", TruncateLeft(config.BackupPath, 50), ConsoleColor.Green);
            Row("Files:", config.TotalFiles.ToString("N0"), ConsoleColor.Blue);
            Row("Size:", FormatBytes(config.TotalSize), ConsoleColor.Cyan);
            Row("Timestamp:", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), ConsoleColor.Magenta);

            try
            {
                var drive = new DriveInfo(Path.GetPathRoot(config.BackupPath)!);
                Row("Free Space:", FormatBytes(drive.AvailableFreeSpace), ConsoleColor.DarkGreen);
            }
            catch { Row("Free Space:", "Unknown", ConsoleColor.Red); }
        }

        private static void ShowSuccessMessage(TimeSpan elapsed, BackupConfig config)
        {
            Console.WriteLine();
            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine("========= BACKUP COMPLETED SUCCESSFULLY =========");
            Console.ResetColor();
            Console.WriteLine();
            Console.WriteLine($"  Duration:      {elapsed:mm\\:ss}");
            Console.WriteLine($"  Files copied:  {_copiedFiles:N0}");
            Console.WriteLine($"  Data copied:   {FormatBytes(_copiedBytes)}");
            Console.WriteLine($"  Destination:   {config.BackupPath}");
            Console.WriteLine($"  Finished at:   {DateTime.Now:yyyy-MM-dd HH:mm:ss}");
        }

        private static void DrawBar(int pct)
        {
            const int width = 46;
            int filled = pct * width / 100;
            Console.Write("[");
            Console.ForegroundColor = ConsoleColor.Green;
            Console.Write(new string('█', filled));
            Console.ForegroundColor = ConsoleColor.DarkGray;
            Console.Write(new string('░', width - filled));
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.Write($"] {pct,3}%");
            Console.ResetColor();
        }

        private static void ClearLine()
        {
            int top = Console.CursorTop;
            Console.SetCursorPosition(0, top);
            Console.Write(new string(' ', Console.WindowWidth - 1));
            Console.SetCursorPosition(0, top);
        }

        private static string SpinChar(TimeSpan t)
        {
            string[] frames = { "⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏" };
            return frames[(int)(t.TotalMilliseconds / 100) % frames.Length];
        }

        private static string FormatBytes(long bytes)
        {
            if (bytes == 0) return "0 B";
            string[] sizes = { "B", "KB", "MB", "GB", "TB" };
            double len = bytes; int order = 0;
            while (len >= 1024 && order < sizes.Length - 1) { len /= 1024; order++; }
            return $"{len:0.##} {sizes[order]}";
        }

        private static string TruncateLeft(string s, int max) =>
            s.Length <= max ? s : "…" + s[^(max - 1)..];

        private static void WriteColor(string msg, ConsoleColor col, bool newline = true)
        {
            Console.ForegroundColor = col;
            if (newline) Console.WriteLine(msg);
            else Console.Write(msg);
            Console.ResetColor();
        }
    }

    public class BackupConfig
    {
        public string ProjectName { get; set; } = "";
        public string ProjectPath { get; set; } = "";
        public string ParentPath { get; set; } = "";
        public string BackupFolderName { get; set; } = "";
        public string BackupPath { get; set; } = "";
        public long TotalFiles { get; set; }
        public long TotalSize { get; set; }
    }
}