TransferEngine.cs

using System;
using System.Collections.Concurrent;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.IO.Enumeration;
using System.Threading.Tasks;

namespace RoboCopyApp
{
    public class TransferEngine
    {
        public event EventHandler<TransferProgressEventArgs>? ProgressChanged;
        public event EventHandler<string>? LogMessage;

        private long _totalBytes;
        private long _transferredBytes;
        private int _totalFiles;
        private int _transferredFiles;
        private bool _isScanning;
        
        private CancellationTokenSource? _cancellationTokenSource;
        private ManualResetEventSlim _pauseEvent = new ManualResetEventSlim(true);

        public void Pause()
        {
            _pauseEvent.Reset();
        }

        public void Resume()
        {
            _pauseEvent.Set();
        }

        public async Task StartTransferAsync(
            string sourceDir, 
            string destDir, 
            TransferMode mode, 
            int maxThreads, 
            int bufferSize, 
            int maxRetries, 
            bool verifyChecksums,
            List<string> excludePatterns)
        {
            _cancellationTokenSource = new CancellationTokenSource();
            _pauseEvent.Set(); // Ensure running on start
            var ct = _cancellationTokenSource.Token;

            _totalBytes = 0;
            _transferredBytes = 0;
            _totalFiles = 0;
            _transferredFiles = 0;
            _isScanning = true;

            var queue = new ConcurrentQueue<FileTransferTask>();
            var sw = Stopwatch.StartNew();

            LogMessage?.Invoke(this, $"Scanning directory: {sourceDir}");
            
            // Fire and forget progress updater
            var progressUpdater = Task.Run(async () => 
            {
                while (!ct.IsCancellationRequested)
                {
                    ReportProgress(sw, string.Empty);
                    await Task.Delay(250, ct).ConfigureAwait(false);
                }
            });

            // 1. Scan Directory
            try
            {
                await ScanDirectoryAsync(sourceDir, destDir, queue, ct, excludePatterns);
            }
            catch (Exception ex)
            {
                LogMessage?.Invoke(this, $"Error during scan: {ex.Message}");
            }
            
            _isScanning = false;
            LogMessage?.Invoke(this, $"Scan complete. Found {_totalFiles} files ({_totalBytes / (1024.0 * 1024.0):F2} MB). Starting transfer with {maxThreads} threads.");

            if (_totalFiles == 0)
            {
                _cancellationTokenSource.Cancel();
                LogMessage?.Invoke(this, "Transfer complete (no files found).");
                return;
            }

            // 2. Process Queue in Parallel
            var parallelOptions = new ParallelOptions
            {
                MaxDegreeOfParallelism = maxThreads,
                CancellationToken = ct
            };

            try
            {
                await Parallel.ForEachAsync(queue, parallelOptions, async (task, token) =>
                {
                    try
                    {
                        _pauseEvent.Wait(token); // Pause mid-queue, respects cancellation token
                        await FileCopier.CopyFileAsync(
                            task, 
                            bufferSize, 
                            maxRetries, 
                            verifyChecksums, 
                            (bytes) => Interlocked.Add(ref _transferredBytes, bytes),
                            token);

                        if (mode == TransferMode.Move)
                        {
                            File.Delete(task.SourcePath);
                        }

                        Interlocked.Increment(ref _transferredFiles);
                        LogMessage?.Invoke(this, $"Success: {task.SourcePath}");
                    }
                    catch (Exception ex)
                    {
                        LogMessage?.Invoke(this, $"Failed: {task.SourcePath}. Error: {ex.Message}");
                    }
                });
            }
            catch (OperationCanceledException)
            {
                LogMessage?.Invoke(this, "Transfer canceled by user.");
            }
            catch (Exception ex)
            {
                LogMessage?.Invoke(this, $"Transfer engine error: {ex.Message}");
            }
            finally
            {
                sw.Stop();
                _cancellationTokenSource.Cancel(); // Stop the progress updater loop
                ReportProgress(sw, "Completed");
                
                if (mode == TransferMode.Move)
                {
                    try { Directory.Delete(sourceDir, true); } catch { /* Ignore */ }
                }
                
                LogMessage?.Invoke(this, "Transfer complete.");
            }
        }

        public void StopTransfer()
        {
            _cancellationTokenSource?.Cancel();
            _pauseEvent.Set(); // Release any waiting threads to let them cancel
        }

        private async Task ScanDirectoryAsync(string source, string dest, ConcurrentQueue<FileTransferTask> queue, CancellationToken ct, List<string> excludePatterns)
        {
            if (ct.IsCancellationRequested) return;

            try
            {
                var dirInfo = new DirectoryInfo(source);
                if (!dirInfo.Exists)
                {
                    // It might be a single file
                    var fileInfo = new FileInfo(source);
                    if (fileInfo.Exists)
                    {
                        if (ShouldExclude(fileInfo.Name, excludePatterns))
                        {
                            LogMessage?.Invoke(this, $"Skipped (excluded): {fileInfo.FullName}");
                            return;
                        }

                        Interlocked.Add(ref _totalBytes, fileInfo.Length);
                        Interlocked.Increment(ref _totalFiles);
                        queue.Enqueue(new FileTransferTask 
                        { 
                            SourcePath = source, 
                            DestinationPath = dest, 
                            Size = fileInfo.Length 
                        });
                    }
                    return;
                }

                // Create root dest dir
                Directory.CreateDirectory(dest);

                var dirQueue = new Queue<string>();
                dirQueue.Enqueue(source);

                while (dirQueue.Count > 0)
                {
                    ct.ThrowIfCancellationRequested();
                    string currentDir = dirQueue.Dequeue();
                    
                    try
                    {
                        var currentDirInfo = new DirectoryInfo(currentDir);
                        if (!currentDirInfo.Exists) continue;

                        // Exclude folders
                        foreach (var subdir in currentDirInfo.EnumerateDirectories())
                        {
                            if (ShouldExclude(subdir.Name, excludePatterns))
                            {
                                LogMessage?.Invoke(this, $"Skipped (excluded): {subdir.FullName}");
                                continue;
                            }
                            dirQueue.Enqueue(subdir.FullName);
                        }

                        // Exclude files
                        foreach (var file in currentDirInfo.EnumerateFiles())
                        {
                            if (ShouldExclude(file.Name, excludePatterns))
                            {
                                LogMessage?.Invoke(this, $"Skipped (excluded): {file.FullName}");
                                continue;
                            }

                            var relPath = Path.GetRelativePath(source, file.FullName);
                            var targetPath = Path.Combine(dest, relPath);

                            Interlocked.Add(ref _totalBytes, file.Length);
                            Interlocked.Increment(ref _totalFiles);

                            queue.Enqueue(new FileTransferTask
                            {
                                SourcePath = file.FullName,
                                DestinationPath = targetPath,
                                Size = file.Length
                            });
                        }
                    }
                    catch (UnauthorizedAccessException)
                    {
                        LogMessage?.Invoke(this, $"Access denied scanning: {currentDir}");
                    }
                    catch (DirectoryNotFoundException)
                    {
                        // Directory was deleted while scanning
                    }
                }
            }
            catch (UnauthorizedAccessException)
            {
                LogMessage?.Invoke(this, $"Access denied scanning root: {source}");
            }
        }

        private bool ShouldExclude(string name, List<string> excludePatterns)
        {
            if (excludePatterns == null || excludePatterns.Count == 0) return false;
            foreach (var pattern in excludePatterns)
            {
                if (FileSystemName.MatchesSimpleExpression(pattern, name, ignoreCase: true))
                    return true;
            }
            return false;
        }

        private void ReportProgress(Stopwatch sw, string currentFile)
        {
            double elapsedSeconds = sw.Elapsed.TotalSeconds;
            double speed = elapsedSeconds > 0 ? _transferredBytes / elapsedSeconds : 0;
            
            TimeSpan eta = TimeSpan.Zero;
            if (speed > 0 && _totalBytes > _transferredBytes)
            {
                eta = TimeSpan.FromSeconds((_totalBytes - _transferredBytes) / speed);
            }

            ProgressChanged?.Invoke(this, new TransferProgressEventArgs
            {
                TotalBytesTransferred = _transferredBytes,
                TotalBytes = _totalBytes,
                FilesCompleted = _transferredFiles,
                TotalFiles = _totalFiles,
                SpeedBytesPerSecond = speed,
                EstimatedTimeRemaining = eta,
                CurrentFile = currentFile,
                IsScanning = _isScanning
            });
        }
    }
}