Mac-utlity-app

//  DiskAnalyzer.swift

//  MUA

//

//  Created by Mitchel Volkering on 21/12/2025.

//

import Foundation

/// Thread-safe progress reporter for disk scanning

final class ScanProgress: @unchecked Sendable {

    private let lock = NSLock()

    private var _currentPath: String = ""

    private var _scannedCount: Int = 0

    private var _totalTopLevel: Int = 0

    private var _completedTopLevel: Int = 0

    var currentPath: String {

        lock.lock()

        defer { lock.unlock() }

        return _currentPath

    }

    var scannedCount: Int {

        lock.lock()

        defer { lock.unlock() }

        return _scannedCount

    }

    var progress: Double {

        lock.lock()

        defer { lock.unlock() }

        guard _totalTopLevel > 0 else { return 0 }

        return Double(_completedTopLevel) / Double(_totalTopLevel)

    }

    func update(path: String) {

        lock.lock()

        _currentPath = path

        _scannedCount += 1

        lock.unlock()

    }

    func setTotalTopLevel(_ count: Int) {

        lock.lock()

        _totalTopLevel = count

        lock.unlock()

    }

    func completeTopLevel() {

        lock.lock()

        _completedTopLevel += 1

        lock.unlock()

    }

}

/// Service for analyzing disk space usage

@Observable

@MainActor

final class DiskAnalyzer {

    var rootItem: FileItem?

    var isScanning = false

    var scanProgress: Double = 0

    var currentPath: String = ""

    var scannedCount: Int = 0

    var error: String?

    private var progressReporter: ScanProgress?

    private var progressTask: Task<Void, Never>?

    /// Analyze a directory and build the file tree

    func analyze(url: URL) async {

        isScanning = true

        scanProgress = 0

        scannedCount = 0

        error = nil

        currentPath = url.path

        let scanURL = url

        let progress = ScanProgress()

        self.progressReporter = progress

        // Start progress monitoring task

        progressTask = Task { [weak self] in

            while !Task.isCancelled {

                try? await Task.sleep(for: .milliseconds(100))

                guard let self = self, self.isScanning else { break }

                self.currentPath = progress.currentPath

                self.scannedCount = progress.scannedCount

                self.scanProgress = progress.progress

            }

        }

        // Perform heavy scanning on background thread using static helper

        let result = await Task.detached(priority: .userInitiated) {

            Self.scanDirectorySync(url: scanURL, parent: nil, depth: 0, progress: progress, isTopLevel: true)

        }.value

        progressTask?.cancel()

        progressTask = nil

        if let item = result {

            // Sort children by size for better visualization

            item.children.sort { $0.size > $1.size }

            rootItem = item

            scanProgress = 1.0

            // Check if we got limited results

            if item.children.isEmpty {

                error = "No accessible folders found. Check Full Disk Access."

            } else if item.children.count == 1 {

                error = "Limited access. Only \(item.children.first?.name ?? "one folder") accessible."

            }

        } else {

            error = "Could not scan directory. Check permissions."

        }

        isScanning = false

    }

    /// Scan a directory recursively (runs on background thread)

    /// Static and nonisolated to avoid actor isolation issues

    private nonisolated static func scanDirectorySync(

        url: URL,

        parent: FileItem?,

        depth: Int,

        progress: ScanProgress,

        isTopLevel: Bool = false

    ) -> FileItem? {

        let fileManager = FileManager.default

        let item = FileItem(url: url, isDirectory: true, parent: parent)

        progress.update(path: url.path)

        // Get directory contents

        let contents: [URL]

        do {

            contents = try fileManager.contentsOfDirectory(

                at: url,

                includingPropertiesForKeys: [.isDirectoryKey, .fileSizeKey, .totalFileSizeKey],

                options: [] // Don't skip hidden files to get accurate sizes

            )

        } catch {

            // Can't access directory - return empty item with zero size

            return item

        }

        // Set total for progress tracking at top level

        if isTopLevel {

            progress.setTotalTopLevel(contents.count)

        }

        var children: [FileItem] = []

        var totalSize: Int64 = 0

        for contentURL in contents {

            do {

                let resourceValues = try contentURL.resourceValues(forKeys: [.isDirectoryKey, .fileSizeKey, .totalFileSizeKey])

                let isDir = resourceValues.isDirectory ?? false

                if isDir {

                    // Recursively scan subdirectory (limit depth to prevent hanging)

                    if depth < 10 {

                        if let childItem = scanDirectorySync(url: contentURL, parent: item, depth: depth + 1, progress: progress) {

                            children.append(childItem)

                            totalSize += childItem.size

                        }

                    } else {

                        // For deep directories, just estimate size without full recursion

                        let estimatedSize = quickDirectorySize(url: contentURL)

                        let childItem = FileItem(url: contentURL, isDirectory: true, size: estimatedSize, parent: item)

                        children.append(childItem)

                        totalSize += estimatedSize

                    }

                } else {

                    // Regular file

                    let fileSize = Int64(resourceValues.totalFileSize ?? resourceValues.fileSize ?? 0)

                    let childItem = FileItem(url: contentURL, isDirectory: false, size: fileSize, parent: item)

                    children.append(childItem)

                    totalSize += fileSize

                }

            } catch {

                // Skip files we can't access

                continue

            }

            // Update progress for top-level items

            if isTopLevel {

                progress.completeTopLevel()

            }

        }

        // Sort children by size (largest first) for better visualization

        children.sort { $0.size > $1.size }

        item.children = children

        item.size = totalSize

        return item

    }

    /// Quick size estimation for deep directories

    private nonisolated static func quickDirectorySize(url: URL) -> Int64 {

        let fileManager = FileManager.default

        var totalSize: Int64 = 0

        guard let enumerator = fileManager.enumerator(

            at: url,

            includingPropertiesForKeys: [.fileSizeKey],

            options: [.skipsHiddenFiles, .skipsPackageDescendants]

        ) else {

            return 0

        }

        while let fileURL = enumerator.nextObject() as? URL {

            do {

                let resourceValues = try fileURL.resourceValues(forKeys: [.fileSizeKey])

                totalSize += Int64(resourceValues.fileSize ?? 0)

            } catch {

                continue

            }

        }

        return totalSize

    }

    /// Get size of a single file or directory (without full recursive scan)

    nonisolated func getQuickSize(url: URL) -> Int64 {

        let fileManager = FileManager.default

        var isDirectory: ObjCBool = false

        guard fileManager.fileExists(atPath: url.path, isDirectory: &isDirectory) else {

            return 0

        }

        if !isDirectory.boolValue {

            do {

                let attrs = try fileManager.attributesOfItem(atPath: url.path)

                return attrs[.size] as? Int64 ?? 0

            } catch {

                return 0

            }

        }

        // For directories, use a quick enumeration

        var totalSize: Int64 = 0

        if let enumerator = fileManager.enumerator(at: url, includingPropertiesForKeys: [.fileSizeKey], options: [.skipsHiddenFiles]) {

            while let fileURL = enumerator.nextObject() as? URL {

                do {

                    let resourceValues = try fileURL.resourceValues(forKeys: [.fileSizeKey])

                    totalSize += Int64(resourceValues.fileSize ?? 0)

                } catch {

                    continue

                }

            }

        }

        return totalSize

    }

    /// Cancel ongoing scan

    func cancel() {

        progressTask?.cancel()

        isScanning = false

    }

    /// Clear results

    func reset() {

        rootItem = nil

        isScanning = false

        scanProgress = 0

        currentPath = ""

        scannedCount = 0

        error = nil

    }

}