Form1.cs

using System.ComponentModel;
using System.Diagnostics;
using System.Drawing.Drawing2D;
using System.Runtime.InteropServices;

namespace FolderSizeScanner;

public partial class Form1 : Form
{
    private const int HardRecursionLimit = 200;
    private const int ParallelDepthLimit = 1; // parallelize depth 0 and 1
    private CancellationTokenSource? _cts;
    private int _maxDepth = 3;
    private int _skippedCount;
    private FolderInfo? _scanRoot;
    private bool _scanRunning;
    private System.Windows.Forms.Timer? _uiTimer;
    private System.Windows.Forms.Timer? _animTimer;
    private long _filesScanned;
    private long _foldersScanned;
    private string _currentPath = "";
    private TreeNode? _subScanNode;

    // Win32 P/Invoke
    private const int MAX_PATH = 260;
    private const int MAX_ALTERNATE = 14;
    private const uint FILE_ATTRIBUTE_DIRECTORY = 0x10;
    private const uint FILE_ATTRIBUTE_REPARSE_POINT = 0x400;
    private static readonly IntPtr INVALID_HANDLE_VALUE = new(-1);

    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    private struct WIN32_FIND_DATA
    {
        public uint dwFileAttributes;
        public System.Runtime.InteropServices.ComTypes.FILETIME ftCreationTime;
        public System.Runtime.InteropServices.ComTypes.FILETIME ftLastAccessTime;
        public System.Runtime.InteropServices.ComTypes.FILETIME ftLastWriteTime;
        public uint nFileSizeHigh;
        public uint nFileSizeLow;
        public uint dwReserved0;
        public uint dwReserved1;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_PATH)]
        public string cFileName;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_ALTERNATE)]
        public string cAlternateFileName;
    }

    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
    private static extern IntPtr FindFirstFileW(string lpFileName, out WIN32_FIND_DATA lpFindFileData);

    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
    private static extern bool FindNextFileW(IntPtr hFindFile, out WIN32_FIND_DATA lpFindFileData);

    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern bool FindClose(IntPtr hFindFile);

    public Form1()
    {
        InitializeComponent();
        LoadLogo();
    }

    private void LoadLogo()
    {
        var logoPath = Path.Combine(AppContext.BaseDirectory, "P9.png");
        if (!File.Exists(logoPath)) return;

        try
        {
            var bmp = new Bitmap(logoPath);
            picLogo.Image = bmp;

            // Set form icon from the same PNG
            var iconBmp = new Bitmap(bmp, 32, 32);
            var hIcon = iconBmp.GetHicon();
            Icon = Icon.FromHandle(hIcon);
        }
        catch { }
    }

    private void BtnBrowse_Click(object sender, EventArgs e)
    {
        using var dialog = new FolderBrowserDialog
        {
            Description = "Select a folder to scan",
            UseDescriptionForTitle = true
        };

        if (dialog.ShowDialog() == DialogResult.OK)
        {
            txtPath.Text = dialog.SelectedPath;
        }
    }

    private void BtnScan_Click(object sender, EventArgs e)
    {
        if (_scanRunning)
        {
            _cts?.Cancel();
            btnScan.Enabled = false;
            lblStatus.Text = "Cancelling...";
            return;
        }

        var path = txtPath.Text.Trim();
        if (!Directory.Exists(path))
        {
            MessageBox.Show("Please select a valid folder.", "Invalid Path",
                MessageBoxButtons.OK, MessageBoxIcon.Warning);
            return;
        }

        _maxDepth = (int)nudDepth.Value;

        treeResults.Nodes.Clear();
        progressBar.Value = 0;
        progressBar.IsMarquee = true;
        lblStatus.Text = "Scanning...";
        btnScan.Text = "Cancel";
        btnScan.IsPrimary = false;
        btnBrowse.Enabled = false;
        btnExport.Enabled = false;
        nudDepth.Enabled = false;

        _skippedCount = 0;
        _filesScanned = 0;
        _foldersScanned = 0;
        _currentPath = "";
        _scanRoot = null;
        _cts = new CancellationTokenSource();
        _scanRunning = true;

        // Create root node immediately (collapsed)
        var rootNode = new TreeNode(Path.GetFileName(path) is { Length: > 0 } name ? name : path)
        {
            Tag = path
        };
        treeResults.Nodes.Add(rootNode);

        // Start UI update timer
        _uiTimer = new System.Windows.Forms.Timer { Interval = 200 };
        _uiTimer.Tick += UiTimer_Tick;
        _uiTimer.Start();

        // Start animation timer for progress bar shimmer
        _animTimer = new System.Windows.Forms.Timer { Interval = 16 };
        _animTimer.Tick += (_, _) => progressBar.AdvanceAnimation();
        _animTimer.Start();

        // Launch scan on background thread
        var ct = _cts.Token;
        Task.Run(() =>
        {
            try
            {
                var result = ScanFolder(path, 0, ct);
                _scanRoot = result;
            }
            catch (OperationCanceledException)
            {
                // _scanRoot may have partial data from children added during scan
            }
            catch (Exception ex)
            {
                BeginInvoke(() =>
                {
                    StopTimers();
                    ResetUiAfterScan();
                    lblStatus.Text = "Scan failed.";
                    MessageBox.Show($"{ex.GetType().Name}: {ex.Message}\n\n{ex.StackTrace}",
                        "Scan Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                });
                return;
            }

            BeginInvoke(OnScanComplete);
        }, ct);
    }

    private void UiTimer_Tick(object? sender, EventArgs e)
    {
        var files = Interlocked.Read(ref _filesScanned);
        var folders = Interlocked.Read(ref _foldersScanned);
        var skipped = _skippedCount;
        var path = _currentPath;

        var display = path.Length > 100
            ? path[..45] + "..." + path[^45..]
            : path;

        lblStatus.Text = $"Scanning: {files:N0} files, {folders:N0} folders scanned... {display}";

        // Update the root node text with running totals if we have data (skip during sub-scan)
        if (_subScanNode == null && _scanRoot != null && treeResults.Nodes.Count > 0)
        {
            RefreshTree();
        }
    }

    private void RefreshTree()
    {
        var root = _scanRoot;
        if (root == null || treeResults.Nodes.Count == 0) return;

        treeResults.BeginUpdate();
        var rootNode = treeResults.Nodes[0];
        UpdateNodeFromInfo(rootNode, root, root.TotalSize);
        treeResults.EndUpdate();
    }

    private void UpdateNodeFromInfo(TreeNode node, FolderInfo folder, long rootTotal)
    {
        node.Text = folder.Name;
        node.Tag = folder;

        // Build a map of existing child nodes by path
        var existingChildren = new Dictionary<string, TreeNode>();
        foreach (TreeNode child in node.Nodes)
        {
            if (child.Tag is FolderInfo fi)
                existingChildren[fi.Path] = child;
        }

        // Get children sorted by size descending
        List<FolderInfo> sortedChildren;
        lock (folder.Children)
        {
            sortedChildren = folder.Children.OrderByDescending(c => c.TotalSize).ToList();
        }

        // Sync tree nodes with folder children
        // Remove nodes for children that no longer exist
        for (int i = node.Nodes.Count - 1; i >= 0; i--)
        {
            if (node.Nodes[i].Tag is FolderInfo fi && !sortedChildren.Any(c => c.Path == fi.Path))
                node.Nodes.RemoveAt(i);
        }

        // Add/update nodes in sorted order
        for (int i = 0; i < sortedChildren.Count; i++)
        {
            var childInfo = sortedChildren[i];
            TreeNode childNode;

            if (existingChildren.TryGetValue(childInfo.Path, out var existing))
            {
                childNode = existing;
                // Move to correct position if needed
                if (node.Nodes.IndexOf(childNode) != i)
                {
                    node.Nodes.Remove(childNode);
                    node.Nodes.Insert(i, childNode);
                }
            }
            else
            {
                childNode = new TreeNode(childInfo.Name);
                node.Nodes.Insert(i, childNode);
            }

            UpdateNodeFromInfo(childNode, childInfo, rootTotal);
        }
    }

    private void OnScanComplete()
    {
        StopTimers();

        var wasCancelled = _cts?.IsCancellationRequested ?? false;
        var root = _scanRoot;

        ResetUiAfterScan();

        if (root == null)
        {
            lblStatus.Text = wasCancelled ? "Scan cancelled (no data)." : "Scan returned no results.";
            progressBar.Value = 0;
            return;
        }

        // Final tree refresh
        treeResults.BeginUpdate();
        treeResults.Nodes.Clear();
        var rootNode = BuildTreeNode(root, root.TotalSize);
        treeResults.Nodes.Add(rootNode);
        treeResults.EndUpdate();

        btnExport.Enabled = true;
        progressBar.Value = wasCancelled ? 0 : 100;
        var skipped = _skippedCount > 0 ? $" | {_skippedCount} junctions skipped" : "";
        var cancelNote = wasCancelled ? " [PARTIAL — cancelled]" : "";
        lblStatus.Text = $"Done — {FormatSize(root.TotalSize)} total | " +
                          $"{root.FileCount:N0} files | {root.FolderCount:N0} folders " +
                          $"(depth: {_maxDepth}){skipped}{cancelNote}";
    }

    private void ResetUiAfterScan()
    {
        _scanRunning = false;
        btnScan.Text = "Scan";
        btnScan.IsPrimary = true;
        btnScan.Enabled = true;
        btnBrowse.Enabled = true;
        nudDepth.Enabled = true;
        progressBar.IsMarquee = false;
    }

    // ── Fast Win32 scanner ──────────────────────────────────────────

    private struct FastEntry
    {
        public string Name;
        public bool IsDirectory;
        public bool IsReparsePoint;
        public long Size;
    }

    private static List<FastEntry> FastScanDirectory(string path)
    {
        var results = new List<FastEntry>();
        var searchPath = path.Length > 0 && path[^1] == '\\'
            ? path + "*"
            : path + "\\*";

        var handle = FindFirstFileW(searchPath, out var findData);
        if (handle == INVALID_HANDLE_VALUE)
            return results;

        try
        {
            do
            {
                var name = findData.cFileName;
                if (name == "." || name == "..")
                    continue;

                var isDir = (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
                var isReparse = (findData.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0;
                long size = isDir ? 0 : ((long)findData.nFileSizeHigh << 32) | findData.nFileSizeLow;

                results.Add(new FastEntry
                {
                    Name = name,
                    IsDirectory = isDir,
                    IsReparsePoint = isReparse,
                    Size = size
                });
            } while (FindNextFileW(handle, out findData));
        }
        finally
        {
            FindClose(handle);
        }

        return results;
    }

    // ── Scan engine ─────────────────────────────────────────────────

    private FolderInfo ScanFolder(string path, int currentDepth, CancellationToken ct)
    {
        var info = new FolderInfo { Path = path, Name = Path.GetFileName(path) };
        if (string.IsNullOrEmpty(info.Name))
            info.Name = path;

        // Store root reference early for partial results (skip during sub-scan)
        if (currentDepth == 0 && _subScanNode == null)
            _scanRoot = info;

        ct.ThrowIfCancellationRequested();

        Volatile.Write(ref _currentPath, path);

        // Single Win32 call gets all entries with attributes + sizes
        List<FastEntry> entries;
        try
        {
            entries = FastScanDirectory(path);
        }
        catch
        {
            info.AccessDenied = true;
            return info;
        }

        // Process files from this directory
        foreach (var entry in entries)
        {
            if (entry.IsDirectory) continue;
            info.OwnSize += entry.Size;
            info.FileCount++;
            Interlocked.Increment(ref _filesScanned);
        }

        // Collect subdirectories
        var subdirs = new List<(string FullPath, string Name)>();
        foreach (var entry in entries)
        {
            if (!entry.IsDirectory) continue;
            if (entry.IsReparsePoint)
            {
                Interlocked.Increment(ref _skippedCount);
                continue;
            }
            subdirs.Add((Path.Combine(path, entry.Name), entry.Name));
        }

        // Decide parallel vs sequential
        if (currentDepth <= ParallelDepthLimit && subdirs.Count > 1)
        {
            ScanSubdirsParallel(info, subdirs, currentDepth, ct);
        }
        else
        {
            ScanSubdirsSequential(info, subdirs, currentDepth, ct);
        }

        info.TotalSize += info.OwnSize;

        Interlocked.Increment(ref _foldersScanned);

        return info;
    }

    private void ScanSubdirsParallel(FolderInfo parent, List<(string FullPath, string Name)> subdirs,
        int currentDepth, CancellationToken ct)
    {
        var parallelOptions = new ParallelOptions
        {
            MaxDegreeOfParallelism = Environment.ProcessorCount,
            CancellationToken = ct
        };

        Parallel.ForEach(subdirs, parallelOptions, subdir =>
        {
            ct.ThrowIfCancellationRequested();

            try
            {
                if (currentDepth < _maxDepth)
                {
                    var child = ScanFolder(subdir.FullPath, currentDepth + 1, ct);
                    lock (parent.Children)
                    {
                        parent.Children.Add(child);
                    }
                    Interlocked.Add(ref parent._totalSize, child.TotalSize);
                    Interlocked.Add(ref parent._fileCount, child.FileCount);
                    Interlocked.Add(ref parent._folderCount, child.FolderCount + 1);
                }
                else
                {
                    var (size, files, folders) = TallyFolder(subdir.FullPath, 0, ct);
                    Interlocked.Add(ref parent._totalSize, size);
                    Interlocked.Add(ref parent._fileCount, files);
                    Interlocked.Add(ref parent._folderCount, folders + 1);
                }
            }
            catch (OperationCanceledException) { throw; }
            catch { }
        });
    }

    private void ScanSubdirsSequential(FolderInfo parent, List<(string FullPath, string Name)> subdirs,
        int currentDepth, CancellationToken ct)
    {
        foreach (var subdir in subdirs)
        {
            ct.ThrowIfCancellationRequested();

            try
            {
                if (currentDepth < _maxDepth)
                {
                    var child = ScanFolder(subdir.FullPath, currentDepth + 1, ct);
                    parent.Children.Add(child);
                    parent.TotalSize += child.TotalSize;
                    parent.FileCount += child.FileCount;
                    parent.FolderCount += child.FolderCount + 1;
                }
                else
                {
                    var (size, files, folders) = TallyFolder(subdir.FullPath, 0, ct);
                    parent.TotalSize += size;
                    parent.FileCount += files;
                    parent.FolderCount += folders + 1;
                }
            }
            catch (OperationCanceledException) { throw; }
            catch { }
        }
    }

    private (long size, int files, int folders) TallyFolder(string path, int depth, CancellationToken ct)
    {
        if (depth > HardRecursionLimit)
            return (0, 0, 0);

        ct.ThrowIfCancellationRequested();

        Volatile.Write(ref _currentPath, path);

        List<FastEntry> entries;
        try
        {
            entries = FastScanDirectory(path);
        }
        catch
        {
            return (0, 0, 0);
        }

        long size = 0;
        int files = 0;
        int folders = 0;

        foreach (var entry in entries)
        {
            if (!entry.IsDirectory)
            {
                size += entry.Size;
                files++;
                Interlocked.Increment(ref _filesScanned);
            }
        }

        foreach (var entry in entries)
        {
            if (!entry.IsDirectory) continue;
            if (entry.IsReparsePoint)
            {
                Interlocked.Increment(ref _skippedCount);
                continue;
            }

            ct.ThrowIfCancellationRequested();

            try
            {
                var fullPath = Path.Combine(path, entry.Name);
                var (s, f, d) = TallyFolder(fullPath, depth + 1, ct);
                size += s;
                files += f;
                folders += d + 1;
            }
            catch (OperationCanceledException) { throw; }
            catch { }
        }

        Interlocked.Increment(ref _foldersScanned);

        return (size, files, folders);
    }

    // ── Tree building (final) ───────────────────────────────────────

    private static TreeNode BuildTreeNode(FolderInfo folder, long rootTotal)
    {
        var node = new TreeNode(folder.Name) { Tag = folder };

        List<FolderInfo> sorted;
        lock (folder.Children)
        {
            sorted = folder.Children.OrderByDescending(c => c.TotalSize).ToList();
        }

        foreach (var child in sorted)
        {
            node.Nodes.Add(BuildTreeNode(child, rootTotal));
        }

        return node;
    }

    // ── UI events ───────────────────────────────────────────────────

    private void TreeResults_NodeMouseDoubleClick(object? sender, TreeNodeMouseClickEventArgs e)
    {
        if (e.Node?.Tag is FolderInfo info)
        {
            try
            {
                Process.Start(new ProcessStartInfo
                {
                    FileName = info.Path,
                    UseShellExecute = true
                });
            }
            catch { }
        }
    }

    private void BtnExport_Click(object sender, EventArgs e)
    {
        if (treeResults.Nodes.Count == 0) return;

        using var dlg = new SaveFileDialog
        {
            Filter = "Text Files|*.txt|CSV Files|*.csv",
            FileName = "FolderSizes"
        };

        if (dlg.ShowDialog() != DialogResult.OK) return;

        var root = (FolderInfo)treeResults.Nodes[0].Tag!;
        using var writer = new StreamWriter(dlg.FileName);

        if (dlg.FilterIndex == 2)
        {
            writer.WriteLine("Path,Size (Bytes),Size,Files,Folders");
            ExportCsv(writer, root);
        }
        else
        {
            ExportText(writer, root, 0);
        }

        lblStatus.Text = $"Exported to {dlg.FileName}";
    }

    private static void ExportText(StreamWriter writer, FolderInfo folder, int indent)
    {
        var prefix = new string(' ', indent * 2);
        writer.WriteLine($"{prefix}{folder.Name}  --  {FormatSize(folder.TotalSize)}  ({folder.FileCount:N0} files)");
        List<FolderInfo> sorted;
        lock (folder.Children)
        {
            sorted = folder.Children.OrderByDescending(c => c.TotalSize).ToList();
        }
        foreach (var child in sorted)
            ExportText(writer, child, indent + 1);
    }

    private static void ExportCsv(StreamWriter writer, FolderInfo folder)
    {
        writer.WriteLine($"\"{folder.Path}\",{folder.TotalSize},\"{FormatSize(folder.TotalSize)}\",{folder.FileCount},{folder.FolderCount}");
        List<FolderInfo> sorted;
        lock (folder.Children)
        {
            sorted = folder.Children.OrderByDescending(c => c.TotalSize).ToList();
        }
        foreach (var child in sorted)
            ExportCsv(writer, child);
    }

    private static string FormatSize(long bytes)
    {
        string[] units = ["B", "KB", "MB", "GB", "TB"];
        double size = bytes;
        int unit = 0;
        while (size >= 1024 && unit < units.Length - 1)
        {
            size /= 1024;
            unit++;
        }
        return unit == 0 ? $"{size:N0} {units[unit]}" : $"{size:N2} {units[unit]}";
    }

    // ── Sub-scan (right-click "Scan from here") ──────────────────────

    private void CtxTree_Opening(object? sender, CancelEventArgs e)
    {
        if (_scanRunning)
        {
            e.Cancel = true;
            return;
        }

        var pos = treeResults.PointToClient(Cursor.Position);
        var node = treeResults.GetNodeAt(pos);
        if (node?.Tag is not FolderInfo)
        {
            e.Cancel = true;
            return;
        }

        treeResults.SelectedNode = node;
    }

    private void CtxScanFromHere_Click(object? sender, EventArgs e)
    {
        var node = treeResults.SelectedNode;
        if (node?.Tag is not FolderInfo folderInfo || _scanRunning) return;

        var path = folderInfo.Path;
        if (!Directory.Exists(path))
        {
            MessageBox.Show($"Folder no longer exists:\n{path}", "Invalid Path",
                MessageBoxButtons.OK, MessageBoxIcon.Warning);
            return;
        }

        _subScanNode = node;
        _maxDepth = (int)nudDepth.Value;

        // Set up UI — keep existing tree visible
        progressBar.Value = 0;
        progressBar.IsMarquee = true;
        lblStatus.Text = $"Scanning {folderInfo.Name}...";
        btnScan.Text = "Cancel";
        btnScan.IsPrimary = false;
        btnBrowse.Enabled = false;
        btnExport.Enabled = false;
        nudDepth.Enabled = false;

        _skippedCount = 0;
        _filesScanned = 0;
        _foldersScanned = 0;
        _currentPath = "";
        _cts = new CancellationTokenSource();
        _scanRunning = true;

        // Start timers
        _uiTimer = new System.Windows.Forms.Timer { Interval = 200 };
        _uiTimer.Tick += UiTimer_Tick;
        _uiTimer.Start();

        _animTimer = new System.Windows.Forms.Timer { Interval = 16 };
        _animTimer.Tick += (_, _) => progressBar.AdvanceAnimation();
        _animTimer.Start();

        var ct = _cts.Token;
        Task.Run(() =>
        {
            FolderInfo? result = null;
            try
            {
                result = ScanFolder(path, 0, ct);
            }
            catch (OperationCanceledException) { }
            catch (Exception ex)
            {
                BeginInvoke(() =>
                {
                    StopTimers();
                    _subScanNode = null;
                    ResetUiAfterScan();
                    lblStatus.Text = "Sub-scan failed.";
                    MessageBox.Show($"{ex.GetType().Name}: {ex.Message}",
                        "Scan Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                });
                return;
            }

            BeginInvoke(() => OnSubScanComplete(node, result));
        }, ct);
    }

    private void OnSubScanComplete(TreeNode node, FolderInfo? newInfo)
    {
        StopTimers();

        var wasCancelled = _cts?.IsCancellationRequested ?? false;

        if (newInfo == null)
        {
            _subScanNode = null;
            ResetUiAfterScan();
            lblStatus.Text = wasCancelled ? "Sub-scan cancelled." : "Sub-scan returned no results.";
            progressBar.Value = 0;
            return;
        }

        MergeSubScan(node, newInfo);

        _subScanNode = null;
        ResetUiAfterScan();
        btnExport.Enabled = true;
        progressBar.Value = wasCancelled ? 0 : 100;

        var root = treeResults.Nodes.Count > 0 ? treeResults.Nodes[0].Tag as FolderInfo : null;
        if (root != null)
        {
            var skipped = _skippedCount > 0 ? $" | {_skippedCount} junctions skipped" : "";
            var cancelNote = wasCancelled ? " [PARTIAL]" : "";
            lblStatus.Text = $"Done — {FormatSize(root.TotalSize)} total | " +
                              $"{root.FileCount:N0} files | {root.FolderCount:N0} folders{skipped}{cancelNote}";
        }
    }

    private void MergeSubScan(TreeNode node, FolderInfo newInfo)
    {
        var oldInfo = node.Tag as FolderInfo;
        long sizeDelta = newInfo.TotalSize - (oldInfo?.TotalSize ?? 0);
        int fileDelta = newInfo.FileCount - (oldInfo?.FileCount ?? 0);
        int folderDelta = newInfo.FolderCount - (oldInfo?.FolderCount ?? 0);

        // Replace in parent FolderInfo's Children list
        if (node.Parent?.Tag is FolderInfo parentInfo && oldInfo != null)
        {
            lock (parentInfo.Children)
            {
                var idx = parentInfo.Children.IndexOf(oldInfo);
                if (idx >= 0)
                    parentInfo.Children[idx] = newInfo;
            }
        }
        else if (node.Parent == null)
        {
            // Re-scanning root node
            _scanRoot = newInfo;
        }

        // Propagate size deltas up the ancestor chain
        var ancestor = node.Parent;
        while (ancestor?.Tag is FolderInfo ancestorInfo)
        {
            Interlocked.Add(ref ancestorInfo._totalSize, sizeDelta);
            Interlocked.Add(ref ancestorInfo._fileCount, fileDelta);
            Interlocked.Add(ref ancestorInfo._folderCount, folderDelta);
            ancestor = ancestor.Parent;
        }

        // Update this node and rebuild its subtree
        node.Tag = newInfo;
        node.Text = newInfo.Name;

        long rootTotal = GetTreeRootTotal();
        treeResults.BeginUpdate();
        node.Nodes.Clear();

        List<FolderInfo> sorted;
        lock (newInfo.Children)
        {
            sorted = newInfo.Children.OrderByDescending(c => c.TotalSize).ToList();
        }
        foreach (var child in sorted)
        {
            node.Nodes.Add(BuildTreeNode(child, rootTotal));
        }

        node.Expand();
        treeResults.EndUpdate();
        treeResults.Invalidate();
    }

    private long GetTreeRootTotal()
    {
        if (treeResults.Nodes.Count > 0 && treeResults.Nodes[0].Tag is FolderInfo rootInfo)
            return rootInfo.TotalSize;
        return _scanRoot?.TotalSize ?? 0;
    }

    private void StopTimers()
    {
        _uiTimer?.Stop();
        _uiTimer?.Dispose();
        _uiTimer = null;
        _animTimer?.Stop();
        _animTimer?.Dispose();
        _animTimer = null;
    }

    // ── Card panel paint (rounded border) ───────────────────────────

    private void PaintCardPanel(object? sender, PaintEventArgs e)
    {
        if (sender is not Panel panel) return;
        var g = e.Graphics;
        g.SmoothingMode = SmoothingMode.AntiAlias;
        var rect = new RectangleF(0.5f, 0.5f, panel.Width - 1f, panel.Height - 1f);
        using var path = ModernTheme.RoundedRect(rect, ModernTheme.CardRadius);
        using var pen = new Pen(ModernTheme.CardBorder, 1f);
        g.DrawPath(pen, path);
    }

    // ── Textbox wrapper paint (rounded border, accent on focus) ─────

    private void PnlPathWrapper_Paint(object? sender, PaintEventArgs e)
    {
        if (sender is not Panel panel) return;
        var g = e.Graphics;
        g.SmoothingMode = SmoothingMode.AntiAlias;
        var rect = new RectangleF(0.5f, 0.5f, panel.Width - 1f, panel.Height - 1f);
        using var path = ModernTheme.RoundedRect(rect, ModernTheme.ButtonRadius);
        var borderColor = txtPath.Focused ? ModernTheme.Accent : ModernTheme.CardBorder;
        var thickness = txtPath.Focused ? 2f : 1f;
        using var pen = new Pen(borderColor, thickness);
        g.DrawPath(pen, path);
    }

    private void TxtPath_FocusChanged(object? sender, EventArgs e)
    {
        pnlPathWrapper.Invalidate();
    }

    private void Form1_KeyDown(object? sender, KeyEventArgs e)
    {
        if (e.KeyCode == Keys.Enter)
        {
            e.SuppressKeyPress = true;
            BtnScan_Click(this, EventArgs.Empty);
        }
    }
}

public class FolderInfo
{
    public string Path { get; set; } = "";
    public string Name { get; set; } = "";
    public long OwnSize { get; set; }
    public bool AccessDenied { get; set; }
    public List<FolderInfo> Children { get; set; } = [];

    // Backing fields for Interlocked access in parallel scans
    internal long _totalSize;
    internal long _fileCount;
    internal long _folderCount;

    public long TotalSize
    {
        get => Interlocked.Read(ref _totalSize);
        set => Interlocked.Exchange(ref _totalSize, value);
    }

    public int FileCount
    {
        get => (int)Interlocked.Read(ref _fileCount);
        set => Interlocked.Exchange(ref _fileCount, value);
    }

    public int FolderCount
    {
        get => (int)Interlocked.Read(ref _folderCount);
        set => Interlocked.Exchange(ref _folderCount, value);
    }
}