Mac-utlity-app

//  LargeFilesView.swift

//  MUA

//

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

//

import SwiftUI

/// View for finding large files quickly

struct LargeFilesView: View {

    @State private var files: [FileItem] = []

    @State private var isScanning = false

    @State private var scanProgress: Double = 0

    @State private var selectedFile: FileItem?

    @State private var minimumSize: Int64 = 100_000_000 // 100 MB

    @State private var searchPath: URL = FileManager.default.homeDirectoryForCurrentUser

    private let sizeOptions: [(String, Int64)] = [

        ("10 MB", 10_000_000),

        ("50 MB", 50_000_000),

        ("100 MB", 100_000_000),

        ("500 MB", 500_000_000),

        ("1 GB", 1_000_000_000),

    ]

    var body: some View {

        VStack(spacing: 0) {

            // Toolbar

            toolbar

            // Content

            if isScanning {

                scanningView

            } else if files.isEmpty {

                emptyView

            } else {

                filesList

            }

        }

        .background(Color(nsColor: .windowBackgroundColor))

    }

    private var toolbar: some View {

        HStack(spacing: 16) {

            // Size picker

            Picker("Minimum size", selection: $minimumSize) {

                ForEach(sizeOptions, id: \.1) { option in

                    Text(option.0).tag(option.1)

                }

            }

            .pickerStyle(.segmented)

            .frame(maxWidth: 400)

            Spacer()

            // Scan button

            Button {

                Task { await scanForLargeFiles() }

            } label: {

                Label("Scan Home", systemImage: "magnifyingglass")

            }

            .buttonStyle(.borderedProminent)

            .disabled(isScanning)

            // Total size badge

            if !files.isEmpty {

                let totalSize = files.reduce(0) { $0 + $1.size }

                Text("Total: \(ByteCountFormatter.string(fromByteCount: totalSize, countStyle: .file))")

                    .font(.subheadline)

                    .foregroundStyle(.secondary)

                    .padding(.horizontal, 12)

                    .padding(.vertical, 6)

                    .background(.ultraThinMaterial, in: Capsule())

            }

        }

        .padding()

        .background(.ultraThinMaterial)

    }

    private var scanningView: some View {

        VStack(spacing: 20) {

            ProgressView(value: scanProgress)

                .progressViewStyle(.circular)

                .scaleEffect(1.5)

            Text("Searching for large files...")

                .font(.headline)

            Text("\(files.count) files found")

                .font(.subheadline)

                .foregroundStyle(.secondary)

        }

        .frame(maxWidth: .infinity, maxHeight: .infinity)

    }

    private var emptyView: some View {

        VStack(spacing: 16) {

            Image(systemName: "doc.badge.arrow.up")

                .font(.system(size: 56))

                .foregroundStyle(.quaternary)

            Text("Find Large Files")

                .font(.title2)

                .fontWeight(.medium)

            Text("Scan to find files larger than \(ByteCountFormatter.string(fromByteCount: minimumSize, countStyle: .file))")

                .font(.subheadline)

                .foregroundStyle(.secondary)

            Button {

                Task { await scanForLargeFiles() }

            } label: {

                Label("Start Scan", systemImage: "magnifyingglass")

            }

            .buttonStyle(.borderedProminent)

            .controlSize(.large)

        }

        .frame(maxWidth: .infinity, maxHeight: .infinity)

    }

    private var filesList: some View {

        HSplitView {

            // File list

            List(selection: $selectedFile) {

                ForEach(files) { file in

                    LargeFileRow(file: file, isSelected: selectedFile?.id == file.id)

                        .tag(file)

                        .listRowSeparator(.hidden)

                        .listRowInsets(EdgeInsets(top: 4, leading: 8, bottom: 4, trailing: 8))

                }

            }

            .listStyle(.plain)

            .frame(minWidth: 400)

            // Detail panel

            DetailPanelView(item: selectedFile)

        }

    }

    private func scanForLargeFiles() async {

        isScanning = true

        files = []

        scanProgress = 0

        let searchURL = searchPath

        let minSize = minimumSize

        // Perform file enumeration on background thread using a static helper

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

            Self.scanForFilesSync(at: searchURL, minSize: minSize)

        }.value

        files = foundFiles

        isScanning = false

        scanProgress = 1.0

    }

    /// Synchronous file scanning helper - runs on background thread

    private nonisolated static func scanForFilesSync(at url: URL, minSize: Int64) -> [FileItem] {

        let fileManager = FileManager.default

        var results: [FileItem] = []

        guard let enumerator = fileManager.enumerator(

            at: url,

            includingPropertiesForKeys: [.fileSizeKey, .isDirectoryKey],

            options: [.skipsHiddenFiles, .skipsPackageDescendants]

        ) else {

            return results

        }

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

            do {

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

                guard resourceValues.isDirectory == false else { continue }

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

                if size >= minSize {

                    let item = FileItem(url: fileURL, isDirectory: false, size: size)

                    results.append(item)

                }

            } catch {

                continue

            }

        }

        return results.sorted { $0.size > $1.size }

    }

}

struct LargeFileRow: View {

    let file: FileItem

    let isSelected: Bool

    @State private var isHovered = false

    var body: some View {

        HStack(spacing: 12) {

            // Icon with glass effect

            ZStack {

                RoundedRectangle(cornerRadius: 8)

                    .fill(

                        .linearGradient(

                            colors: [

                                file.color.opacity(0.6),

                                file.color.opacity(0.3)

                            ],

                            startPoint: .topLeading,

                            endPoint: .bottomTrailing

                        )

                    )

                    .frame(width: 40, height: 40)

                    .overlay(

                        RoundedRectangle(cornerRadius: 8)

                            .strokeBorder(.white.opacity(0.2), lineWidth: 1)

                    )

                Image(systemName: file.icon)

                    .foregroundStyle(.white)

            }

            VStack(alignment: .leading, spacing: 2) {

                Text(file.name)

                    .lineLimit(1)

                    .truncationMode(.middle)

                Text(file.url.deletingLastPathComponent().path)

                    .font(.caption)

                    .foregroundStyle(.tertiary)

                    .lineLimit(1)

                    .truncationMode(.middle)

            }

            Spacer()

            Text(file.formattedSize)

                .font(.system(.body, design: .rounded, weight: .medium))

                .foregroundStyle(.secondary)

        }

        .padding(8)

        .background(

            RoundedRectangle(cornerRadius: 10)

                .fill(isSelected ? Color.accentColor.opacity(0.1) : (isHovered ? Color.primary.opacity(0.03) : Color.clear))

        )

        .onHover { hovering in

            isHovered = hovering

        }

        .contextMenu {

            Button("Show in Finder") {

                NSWorkspace.shared.selectFile(file.url.path, inFileViewerRootedAtPath: file.url.deletingLastPathComponent().path)

            }

            Button("Move to Trash", role: .destructive) {

                do {

                    try FileManager.default.trashItem(at: file.url, resultingItemURL: nil)

                } catch {

                    print("Failed to trash: \(error)")

                }

            }

        }

    }

}

#Preview {

    LargeFilesView()

        .frame(width: 800, height: 600)

}