import AppKit
import CoreServices
import Darwin
import SwiftUI

struct AppHistoryView: View {
    @Environment(SystemMonitor.self) private var monitor
    let searchText: String
    let onShowDetails: (ProcessRecord) -> Void
    @State private var selection: String?
    @State private var inspectedUsage: AppUsageRecord?
    @State private var showingResetConfirmation = false

    var body: some View {
        VStack(spacing: 0) {
            PageHeader(
                title: "App history",
                subtitle: "Resource usage since \(monitor.appHistoryStartDate.formatted(date: .abbreviated, time: .shortened))"
            ) {
                Button("Reset usage data", systemImage: "arrow.counterclockwise") {
                    showingResetConfirmation = true
                }
                .disabled(monitor.appHistory.isEmpty)
            }
            if filtered.isEmpty {
                EmptyState(
                    icon: "clock.arrow.circlepath",
                    title: searchText.isEmpty ? "Collecting app history" : "No matching apps",
                    message: searchText.isEmpty
                        ? "CPU and network usage will appear as applications run."
                        : "Try a different app name, user, or path."
                )
            } else {
                Table(Array(filtered.prefix(250)), selection: $selection) {
                    TableColumn("Name") { usage in
                        HStack(spacing: 8) {
                            ProcessIcon(name: usage.name, path: usage.executablePath)
                            Text(usage.name).lineLimit(1)
                        }
                    }.width(min: 170, ideal: 260)
                    TableColumn("CPU time") { usage in
                        Text(Formatters.duration(usage.cpuSeconds)).monospacedDigit()
                    }.width(90)
                    TableColumn("Network") { usage in
                        Text(Formatters.bytes.string(fromByteCount: Int64(usage.networkTotalBytes))).monospacedDigit()
                    }.width(100)
                    TableColumn("Downloads") { usage in
                        Text(Formatters.bytes.string(fromByteCount: Int64(usage.networkReceivedBytes))).monospacedDigit()
                    }.width(100)
                    TableColumn("Uploads") { usage in
                        Text(Formatters.bytes.string(fromByteCount: Int64(usage.networkSentBytes))).monospacedDigit()
                    }.width(100)
                    TableColumn("Last used") { usage in
                        Text(usage.lastSeen, style: .relative).foregroundStyle(.secondary)
                    }.width(min: 90, ideal: 115)
                }
                .contextMenu(forSelectionType: String.self) { selectedIDs in
                    if let id = selectedIDs.first,
                       let usage = monitor.appHistory.first(where: { $0.id == id }) {
                        appHistoryMenu(usage)
                    }
                }
            }
        }
        .alert("Reset app usage history?", isPresented: $showingResetConfirmation) {
            Button("Cancel", role: .cancel) {}
            Button("Reset", role: .destructive) { monitor.resetAppHistory() }
        } message: {
            Text("CPU time and network totals collected by Puter will be permanently cleared.")
        }
        .sheet(item: $inspectedUsage) { AppUsagePropertiesView(usage: $0) }
    }

    private var filtered: [AppUsageRecord] {
        monitor.appHistory.filter {
            searchText.isEmpty
                || $0.name.localizedCaseInsensitiveContains(searchText)
                || $0.user.localizedCaseInsensitiveContains(searchText)
                || $0.executablePath.localizedCaseInsensitiveContains(searchText)
        }.sorted {
            if $0.cpuSeconds != $1.cpuSeconds { return $0.cpuSeconds > $1.cpuSeconds }
            return $0.name.localizedCaseInsensitiveCompare($1.name) == .orderedAscending
        }
    }

    @ViewBuilder
    private func appHistoryMenu(_ usage: AppUsageRecord) -> some View {
        Button("Go to details", systemImage: "list.bullet.rectangle") {
            guard let process = monitor.activeProcess(for: usage) else { return }
            onShowDetails(process)
        }
        .disabled(monitor.activeProcess(for: usage) == nil)

        Divider()

        Button("Open file location", systemImage: "folder") {
            NSWorkspace.shared.activateFileViewerSelecting([URL(fileURLWithPath: usage.executablePath)])
        }
        .disabled(!usage.executablePath.hasPrefix("/"))

        Button("Search online", systemImage: "magnifyingglass") {
            guard let query = usage.name.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed),
                  let url = URL(string: "https://www.google.com/search?q=\(query)+macOS+app") else { return }
            NSWorkspace.shared.open(url)
        }

        Menu("Copy", systemImage: "doc.on.doc") {
            Button("Name") { copy(usage.name) }
            Button("CPU time") { copy(Formatters.duration(usage.cpuSeconds)) }
            Button("Network total") { copy(Formatters.bytes.string(fromByteCount: Int64(usage.networkTotalBytes))) }
            Button("Executable path") { copy(usage.executablePath) }
            Button("All details") {
                copy("\(usage.name)\tCPU \(Formatters.duration(usage.cpuSeconds))\tNetwork \(Formatters.bytes.string(fromByteCount: Int64(usage.networkTotalBytes)))\t\(usage.executablePath)")
            }
        }

        Button("Properties", systemImage: "info.circle") { inspectedUsage = usage }
    }

    private func copy(_ value: String) {
        NSPasteboard.general.clearContents()
        NSPasteboard.general.setString(value, forType: .string)
    }
}

private struct AppUsagePropertiesView: View {
    @Environment(\.dismiss) private var dismiss
    let usage: AppUsageRecord

    var body: some View {
        VStack(spacing: 0) {
            HStack(spacing: 14) {
                ProcessIcon(name: usage.name, path: usage.executablePath).scaleEffect(1.35).frame(width: 42, height: 42)
                VStack(alignment: .leading, spacing: 3) {
                    Text(usage.name).font(.title2.weight(.semibold))
                    Text("Application usage").foregroundStyle(.secondary)
                }
                Spacer()
            }
            .padding(20)
            Divider()
            Grid(alignment: .leading, horizontalSpacing: 24, verticalSpacing: 13) {
                property("Executable", usage.executablePath)
                property("User", usage.user)
                property("CPU time", Formatters.duration(usage.cpuSeconds))
                property("Network", Formatters.bytes.string(fromByteCount: Int64(usage.networkTotalBytes)))
                property("Downloads", Formatters.bytes.string(fromByteCount: Int64(usage.networkReceivedBytes)))
                property("Uploads", Formatters.bytes.string(fromByteCount: Int64(usage.networkSentBytes)))
                property("Last used", usage.lastSeen.formatted(date: .abbreviated, time: .standard))
            }
            .padding(20)
            Divider()
            HStack {
                Button("Reveal in Finder") {
                    NSWorkspace.shared.activateFileViewerSelecting([URL(fileURLWithPath: usage.executablePath)])
                }
                .disabled(!usage.executablePath.hasPrefix("/"))
                Spacer()
                Button("Done") { dismiss() }.keyboardShortcut(.defaultAction)
            }
            .padding(16)
        }
        .frame(width: 570)
    }

    private func property(_ name: String, _ value: String) -> some View {
        GridRow {
            Text(name).foregroundStyle(.secondary).frame(width: 90, alignment: .trailing)
            Text(value).textSelection(.enabled).lineLimit(2).frame(maxWidth: .infinity, alignment: .leading)
        }
    }
}

struct StartupAppsView: View {
    @Environment(SystemMonitor.self) private var monitor
    @State private var items: [StartupItem] = []
    @State private var isLoading = true
    @State private var inspectedItem: StartupItem?

    var body: some View {
        VStack(spacing: 0) {
            PageHeader(title: "Startup apps", subtitle: "Login items and launch agents with estimated live impact") {
                HStack {
                    Button("Refresh", systemImage: "arrow.clockwise") { refreshItems() }
                        .disabled(isLoading)
                    Button("Open Login Items") {
                        openLoginItemsSettings()
                    }
                }
            }
            if isLoading && items.isEmpty {
                VStack(spacing: 12) {
                    ProgressView()
                    Text("Scanning login items…").foregroundStyle(.secondary)
                }
                .frame(maxWidth: .infinity, maxHeight: .infinity)
                .accessibilityElement(children: .combine)
                .accessibilityLabel("Scanning login items")
            } else if items.isEmpty {
                EmptyState(
                    icon: "rectangle.stack.badge.play",
                    title: "No startup items found",
                    message: "Other login items can be managed in System Settings."
                )
            } else {
                Table(items) {
                    TableColumn("Name") { item in
                        HStack(spacing: 8) {
                            ProcessIcon(name: item.name, path: item.executablePath)
                            Text(item.name).lineLimit(1)
                        }
                    }.width(min: 190, ideal: 280)
                    TableColumn("Publisher") { item in Text(item.publisher).lineLimit(1) }.width(min: 90, ideal: 140)
                    TableColumn("Status") { item in
                        Text(item.enabled ? "Enabled" : "Disabled")
                            .foregroundStyle(item.enabled ? .green : .secondary)
                    }.width(80)
                    TableColumn("Startup impact") { item in
                        let impact = startupImpact(for: item)
                        Text(impact.label)
                            .foregroundStyle(impact.color)
                            .help(impact.detail)
                    }.width(105)
                    TableColumn("Type") { item in Text(item.kind.title).foregroundStyle(.secondary) }.width(90)
                }
                .contextMenu(forSelectionType: String.self) { selectedIDs in
                    if let id = selectedIDs.first, let item = items.first(where: { $0.id == id }) {
                        startupMenu(item)
                    }
                }
            }
        }
        .sheet(item: $inspectedItem) { item in
            StartupItemPropertiesView(item: item, impact: startupImpact(for: item))
        }
        .task { refreshItems() }
    }

    private func openLoginItemsSettings() {
        if let url = URL(string: "x-apple.systempreferences:com.apple.LoginItems-Settings.extension") {
            NSWorkspace.shared.open(url)
        }
    }

    private func refreshItems() {
        guard !isLoading || items.isEmpty else { return }
        isLoading = true
        Task {
            items = await Task.detached(priority: .utility) { StartupScanner.scan() }.value
            isLoading = false
        }
    }

    private func startupImpact(for item: StartupItem) -> StartupImpact {
        let candidates = monitor.processes.filter { process in
            guard !item.executablePath.isEmpty else { return false }
            return process.executablePath.hasPrefix(item.executablePath)
                || URL(fileURLWithPath: process.executablePath).lastPathComponent
                    .localizedCaseInsensitiveCompare(URL(fileURLWithPath: item.executablePath).lastPathComponent) == .orderedSame
        }
        guard !candidates.isEmpty else {
            return StartupImpact(label: "Not measured", color: .secondary, detail: "The item is not currently running.")
        }
        let cpu = candidates.reduce(0) { $0 + $1.cpu }
        let memory = candidates.reduce(UInt64(0)) { $0 + $1.residentBytes }
        let disk = candidates.reduce(0.0) { $0 + (monitor.processActivity[$1.pid]?.diskTotal ?? 0) }
        let detail = "Current footprint: CPU \(Formatters.percent(cpu)), memory \(Formatters.bytes.string(fromByteCount: Int64(memory))), disk \(Formatters.rate(disk))."
        if cpu >= 2 || memory >= 1_000_000_000 || disk >= 1_000_000 {
            return StartupImpact(label: "High", color: .red, detail: detail)
        }
        if cpu >= 0.2 || memory >= 250_000_000 || disk >= 100_000 {
            return StartupImpact(label: "Medium", color: .orange, detail: detail)
        }
        return StartupImpact(label: "Low", color: .green, detail: detail)
    }

    @ViewBuilder
    private func startupMenu(_ item: StartupItem) -> some View {
        if item.isDirectlyManageable {
            Button(item.enabled ? "Disable" : "Enable") { setEnabled(!item.enabled, item: item) }
        } else {
            Button("Manage in Login Items", systemImage: "gear") { openLoginItemsSettings() }
        }
        Divider()
        Button("Open file location") {
            NSWorkspace.shared.activateFileViewerSelecting([URL(fileURLWithPath: item.sourcePath)])
        }
        Button("Search online") {
            guard let query = item.name.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed),
                  let url = URL(string: "https://www.google.com/search?q=\(query)+macOS") else { return }
            NSWorkspace.shared.open(url)
        }
        Menu("Copy") {
            Button("Name") { copy(item.name) }
            Button("Path") { copy(item.sourcePath) }
            Button("Identifier") { copy(item.id) }
            Button("Startup impact") { copy(startupImpact(for: item).label) }
        }
        Button("Properties") { inspectedItem = item }
    }

    private func setEnabled(_ enabled: Bool, item: StartupItem) {
        guard item.isDirectlyManageable else {
            openLoginItemsSettings()
            return
        }
        let process = Process()
        process.executableURL = URL(fileURLWithPath: "/bin/launchctl")
        process.arguments = [enabled ? "enable" : "disable", "gui/\(getuid())/\(item.serviceIdentifier)"]
        process.standardOutput = FileHandle.nullDevice
        process.standardError = FileHandle.nullDevice
        do {
            try process.run()
            process.waitUntilExit()
            guard process.terminationStatus == 0 else {
                monitor.errorMessage = "macOS did not allow this startup item to be changed. Try System Settings."
                return
            }
            if let index = items.firstIndex(where: { $0.id == item.id }) { items[index].enabled = enabled }
        } catch {
            monitor.errorMessage = error.localizedDescription
        }
    }

    private func copy(_ value: String) {
        NSPasteboard.general.clearContents()
        NSPasteboard.general.setString(value, forType: .string)
    }
}

private struct StartupImpact {
    let label: String
    let color: Color
    let detail: String
}

private struct StartupItemPropertiesView: View {
    @Environment(\.dismiss) private var dismiss
    let item: StartupItem
    let impact: StartupImpact

    var body: some View {
        VStack(spacing: 0) {
            HStack(spacing: 14) {
                Image(systemName: item.kind == .loginItem ? "person.crop.circle.badge.checkmark" : "shippingbox")
                    .font(.system(size: 28)).foregroundStyle(.tint).frame(width: 42, height: 42)
                VStack(alignment: .leading, spacing: 3) {
                    Text(item.name).font(.title2.weight(.semibold))
                    Text(item.kind.title).foregroundStyle(.secondary)
                }
                Spacer()
            }
            .padding(20)
            Divider()
            Grid(alignment: .leading, horizontalSpacing: 24, verticalSpacing: 13) {
                property("Publisher", item.publisher)
                property("Status", item.enabled ? "Enabled" : "Disabled")
                property("Impact", impact.label)
                property("Impact detail", impact.detail)
                property("Executable", item.executablePath)
                property("Definition", item.sourcePath)
                property("Identifier", item.serviceIdentifier)
            }
            .padding(20)
            Divider()
            HStack {
                Button("Reveal in Finder") {
                    NSWorkspace.shared.activateFileViewerSelecting([URL(fileURLWithPath: item.sourcePath)])
                }
                Spacer()
                Button("Done") { dismiss() }.keyboardShortcut(.defaultAction)
            }
            .padding(16)
        }
        .frame(width: 600)
    }

    private func property(_ name: String, _ value: String) -> some View {
        GridRow {
            Text(name).foregroundStyle(.secondary).frame(width: 100, alignment: .trailing)
            Text(value).textSelection(.enabled).lineLimit(3).frame(maxWidth: .infinity, alignment: .leading)
        }
    }
}

struct UsersView: View {
    @Environment(SystemMonitor.self) private var monitor
    let onShowDetails: (ProcessRecord) -> Void
    @State private var terminationRequest: TerminationRequest?
    @State private var inspectedProcess: ProcessRecord?
    @State private var inspectedUser: UserSessionSummary?
    @State private var sessions: [LoginSession] = []

    private var groups: [UserSessionSummary] {
        let available = sessions.isEmpty ? [LoginSession(user: NSUserName(), terminal: "console", loginDescription: "Current session")] : sessions
        return available.map { session in
            UserSessionSummary(session: session, processes: monitor.processes.filter { $0.user == session.user })
        }.sorted { lhs, rhs in
            if lhs.session.isConsole != rhs.session.isConsole { return lhs.session.isConsole }
            return lhs.cpu > rhs.cpu
        }
    }

    var body: some View {
        VStack(spacing: 0) {
            PageHeader(title: "Users", subtitle: "\(groups.count) signed-in session\(groups.count == 1 ? "" : "s")")
            List(groups) { group in
                DisclosureGroup {
                    ForEach(group.processes.sorted { $0.cpu > $1.cpu }) { process in
                        HStack {
                            ProcessIcon(name: process.displayName, path: process.executablePath)
                            Text(process.displayName)
                            Spacer()
                            Text(Formatters.percent(process.cpu)).monospacedDigit()
                            Text(Formatters.bytes.string(fromByteCount: Int64(process.residentBytes))).monospacedDigit().frame(width: 110, alignment: .trailing)
                        }
                        .contextMenu {
                            ProcessContextMenu(
                                process: process,
                                onTerminate: { terminationRequest = $0 },
                                onShowDetails: onShowDetails,
                                onShowProperties: { inspectedProcess = $0 }
                            )
                        }
                    }
                } label: {
                    HStack {
                        Label(group.session.user, systemImage: group.session.isConsole ? "person.crop.circle.fill.badge.checkmark" : "person.crop.circle.fill")
                        if group.session.isConsole {
                            Text("Active").font(.caption.weight(.medium)).foregroundStyle(.green)
                        }
                        Spacer()
                        Text("\(group.processes.count) processes")
                        Text(Formatters.percent(group.cpu))
                            .monospacedDigit().frame(width: 70, alignment: .trailing)
                    }
                    .font(.headline)
                    .padding(.vertical, 7)
                    .contentShape(Rectangle())
                    .contextMenu { userMenu(group) }
                }
            }
            .listStyle(.inset)
        }
        .terminationConfirmation($terminationRequest)
        .sheet(item: $inspectedProcess) { ProcessPropertiesView(process: $0) }
        .sheet(item: $inspectedUser) { UserSessionPropertiesView(summary: $0) }
        .task {
            sessions = await Task.detached(priority: .utility) { LoginSessionScanner.capture() }.value
        }
    }

    @ViewBuilder
    private func userMenu(_ group: UserSessionSummary) -> some View {
        Button("Go to details", systemImage: "list.bullet.rectangle") {
            if let process = group.processes.max(by: { $0.cpu < $1.cpu }) { onShowDetails(process) }
        }
        .disabled(group.processes.isEmpty)

        if group.session.isConsole {
            Button("Lock session", systemImage: "lock") { SessionUserActions.lockScreen() }
        }

        Divider()
        Button("Open home folder", systemImage: "folder") { SessionUserActions.openHome(group.session.user) }
        Button("Manage account…", systemImage: "person.crop.circle.badge.gearshape") { SessionUserActions.openAccountsSettings() }
        Menu {
            Button("User name") { copy(group.session.user) }
            Button("Process IDs") { copy(group.processes.map { String($0.pid) }.joined(separator: ", ")) }
            Button("Resource summary") {
                copy("\(group.session.user)\t\(group.processes.count) processes\tCPU \(Formatters.percent(group.cpu))\tMemory \(Formatters.bytes.string(fromByteCount: Int64(group.memory)))")
            }
        } label: {
            Label("Copy", systemImage: "doc.on.doc")
        }
        Button("Properties", systemImage: "info.circle") { inspectedUser = group }
    }

    private func copy(_ value: String) {
        NSPasteboard.general.clearContents()
        NSPasteboard.general.setString(value, forType: .string)
    }
}

private struct LoginSession: Identifiable, Hashable, Sendable {
    let user: String
    let terminal: String
    let loginDescription: String
    var id: String { "\(user):\(terminal)" }
    var isConsole: Bool { terminal == "console" }
}

private struct UserSessionSummary: Identifiable, Hashable {
    let session: LoginSession
    let processes: [ProcessRecord]
    var id: String { session.id }
    var cpu: Double { processes.reduce(0) { $0 + $1.cpu } }
    var memory: UInt64 { processes.reduce(0) { $0 + $1.residentBytes } }
}

private enum LoginSessionScanner {
    static func capture() -> [LoginSession] {
        let task = Process()
        let pipe = Pipe()
        task.executableURL = URL(fileURLWithPath: "/usr/bin/who")
        task.standardOutput = pipe
        task.standardError = FileHandle.nullDevice
        do {
            try task.run()
            let data = pipe.fileHandleForReading.readDataToEndOfFile()
            task.waitUntilExit()
            var seen: Set<String> = []
            return String(decoding: data, as: UTF8.self).split(separator: "\n").compactMap { line in
                let fields = line.split(whereSeparator: { $0 == " " || $0 == "\t" }).map(String.init)
                guard fields.count >= 2 else { return nil }
                let key = "\(fields[0]):\(fields[1])"
                guard seen.insert(key).inserted else { return nil }
                return LoginSession(user: fields[0], terminal: fields[1], loginDescription: fields.dropFirst(2).joined(separator: " "))
            }
        } catch {
            return []
        }
    }
}

private enum SessionUserActions {
    static func lockScreen() {
        let task = Process()
        task.executableURL = URL(fileURLWithPath: "/usr/bin/pmset")
        task.arguments = ["displaysleepnow"]
        task.standardOutput = FileHandle.nullDevice
        task.standardError = FileHandle.nullDevice
        try? task.run()
    }

    static func openHome(_ user: String) {
        guard let account = getpwnam(user), let path = account.pointee.pw_dir else { return }
        NSWorkspace.shared.open(URL(fileURLWithPath: String(cString: path), isDirectory: true))
    }

    static func openAccountsSettings() {
        guard let url = URL(string: "x-apple.systempreferences:com.apple.Users-Groups-Settings.extension") else { return }
        NSWorkspace.shared.open(url)
    }
}

private struct UserSessionPropertiesView: View {
    @Environment(\.dismiss) private var dismiss
    let summary: UserSessionSummary

    var body: some View {
        VStack(spacing: 0) {
            HStack(spacing: 14) {
                Image(systemName: summary.session.isConsole ? "person.crop.circle.fill.badge.checkmark" : "person.crop.circle.fill")
                    .font(.system(size: 32)).foregroundStyle(.tint).frame(width: 44)
                VStack(alignment: .leading, spacing: 3) {
                    Text(summary.session.user).font(.title2.weight(.semibold))
                    Text(summary.session.isConsole ? "Active console session" : "Signed-in session").foregroundStyle(.secondary)
                }
                Spacer()
            }.padding(20)
            Divider()
            Grid(alignment: .leading, horizontalSpacing: 24, verticalSpacing: 13) {
                property("Terminal", summary.session.terminal)
                property("Signed in", summary.session.loginDescription)
                property("Processes", "\(summary.processes.count)")
                property("CPU", Formatters.percent(summary.cpu))
                property("Memory", Formatters.bytes.string(fromByteCount: Int64(summary.memory)))
                property("Session", summary.session.isConsole ? "Active" : "Connected")
            }.padding(20)
            Divider()
            HStack {
                Button("Open home folder") { SessionUserActions.openHome(summary.session.user) }
                Spacer()
                Button("Done") { dismiss() }.keyboardShortcut(.defaultAction)
            }.padding(16)
        }
        .frame(width: 520)
    }

    private func property(_ name: String, _ value: String) -> some View {
        GridRow {
            Text(name).foregroundStyle(.secondary).frame(width: 90, alignment: .trailing)
            Text(value).textSelection(.enabled).frame(maxWidth: .infinity, alignment: .leading)
        }
    }
}

private enum StartupItemKind: Sendable {
    case loginItem
    case launchAgent

    var title: String { self == .loginItem ? "Login item" : "Launch agent" }
}

private struct StartupItem: Identifiable, Sendable {
    let id: String
    let name: String
    let publisher: String
    let sourcePath: String
    let executablePath: String
    let serviceIdentifier: String
    let kind: StartupItemKind
    let isDirectlyManageable: Bool
    var enabled: Bool
}

private enum StartupScanner {
    static func scan() -> [StartupItem] {
        let home = FileManager.default.homeDirectoryForCurrentUser.path
        let directories = ["\(home)/Library/LaunchAgents", "/Library/LaunchAgents"]
        let disabled = disabledServices()
        let agents = directories.flatMap { scanDirectory($0, disabled: disabled) }
        let loginItems = sessionLoginItems()
        return (loginItems + agents).sorted {
            if $0.kind != $1.kind { return $0.kind == .loginItem }
            return $0.name.localizedCaseInsensitiveCompare($1.name) == .orderedAscending
        }
    }

    private static func scanDirectory(_ directory: String, disabled: Set<String>) -> [StartupItem] {
        guard let files = try? FileManager.default.contentsOfDirectory(atPath: directory) else { return [] }
        return files.filter { $0.hasSuffix(".plist") }.compactMap { filename in
            let path = (directory as NSString).appendingPathComponent(filename)
            guard let data = FileManager.default.contents(atPath: path),
                  let plist = try? PropertyListSerialization.propertyList(from: data, format: nil) as? [String: Any] else { return nil }
            let label = plist["Label"] as? String ?? (filename as NSString).deletingPathExtension
            let command = plist["Program"] as? String ?? ((plist["ProgramArguments"] as? [String])?.first ?? "")
            let publisher = publisherName(label: label, command: command)
            return StartupItem(
                id: "agent:\(label)",
                name: friendlyName(label),
                publisher: publisher,
                sourcePath: path,
                executablePath: command,
                serviceIdentifier: label,
                kind: .launchAgent,
                isDirectlyManageable: true,
                enabled: !disabled.contains(label) && !(plist["Disabled"] as? Bool ?? false)
            )
        }
    }

    private static func sessionLoginItems() -> [StartupItem] {
        guard let unmanagedList = LSSharedFileListCreate(
            nil,
            "com.apple.LSSharedFileList.SessionLoginItems" as CFString,
            nil
        ) else { return [] }
        let list = unmanagedList.takeRetainedValue()
        guard let unmanagedSnapshot = LSSharedFileListCopySnapshot(list, nil) else { return [] }
        let snapshot = unmanagedSnapshot.takeRetainedValue()
        var seen: Set<String> = []
        var items: [StartupItem] = []
        let flags = UInt32(kLSSharedFileListNoUserInteraction | kLSSharedFileListDoNotMountVolumes)
        for index in 0..<CFArrayGetCount(snapshot) {
            let raw = CFArrayGetValueAtIndex(snapshot, index)
            let item = unsafeBitCast(raw, to: LSSharedFileListItem.self)
            guard let unmanagedURL = LSSharedFileListItemCopyResolvedURL(item, flags, nil) else { continue }
            let url = unmanagedURL.takeRetainedValue() as URL
            let path = url.standardizedFileURL.path
            guard seen.insert(path).inserted else { continue }
            let bundle = Bundle(url: url)
            let identifier = bundle?.bundleIdentifier ?? path
            let name = (bundle?.object(forInfoDictionaryKey: "CFBundleDisplayName") as? String)
                ?? (bundle?.object(forInfoDictionaryKey: "CFBundleName") as? String)
                ?? url.deletingPathExtension().lastPathComponent
            items.append(StartupItem(
                id: "login:\(path)",
                name: name,
                publisher: publisherName(label: identifier, command: path),
                sourcePath: path,
                executablePath: path,
                serviceIdentifier: identifier,
                kind: .loginItem,
                isDirectlyManageable: false,
                enabled: true
            ))
        }
        return items
    }

    private static func disabledServices() -> Set<String> {
        let process = Process()
        let pipe = Pipe()
        process.executableURL = URL(fileURLWithPath: "/bin/launchctl")
        process.arguments = ["print-disabled", "gui/\(getuid())"]
        process.standardOutput = pipe
        process.standardError = FileHandle.nullDevice
        do {
            try process.run()
            let output = String(decoding: pipe.fileHandleForReading.readDataToEndOfFile(), as: UTF8.self)
            process.waitUntilExit()
            let pattern = #"\"([^\"]+)\"\s*=>\s*true"#
            guard let regex = try? NSRegularExpression(pattern: pattern) else { return [] }
            return Set(regex.matches(in: output, range: NSRange(output.startIndex..., in: output)).compactMap { match in
                guard let range = Range(match.range(at: 1), in: output) else { return nil }
                return String(output[range])
            })
        } catch {
            return []
        }
    }

    private static func friendlyName(_ label: String) -> String {
        let parts = label.split(separator: ".").map(String.init)
        guard let last = parts.last else { return label }
        let generic = ["agent", "updater", "check", "wake", "xpcservice", "helper"]
        if generic.contains(last.lowercased()), parts.count > 1 {
            return "\(parts[parts.count - 2]) \(last)"
        }
        return last
    }

    private static func publisherName(label: String, command: String) -> String {
        if label.hasPrefix("com.apple") { return "Apple" }
        let parts = label.split(separator: ".").map(String.init)
        if let vendor = parts.drop(while: { ["com", "org", "net", "io", "us"].contains($0.lowercased()) }).first {
            return vendor.prefix(1).uppercased() + vendor.dropFirst()
        }
        if let appComponent = command.split(separator: "/").first(where: { $0.hasSuffix(".app") }) {
            return String(appComponent.dropLast(4))
        }
        return "Unknown"
    }
}

private enum DetailColumn: String, CaseIterable, Identifiable {
    case name, pid, parentPID, user, cpu, cpuTime, memory, disk, network, state, elapsed
    case threads, handles, architecture, priority, nice

    var id: String { rawValue }
    var title: String {
        switch self {
        case .name: "Name"
        case .pid: "PID"
        case .parentPID: "Parent PID"
        case .user: "User"
        case .cpu: "CPU"
        case .cpuTime: "CPU time"
        case .memory: "Memory"
        case .disk: "Disk I/O"
        case .network: "Network"
        case .state: "State"
        case .elapsed: "Elapsed"
        case .threads: "Threads"
        case .handles: "Handles"
        case .architecture: "Architecture"
        case .priority: "Priority"
        case .nice: "Nice"
        }
    }
    var defaultWidth: CGFloat {
        switch self {
        case .name: 260
        case .user: 140
        case .architecture, .state: 105
        case .cpuTime, .memory, .disk, .network, .elapsed: 112
        case .parentPID: 92
        default: 78
        }
    }
    var minimumWidth: CGFloat {
        switch self {
        case .name: 170
        case .user: 90
        case .cpuTime, .memory, .disk, .network, .elapsed: 82
        default: 62
        }
    }
    var maximumWidth: CGFloat { self == .name ? 620 : 300 }
    var textAlignment: Alignment {
        switch self {
        case .name, .user, .state, .architecture: .leading
        default: .trailing
        }
    }
    var defaultVisible: Bool {
        [.name, .pid, .user, .cpu, .memory, .threads, .handles, .architecture, .priority, .cpuTime].contains(self)
    }
}

struct DetailsView: View {
    @Environment(SystemMonitor.self) private var monitor
    let searchText: String
    @Binding var selection: Int32?
    @AppStorage("detailVisibleColumnsV2") private var visibleColumnStorage = DetailColumn.allCases.filter(\.defaultVisible).map(\.rawValue).joined(separator: ",")
    @AppStorage("detailColumnWidthsV2") private var columnWidthsStorage = ""
    @State private var terminationRequest: TerminationRequest?
    @State private var inspectedProcess: ProcessRecord?
    @State private var columnWidths = Dictionary(uniqueKeysWithValues: DetailColumn.allCases.map { ($0, $0.defaultWidth) })
    @AppStorage("detailSortColumn") private var sortColumn: DetailColumn = .pid
    @AppStorage("detailSortAscending") private var ascending = true

    private var visibleColumns: [DetailColumn] {
        let stored = Set(visibleColumnStorage.split(separator: ",").map(String.init))
        return DetailColumn.allCases.filter { stored.contains($0.rawValue) || $0 == .name || $0 == .pid }
    }

    var body: some View {
        VStack(spacing: 0) {
            PageHeader(title: "Details", subtitle: "Technical information for running processes") {
                Button("Properties", systemImage: "info.circle") {
                    inspectedProcess = selectedProcess
                }
                .disabled(selectedProcess == nil)
                Menu("Columns", systemImage: "rectangle.split.3x1") {
                    ForEach(DetailColumn.allCases) { column in
                        Toggle(column.title, isOn: columnBinding(column))
                            .disabled(column == .name || column == .pid)
                    }
                    Divider()
                    Button("Reset columns") {
                        visibleColumnStorage = DetailColumn.allCases.filter(\.defaultVisible).map(\.rawValue).joined(separator: ",")
                        columnWidths = Dictionary(uniqueKeysWithValues: DetailColumn.allCases.map { ($0, $0.defaultWidth) })
                        persistColumnWidths()
                    }
                }
            }
            ResourceSummaryBar(snapshot: monitor.snapshot)
            GeometryReader { proxy in
                ScrollView([.horizontal, .vertical]) {
                    LazyVStack(spacing: 0, pinnedViews: [.sectionHeaders]) {
                        Section {
                            ForEach(Array(filtered.enumerated()), id: \.element.id) { index, process in
                                detailRow(process, index: index)
                            }
                        } header: {
                            detailHeader
                        }
                    }
                    .frame(width: max(tableWidth, proxy.size.width), alignment: .leading)
                }
            }
            .frame(maxWidth: .infinity, maxHeight: .infinity)
            selectionBar
        }
        .onAppear(perform: restoreColumnWidths)
        .terminationConfirmation($terminationRequest)
        .sheet(item: $inspectedProcess) { ProcessPropertiesView(process: $0) }
    }

    private var filtered: [ProcessRecord] {
        monitor.processes.filter {
            searchText.isEmpty || $0.displayName.localizedCaseInsensitiveContains(searchText)
                || $0.user.localizedCaseInsensitiveContains(searchText) || String($0.pid).contains(searchText)
        }.sorted { lhs, rhs in
            let result = comparison(lhs, rhs, column: sortColumn)
            if result == .orderedSame { return lhs.pid < rhs.pid }
            return ascending ? result == .orderedAscending : result == .orderedDescending
        }
    }

    private var detailHeader: some View {
        HStack(spacing: 0) {
            ForEach(visibleColumns) { column in
                detailHeaderCell(column)
            }
        }
        .frame(maxWidth: .infinity, alignment: .leading)
        .font(.caption.weight(.medium))
        .foregroundStyle(.secondary)
        .background(.regularMaterial)
        .overlay(alignment: .bottom) { Divider() }
    }

    private func detailRow(_ process: ProcessRecord, index: Int) -> some View {
        HStack(spacing: 0) {
            ForEach(visibleColumns) { column in
                detailCell(process, column: column)
                    .padding(.horizontal, 10)
                    .frame(width: width(column), alignment: column.textAlignment)
                    .clipped()
                    .overlay(alignment: .trailing) { Divider().opacity(0.18) }
            }
        }
        .frame(maxWidth: .infinity, alignment: .leading)
        .font(.callout)
        .frame(minHeight: 42)
        .background(rowBackground(process: process, index: index))
        .contentShape(Rectangle())
        .onTapGesture { selection = process.pid }
        .focusable()
        .onKeyPress(.return) {
            selection = process.pid
            return .handled
        }
        .accessibilityElement(children: .combine)
        .accessibilityLabel("\(process.displayName), PID \(process.pid), \(process.user), \(readableState(process.state))")
        .accessibilityValue("CPU \(Formatters.percent(process.cpu)), memory \(Formatters.bytes.string(fromByteCount: Int64(process.residentBytes))), \(process.threadCount) threads")
        .accessibilityAddTraits(selection == process.pid ? .isSelected : [])
        .accessibilityAction { selection = process.pid }
        .overlay(alignment: .bottom) { Divider().opacity(0.4) }
        .contextMenu {
            ProcessContextMenu(
                process: process,
                onTerminate: { terminationRequest = $0 },
                onShowDetails: { _ in },
                onShowProperties: { inspectedProcess = $0 }
            )
        }
    }

    @ViewBuilder
    private func detailCell(_ process: ProcessRecord, column: DetailColumn) -> some View {
        switch column {
        case .name:
            HStack(spacing: 8) {
                ProcessIcon(name: process.displayName, path: process.executablePath)
                Text(process.displayName).lineLimit(1).truncationMode(.tail)
            }
        case .pid: Text("\(process.pid)").monospacedDigit()
        case .parentPID: Text("\(process.parentPID)").monospacedDigit()
        case .user: Text(process.user).lineLimit(1)
        case .cpu: Text(Formatters.percent(process.cpu)).monospacedDigit()
        case .cpuTime: Text(Formatters.duration(process.cpuTime)).monospacedDigit()
        case .memory: Text(Formatters.bytes.string(fromByteCount: Int64(process.residentBytes))).monospacedDigit()
        case .disk: Text(Formatters.rate(monitor.processActivity[process.pid]?.diskTotal ?? 0)).monospacedDigit()
        case .network: Text(Formatters.rate(monitor.processActivity[process.pid]?.networkTotal ?? 0)).monospacedDigit()
        case .state:
            Text(readableState(process.state))
                .font(.caption.weight(.medium))
                .foregroundStyle(process.state.hasPrefix("R") ? Color.green : Color.secondary)
        case .elapsed: Text(process.elapsed).monospacedDigit()
        case .threads: Text("\(process.threadCount)").monospacedDigit()
        case .handles: Text("\(process.openFileCount)").monospacedDigit()
        case .architecture: Text(process.architecture)
        case .priority: Text("\(process.priority)").monospacedDigit()
        case .nice: Text("\(process.nice)").monospacedDigit()
        }
    }

    private func detailHeaderCell(_ column: DetailColumn) -> some View {
        HStack(spacing: 0) {
            Button {
                if sortColumn == column { ascending.toggle() }
                else { sortColumn = column; ascending = true }
            } label: {
                HStack(spacing: 5) {
                    Text(column.title).lineLimit(1)
                    Spacer(minLength: 4)
                    if sortColumn == column {
                        Image(systemName: ascending ? "chevron.up" : "chevron.down")
                            .font(.caption2.weight(.semibold))
                    }
                }
                .padding(.horizontal, 10)
                .frame(width: width(column), height: 36, alignment: .leading)
                .contentShape(Rectangle())
            }
            .buttonStyle(.plain)
            .accessibilityLabel("Sort by \(column.title)")
            .accessibilityValue(sortColumn == column ? (ascending ? "Ascending" : "Descending") : "Not sorted")
        }
        .frame(width: width(column), height: 36)
        .overlay(alignment: .trailing) {
            Divider().opacity(0.45)
            DetailResizeHandle(
                width: Binding(get: { width(column) }, set: { columnWidths[column] = $0 }),
                minimumWidth: column.minimumWidth,
                maximumWidth: column.maximumWidth,
                onEnded: persistColumnWidths
            )
            .offset(x: 5)
        }
    }

    private var selectionBar: some View {
        VStack(spacing: 0) {
            Divider()
            HStack(spacing: 10) {
                if let process = selectedProcess {
                    ProcessIcon(name: process.displayName, path: process.executablePath)
                    Text(process.displayName).font(.callout.weight(.semibold)).lineLimit(1)
                    Text("PID \(process.pid)").foregroundStyle(.secondary).monospacedDigit()
                    Text("•").foregroundStyle(.tertiary)
                    Text(Formatters.percent(process.cpu) + " CPU").monospacedDigit()
                    Text("•").foregroundStyle(.tertiary)
                    Text(Formatters.bytes.string(fromByteCount: Int64(process.residentBytes))).monospacedDigit()
                    Spacer()
                    Button("End task") { terminationRequest = .init(process: process, kind: .normal) }
                    Button("Properties") { inspectedProcess = process }.buttonStyle(.borderedProminent)
                } else {
                    Text("\(filtered.count) processes").foregroundStyle(.secondary)
                    Spacer()
                    Text("Select a process for actions and live details").foregroundStyle(.tertiary)
                }
            }
            .font(.caption)
            .padding(.horizontal, 14)
            .frame(minHeight: 48)
        }
        .background(.bar)
    }

    private var selectedProcess: ProcessRecord? {
        guard let selection else { return nil }
        return monitor.processes.first { $0.pid == selection }
    }

    private var tableWidth: CGFloat { visibleColumns.reduce(0) { $0 + width($1) } }
    private func width(_ column: DetailColumn) -> CGFloat { columnWidths[column] ?? column.defaultWidth }

    private func rowBackground(process: ProcessRecord, index: Int) -> Color {
        if selection == process.pid { return Color.accentColor.opacity(0.18) }
        return index.isMultiple(of: 2) ? Color.clear : Color.secondary.opacity(0.035)
    }

    private func readableState(_ state: String) -> String {
        if state.hasPrefix("R") { return "Running" }
        if state.hasPrefix("S") { return "Sleeping" }
        if state.hasPrefix("Z") { return "Zombie" }
        if state.hasPrefix("T") { return "Stopped" }
        return state
    }

    private func restoreColumnWidths() {
        guard let data = columnWidthsStorage.data(using: .utf8),
              let stored = try? JSONDecoder().decode([String: Double].self, from: data) else { return }
        for column in DetailColumn.allCases {
            if let value = stored[column.rawValue] {
                columnWidths[column] = min(column.maximumWidth, max(column.minimumWidth, value))
            }
        }
    }

    private func persistColumnWidths() {
        let stored = Dictionary(uniqueKeysWithValues: DetailColumn.allCases.map { ($0.rawValue, Double(width($0))) })
        guard let data = try? JSONEncoder().encode(stored), let value = String(data: data, encoding: .utf8) else { return }
        columnWidthsStorage = value
    }

    private func columnBinding(_ column: DetailColumn) -> Binding<Bool> {
        Binding(
            get: { visibleColumns.contains(column) },
            set: { enabled in
                var columns = Set(visibleColumnStorage.split(separator: ",").map(String.init))
                if enabled { columns.insert(column.rawValue) }
                else { columns.remove(column.rawValue) }
                visibleColumnStorage = DetailColumn.allCases.filter { columns.contains($0.rawValue) }.map(\.rawValue).joined(separator: ",")
            }
        )
    }

    private func comparison(_ lhs: ProcessRecord, _ rhs: ProcessRecord, column: DetailColumn) -> ComparisonResult {
        func compare<T: Comparable>(_ left: T, _ right: T) -> ComparisonResult {
            left == right ? .orderedSame : (left < right ? .orderedAscending : .orderedDescending)
        }
        return switch column {
        case .name: lhs.displayName.localizedCaseInsensitiveCompare(rhs.displayName)
        case .pid: compare(lhs.pid, rhs.pid)
        case .parentPID: compare(lhs.parentPID, rhs.parentPID)
        case .user: lhs.user.localizedCaseInsensitiveCompare(rhs.user)
        case .cpu: compare(lhs.cpu, rhs.cpu)
        case .cpuTime: compare(lhs.cpuTime, rhs.cpuTime)
        case .memory: compare(lhs.residentBytes, rhs.residentBytes)
        case .disk: compare(monitor.processActivity[lhs.pid]?.diskTotal ?? 0, monitor.processActivity[rhs.pid]?.diskTotal ?? 0)
        case .network: compare(monitor.processActivity[lhs.pid]?.networkTotal ?? 0, monitor.processActivity[rhs.pid]?.networkTotal ?? 0)
        case .state: lhs.state.localizedCaseInsensitiveCompare(rhs.state)
        case .elapsed: compare(lhs.elapsed, rhs.elapsed)
        case .threads: compare(lhs.threadCount, rhs.threadCount)
        case .handles: compare(lhs.openFileCount, rhs.openFileCount)
        case .architecture: lhs.architecture.localizedCaseInsensitiveCompare(rhs.architecture)
        case .priority: compare(lhs.priority, rhs.priority)
        case .nice: compare(lhs.nice, rhs.nice)
        }
    }
}

private struct DetailResizeHandle: View {
    @Binding var width: CGFloat
    let minimumWidth: CGFloat
    let maximumWidth: CGFloat
    let onEnded: () -> Void
    @State private var startWidth: CGFloat?
    @State private var proposedWidth: CGFloat?
    @State private var hovered = false

    var body: some View {
        Rectangle()
            .fill(hovered || startWidth != nil ? Color.accentColor : Color.clear)
            .frame(width: 2, height: 24)
            .frame(width: 10, height: 36)
            .offset(x: (proposedWidth ?? width) - width)
            .contentShape(Rectangle())
            .onHover { value in
                hovered = value
                (value ? NSCursor.resizeLeftRight : NSCursor.arrow).set()
            }
            .highPriorityGesture(
                DragGesture(minimumDistance: 0)
                    .onChanged { value in
                        if startWidth == nil { startWidth = width }
                        proposedWidth = min(maximumWidth, max(minimumWidth, (startWidth ?? width) + value.translation.width))
                    }
                    .onEnded { _ in
                        if let proposedWidth { width = proposedWidth }
                        proposedWidth = nil
                        startWidth = nil
                        onEnded()
                    }
            )
            .help("Drag to resize column")
    }
}

struct ServicesView: View {
    @Environment(SystemMonitor.self) private var monitor
    let searchText: String
    let onShowDetails: (ProcessRecord) -> Void
    @State private var selection: String?
    @State private var inspectedService: ServiceRecord?
    @State private var domainFilter: ServiceDomain?

    private var services: [ServiceRecord] {
        monitor.services.filter {
            (domainFilter == nil || $0.domain == domainFilter) && (
                searchText.isEmpty
                    || $0.displayName.localizedCaseInsensitiveContains(searchText)
                    || $0.label.localizedCaseInsensitiveContains(searchText)
                    || $0.domain.rawValue.localizedCaseInsensitiveContains(searchText)
                    || String($0.pid ?? 0).contains(searchText)
            )
        }.sorted {
            if $0.isRunning != $1.isRunning { return $0.isRunning }
            return $0.displayName.localizedCaseInsensitiveCompare($1.displayName) == .orderedAscending
        }
    }

    var body: some View {
        VStack(spacing: 0) {
            PageHeader(
                title: "Services",
                subtitle: "\(monitor.services.filter(\.isRunning).count) running of \(monitor.services.count) launch services"
            ) {
                Picker("Scope", selection: $domainFilter) {
                    Text("All").tag(ServiceDomain?.none)
                    ForEach(ServiceDomain.allCases) { domain in
                        Text(domain.rawValue).tag(Optional(domain))
                    }
                }
                .pickerStyle(.segmented)
                .frame(width: 220)
            }
            Table(services, selection: $selection) {
                TableColumn("Name") { service in
                    HStack(spacing: 8) {
                        if let pid = service.pid, let process = monitor.processes.first(where: { $0.pid == pid }) {
                            ProcessIcon(name: service.displayName, path: process.executablePath)
                        } else {
                            Image(systemName: service.isRunning ? "gearshape.fill" : "gearshape")
                                .frame(width: 30, height: 30)
                        }
                        Text(service.displayName).lineLimit(1)
                    }
                    .foregroundStyle(service.isRunning ? Color.primary : Color.secondary)
                }.width(min: 150, ideal: 210)
                TableColumn("PID") { service in
                    Text(service.pid.map(String.init) ?? "—").monospacedDigit()
                }.width(70)
                TableColumn("Description") { service in
                    Text(service.label).lineLimit(1).foregroundStyle(.secondary)
                }.width(min: 220, ideal: 360)
                TableColumn("Status") { service in
                    HStack(spacing: 6) {
                        Circle().fill(service.isRunning ? Color.green : Color.secondary.opacity(0.5)).frame(width: 7, height: 7)
                        Text(service.isRunning ? "Running" : "Stopped")
                    }
                }.width(100)
                TableColumn("Scope") { Text($0.domain.rawValue) }.width(70)
                TableColumn("Group") { Text($0.publisher) }.width(min: 80, ideal: 110)
            }
            .contextMenu(forSelectionType: String.self) { selectedLabels in
                if let id = selectedLabels.first,
                   let service = monitor.services.first(where: { $0.id == id }) {
                    serviceMenu(service)
                }
            }
        }
        .sheet(item: $inspectedService) { ServicePropertiesView(service: $0) }
    }

    @ViewBuilder
    private func serviceMenu(_ service: ServiceRecord) -> some View {
        Button("Start", systemImage: "play.fill") { monitor.startService(service) }
            .disabled(service.isRunning || !service.isControllable)
        Button("Stop", systemImage: "stop.fill") { monitor.stopService(service) }
            .disabled(!service.isRunning || !service.isControllable)
        Button("Restart", systemImage: "arrow.clockwise") { monitor.restartService(service) }
            .disabled(!service.isRunning || !service.isControllable)
        if !service.isControllable {
            Text("Protected system service")
        }

        Divider()

        Button("Go to details", systemImage: "list.bullet.rectangle") {
            guard let pid = service.pid,
                  let process = monitor.processes.first(where: { $0.pid == pid }) else { return }
            onShowDetails(process)
        }
        .disabled(service.pid == nil)

        Menu("Copy", systemImage: "doc.on.doc") {
            Button("Name") { copy(service.displayName) }
            Button("Service identifier") { copy(service.label) }
            Button("PID") { copy(service.pid.map(String.init) ?? "") }
            Button("All details") {
                copy("\(service.displayName)\t\(service.label)\t\(service.isRunning ? "Running" : "Stopped")\tPID \(service.pid.map(String.init) ?? "—")")
            }
        }

        Menu("Inspect", systemImage: "magnifyingglass") {
            Button("Reveal configuration") { revealConfiguration(service) }
                .disabled(service.configurationPath == nil)
            Button("Search online") { searchOnline(service) }
            Button("Properties") { inspectedService = service }
        }
    }

    private func copy(_ value: String) {
        NSPasteboard.general.clearContents()
        NSPasteboard.general.setString(value, forType: .string)
    }

    private func searchOnline(_ service: ServiceRecord) {
        guard let query = service.label.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed),
              let url = URL(string: "https://www.google.com/search?q=\(query)+macOS+launchd") else { return }
        NSWorkspace.shared.open(url)
    }

    private func revealConfiguration(_ service: ServiceRecord) {
        guard let path = service.configurationPath else { return }
        NSWorkspace.shared.activateFileViewerSelecting([URL(fileURLWithPath: path)])
    }
}

private struct ServicePropertiesView: View {
    @Environment(\.dismiss) private var dismiss
    let service: ServiceRecord

    var body: some View {
        VStack(spacing: 0) {
            HStack(spacing: 14) {
                Image(systemName: service.isRunning ? "gearshape.fill" : "gearshape")
                    .font(.system(size: 28))
                    .foregroundStyle(service.isRunning ? .green : .secondary)
                    .frame(width: 42, height: 42)
                VStack(alignment: .leading, spacing: 3) {
                    Text(service.displayName).font(.title2.weight(.semibold))
                    Text(service.isRunning ? "Running" : "Stopped").foregroundStyle(.secondary)
                }
                Spacer()
            }
            .padding(20)
            Divider()
            Grid(alignment: .leading, horizontalSpacing: 24, verticalSpacing: 13) {
                property("Identifier", service.label)
                property("PID", service.pid.map(String.init) ?? "Not running")
                property("Publisher", service.publisher)
                property("Last exit", "\(service.lastExitStatus)")
                property("Domain", service.domain.launchctlPrefix)
                property("Management", service.isControllable ? "Available" : "Read-only (protected by macOS)")
                property("Configuration", service.configurationPath ?? "Managed dynamically by launchd")
            }
            .padding(20)
            Divider()
            HStack {
                Spacer()
                Button("Done") { dismiss() }.keyboardShortcut(.defaultAction)
            }
            .padding(16)
        }
        .frame(width: 560)
    }

    private func property(_ name: String, _ value: String) -> some View {
        GridRow {
            Text(name).foregroundStyle(.secondary).frame(width: 90, alignment: .trailing)
            Text(value).textSelection(.enabled).lineLimit(2).frame(maxWidth: .infinity, alignment: .leading)
        }
    }
}