ProcessBeacon.swift

import SwiftUI
import AppKit
import UserNotifications

// MARK: - Models

struct ProcessInfo: Identifiable, Equatable {
    let id: Int32 // PID
    let name: String
    let fullCommand: String
    let parentPid: Int32
    let cpuPercent: Double
    let elapsedSeconds: Int
    let isWatched: Bool

    var elapsedFormatted: String { formatElapsed(elapsedSeconds) }

    var shortName: String {
        // Extract meaningful name from command path
        let base = (fullCommand as NSString).lastPathComponent
        // Trim common suffixes
        if base.hasSuffix(" (Renderer)") { return String(base.dropLast(11)) }
        return base
    }

    var category: ProcessCategory {
        let cmd = fullCommand.lowercased()
        if cmd.contains("cargo") || cmd.contains("rustc") || cmd.contains("swift") ||
           cmd.contains("clang") || cmd.contains("gcc") || cmd.contains("make") ||
           cmd.contains("xcodebuild") || cmd.contains("ninja") {
            return .build
        }
        if cmd.contains("npm") || cmd.contains("bun") || cmd.contains("node") ||
           cmd.contains("yarn") || cmd.contains("pnpm") || cmd.contains("deno") ||
           cmd.contains("vite") || cmd.contains("webpack") || cmd.contains("next") {
            return .node
        }
        if cmd.contains("python") || cmd.contains("pip") || cmd.contains("pytest") ||
           cmd.contains("ruby") || cmd.contains("gem") || cmd.contains("java") ||
           cmd.contains("go ") || cmd.contains("dotnet") {
            return .runtime
        }
        if cmd.contains("docker") || cmd.contains("kubectl") || cmd.contains("terraform") ||
           cmd.contains("ansible") || cmd.contains("vagrant") {
            return .infra
        }
        if cmd.contains("git") || cmd.contains("gh ") || cmd.contains("claude") ||
           cmd.contains("codex") {
            return .devtool
        }
        if cmd.contains("test") || cmd.contains("spec") || cmd.contains("jest") ||
           cmd.contains("vitest") || cmd.contains("xctest") {
            return .test
        }
        return .other
    }
}

enum ProcessCategory: String, CaseIterable {
    case build = "Build"
    case test = "Test"
    case node = "JS/TS"
    case runtime = "Runtime"
    case infra = "Infra"
    case devtool = "Dev Tool"
    case other = "Other"

    var icon: String {
        switch self {
        case .build: return "hammer.fill"
        case .test: return "checkmark.circle.fill"
        case .node: return "cube.fill"
        case .runtime: return "gearshape.fill"
        case .infra: return "cloud.fill"
        case .devtool: return "wrench.fill"
        case .other: return "circle.fill"
        }
    }

    var color: Color {
        switch self {
        case .build: return .orange
        case .test: return .green
        case .node: return .yellow
        case .runtime: return .blue
        case .infra: return .purple
        case .devtool: return .cyan
        case .other: return .gray
        }
    }
}

// MARK: - Process Scanner

@Observable
class ProcessScanner {
    var processes: [ProcessInfo] = []
    var watchedPids: Set<Int32> = []
    var completedProcesses: [(name: String, pid: Int32, date: Date)] = []
    var lastScan: Date = Date()
    var filterText: String = ""
    private var timer: Timer?

    init() {
        requestNotificationPermission()
        scan()
        timer = Timer.scheduledTimer(withTimeInterval: 5.0, repeats: true) { [weak self] _ in
            self?.scan()
        }
    }

    deinit {
        timer?.invalidate()
    }

    func scan() {
        let pipe = Pipe()
        let process = Process()
        process.executableURL = URL(fileURLWithPath: "/bin/ps")
        process.arguments = ["-eo", "pid,ppid,etime,pcpu,command"]
        process.standardOutput = pipe
        process.standardError = FileHandle.nullDevice

        try? process.run()
        let data = pipe.fileHandleForReading.readDataToEndOfFile()
        process.waitUntilExit()

        guard let output = String(data: data, encoding: .utf8) else { return }

        let lines = output.components(separatedBy: "\n").dropFirst() // skip header

        var scanned: [ProcessInfo] = []

        for line in lines {
            let trimmed = line.trimmingCharacters(in: .whitespaces)
            guard !trimmed.isEmpty else { continue }

            guard let parsed = parsePsLine(trimmed) else { continue }

            // Filter out system processes
            if shouldFilter(parsed.command) { continue }

            let info = ProcessInfo(
                id: parsed.pid,
                name: (parsed.command as NSString).lastPathComponent,
                fullCommand: parsed.command,
                parentPid: parsed.ppid,
                cpuPercent: parsed.cpu,
                elapsedSeconds: parsed.elapsed,
                isWatched: watchedPids.contains(parsed.pid)
            )
            scanned.append(info)
        }

        // Check for completed watched processes
        let scannedPids = Set(scanned.map { $0.id })
        let missingPids = watchedPids.subtracting(scannedPids)
        for pid in missingPids {
            // Find the name from previous scan
            let name = processes.first { $0.id == pid }?.shortName ?? "PID \(pid)"
            watchedPids.remove(pid)
            completedProcesses.insert((name: name, pid: pid, date: Date()), at: 0)
            if completedProcesses.count > 20 {
                completedProcesses = Array(completedProcesses.prefix(20))
            }
            sendNotification(name: name, pid: pid)
        }

        // Sort: watched first, then by elapsed time descending
        scanned.sort { a, b in
            if a.isWatched != b.isWatched { return a.isWatched }
            return a.elapsedSeconds > b.elapsedSeconds
        }

        processes = scanned
        lastScan = Date()
    }

    func toggleWatch(_ pid: Int32) {
        if watchedPids.contains(pid) {
            watchedPids.remove(pid)
        } else {
            watchedPids.insert(pid)
        }
        // Update isWatched in the process list
        processes = processes.map {
            ProcessInfo(
                id: $0.id, name: $0.name, fullCommand: $0.fullCommand,
                parentPid: $0.parentPid, cpuPercent: $0.cpuPercent,
                elapsedSeconds: $0.elapsedSeconds, isWatched: watchedPids.contains($0.id)
            )
        }
    }

    var filteredProcesses: [ProcessInfo] {
        guard !filterText.isEmpty else { return processes }
        let query = filterText.lowercased()
        return processes.filter {
            $0.shortName.lowercased().contains(query) ||
            $0.fullCommand.lowercased().contains(query) ||
            String($0.id).contains(query) ||
            $0.category.rawValue.lowercased().contains(query)
        }
    }

    var watchedCount: Int { watchedPids.count }

    var menuBarText: String {
        if watchedPids.isEmpty { return "" }
        return "\(watchedPids.count)"
    }

    // MARK: - Parsing

    private struct PsEntry {
        let pid: Int32
        let ppid: Int32
        let elapsed: Int
        let cpu: Double
        let command: String
    }

    private func parsePsLine(_ line: String) -> PsEntry? {
        // Format: "  PID  PPID     ELAPSED  %CPU COMMAND"
        // Elapsed can be: "00:01", "01:23:45", "1-02:03:04"
        let parts = line.split(separator: " ", maxSplits: 4, omittingEmptySubsequences: true)
        guard parts.count >= 5 else { return nil }

        guard let pid = Int32(parts[0]),
              let ppid = Int32(parts[1]) else { return nil }

        let elapsed = parseElapsed(String(parts[2]))
        let cpu = Double(parts[3]) ?? 0.0
        let command = String(parts[4])

        return PsEntry(pid: pid, ppid: ppid, elapsed: elapsed, cpu: cpu, command: command)
    }

    private func shouldFilter(_ command: String) -> Bool {
        let filters = [
            "/System/", "/usr/libexec/", "/usr/sbin/", "/sbin/",
            "/Library/Apple", "com.apple.", "kernel_task", "WindowServer",
            "/Library/PrivilegedHelper", "mdworker", "mds_stores",
            "launchd", "logd", "configd", "powerd", "remoted",
            "watchdogd", "thermalmonitord", "fseventsd", "diskarbitrationd",
            "UserEventAgent", "corespeechd", "contextstored", "xprotectd",
            "kernelmanagerd", "systemstats", "syslogd", "automountd",
            "autofsd", "mediaremoted", "IOMFB", "opendirectoryd",
            "notifyd", "securityd", "trustd", "cloudd", "nsurlsessiond",
            "lsd", "iconservicesagent", "containermanagerd",
            "sandboxd", "symptomsd", "WiFiAgent", "airportd",
            "bluetoothd", "coreaudiod", "hidd", "locationd",
            "coreduetd", "biomed", "duetexpertd", "mediaanalysisd",
            "filecoordinationd", "fileproviderd", "pkd",
            "/Library/Developer/PrivateFrameworks/CoreSimulator",
            "Google Chrome Helper", "Electron Helper",
            "CEF Helper", "Safari Web Content",
            "IMKLaunchAgent", "pboard", "secd", "cfprefsd",
            "AXVisualSupportAgent", "universalaccessd", "talagent",
            "Spotlight", "mds", "corespotlightd", "searchpartyd",
            "ssh-agent", "gpg-agent", "cloudphotod", "photolibraryd",
            "photoanalysisd", "mediaaccessibilityd", "CalendarAgent",
            "remindd", "contactsd", "imagent", "identityservicesd",
            "CommCenter", "parsecd", "rapportd", "sharingd",
            "ctkd", "spindump", "ReportCrash", "diagnosticd",
            "sysdiagnose", "amsaccountsd", "accountsd",
            "ProcessBeacon", // Don't show ourselves
        ]
        return filters.contains { command.contains($0) }
    }

    // MARK: - Notifications

    private func requestNotificationPermission() {
        let center = UNUserNotificationCenter.current()
        center.requestAuthorization(options: [.alert, .sound]) { _, _ in }
    }

    private func sendNotification(name: String, pid: Int32) {
        let center = UNUserNotificationCenter.current()
        let content = UNMutableNotificationContent()
        content.title = "Process Completed"
        content.body = "\(name) (PID \(pid)) has finished."
        content.sound = .default

        let request = UNNotificationRequest(
            identifier: "process-\(pid)-\(Date().timeIntervalSince1970)",
            content: content,
            trigger: nil
        )
        center.add(request)
    }
}

// MARK: - Time Formatting

func parseElapsed(_ str: String) -> Int {
    // Formats: "SS", "MM:SS", "HH:MM:SS", "D-HH:MM:SS"
    var days = 0
    var rest = str

    if let dashIdx = rest.firstIndex(of: "-") {
        days = Int(rest[..<dashIdx]) ?? 0
        rest = String(rest[rest.index(after: dashIdx)...])
    }

    let parts = rest.split(separator: ":").compactMap { Int($0) }

    switch parts.count {
    case 1: return days * 86400 + parts[0]
    case 2: return days * 86400 + parts[0] * 60 + parts[1]
    case 3: return days * 86400 + parts[0] * 3600 + parts[1] * 60 + parts[2]
    default: return days * 86400
    }
}

func formatElapsed(_ seconds: Int) -> String {
    if seconds < 60 { return "\(seconds)s" }
    if seconds < 3600 {
        let m = seconds / 60
        let s = seconds % 60
        return "\(m)m \(s)s"
    }
    if seconds < 86400 {
        let h = seconds / 3600
        let m = (seconds % 3600) / 60
        return "\(h)h \(m)m"
    }
    let d = seconds / 86400
    let h = (seconds % 86400) / 3600
    return "\(d)d \(h)h"
}

// MARK: - App

@main
struct ProcessBeaconApp: App {
    @State private var scanner = ProcessScanner()

    var body: some Scene {
        MenuBarExtra {
            PopupView(scanner: scanner)
                .frame(width: 380)
        } label: {
            HStack(spacing: 3) {
                Image(systemName: scanner.watchedCount > 0 ? "antenna.radiowaves.left.and.right" : "antenna.radiowaves.left.and.right")
                    .font(.system(size: 11))
                    .symbolEffect(.variableColor.iterative, isActive: scanner.watchedCount > 0)
                if !scanner.menuBarText.isEmpty {
                    Text(scanner.menuBarText)
                        .font(.system(size: 11, weight: .medium, design: .monospaced))
                }
            }
        }
        .menuBarExtraStyle(.window)
    }
}

// MARK: - Popup View

struct PopupView: View {
    @Bindable var scanner: ProcessScanner

    var body: some View {
        VStack(spacing: 0) {
            header
            Divider().overlay(Color.white.opacity(0.08))

            // Watched section (if any)
            if !scanner.watchedPids.isEmpty {
                watchedSection
                Divider().overlay(Color.white.opacity(0.08))
            }

            // Completed section (if any)
            if !scanner.completedProcesses.isEmpty {
                completedSection
                Divider().overlay(Color.white.opacity(0.08))
            }

            // Search
            searchBar
            Divider().overlay(Color.white.opacity(0.08))

            // Process list
            processList

            Divider().overlay(Color.white.opacity(0.08))
            footer
        }
        .background(Color(nsColor: .windowBackgroundColor))
    }

    // MARK: - Header

    private var header: some View {
        HStack(spacing: 8) {
            Image(systemName: "antenna.radiowaves.left.and.right")
                .font(.system(size: 14))
                .foregroundStyle(.secondary)
            Text("ProcessBeacon")
                .font(.system(size: 14, weight: .bold))
            Spacer()
            if scanner.watchedCount > 0 {
                Text("\(scanner.watchedCount) watched")
                    .font(.system(size: 11, weight: .medium))
                    .foregroundStyle(.orange)
                    .padding(.horizontal, 6)
                    .padding(.vertical, 2)
                    .background(.orange.opacity(0.15), in: RoundedRectangle(cornerRadius: 4))
            }
            Button {
                scanner.scan()
            } label: {
                Image(systemName: "arrow.clockwise")
                    .font(.system(size: 11))
                    .foregroundStyle(.secondary)
            }
            .buttonStyle(.borderless)
        }
        .padding(.horizontal, 14)
        .padding(.vertical, 10)
    }

    // MARK: - Watched Processes

    private var watchedSection: some View {
        VStack(alignment: .leading, spacing: 4) {
            HStack(spacing: 4) {
                Image(systemName: "eye.fill")
                    .font(.system(size: 10))
                Text("WATCHING")
                    .font(.system(size: 10, weight: .semibold))
                Spacer()
            }
            .foregroundStyle(.orange)
            .padding(.horizontal, 14)
            .padding(.top, 8)

            ForEach(scanner.processes.filter { $0.isWatched }) { proc in
                ProcessRow(process: proc, scanner: scanner, compact: true)
            }
        }
        .padding(.bottom, 4)
    }

    // MARK: - Completed Processes

    private var completedSection: some View {
        VStack(alignment: .leading, spacing: 4) {
            HStack(spacing: 4) {
                Image(systemName: "checkmark.circle.fill")
                    .font(.system(size: 10))
                Text("COMPLETED")
                    .font(.system(size: 10, weight: .semibold))
                Spacer()
                Button {
                    scanner.completedProcesses.removeAll()
                } label: {
                    Text("Clear")
                        .font(.system(size: 10))
                }
                .buttonStyle(.borderless)
            }
            .foregroundStyle(.green)
            .padding(.horizontal, 14)
            .padding(.top, 8)

            ForEach(scanner.completedProcesses.indices, id: \.self) { idx in
                let entry = scanner.completedProcesses[idx]
                HStack(spacing: 6) {
                    Image(systemName: "checkmark.circle.fill")
                        .font(.system(size: 11))
                        .foregroundStyle(.green)
                    Text(entry.name)
                        .font(.system(size: 12, weight: .medium))
                        .lineLimit(1)
                    Spacer()
                    Text(entry.date, style: .relative)
                        .font(.system(size: 10))
                        .foregroundStyle(.tertiary)
                }
                .padding(.horizontal, 14)
                .padding(.vertical, 3)
            }
        }
        .padding(.bottom, 4)
    }

    // MARK: - Search

    private var searchBar: some View {
        HStack(spacing: 6) {
            Image(systemName: "magnifyingglass")
                .font(.system(size: 11))
                .foregroundStyle(.tertiary)
            TextField("Filter by name, PID, or category...", text: $scanner.filterText)
                .textFieldStyle(.plain)
                .font(.system(size: 12))
        }
        .padding(.horizontal, 14)
        .padding(.vertical, 6)
    }

    // MARK: - Process List

    private var processList: some View {
        ScrollView {
            LazyVStack(spacing: 1) {
                let visible = scanner.filteredProcesses.filter { !$0.isWatched }
                if visible.isEmpty {
                    VStack(spacing: 6) {
                        Image(systemName: "tray")
                            .font(.system(size: 24))
                            .foregroundStyle(.tertiary)
                        Text(scanner.filterText.isEmpty ? "No user processes" : "No matches")
                            .font(.system(size: 12))
                            .foregroundStyle(.secondary)
                    }
                    .frame(maxWidth: .infinity)
                    .padding(.vertical, 20)
                } else {
                    ForEach(visible) { proc in
                        ProcessRow(process: proc, scanner: scanner, compact: false)
                    }
                }
            }
            .padding(.vertical, 4)
        }
        .frame(maxHeight: 320)
    }

    // MARK: - Footer

    private var footer: some View {
        HStack(spacing: 8) {
            Text("\(scanner.processes.count) processes")
                .font(.system(size: 11))
                .foregroundStyle(.secondary)
            Spacer()
            Text("Updated \(scanner.lastScan, style: .relative) ago")
                .font(.system(size: 10))
                .foregroundStyle(.tertiary)
            Divider().frame(height: 10)
            Button("Quit") {
                NSApplication.shared.terminate(nil)
            }
            .font(.system(size: 11))
            .buttonStyle(.borderless)
            .foregroundStyle(.secondary)
        }
        .padding(.horizontal, 14)
        .padding(.vertical, 8)
    }
}

// MARK: - Process Row

struct ProcessRow: View {
    let process: ProcessInfo
    let scanner: ProcessScanner
    let compact: Bool
    @State private var isHovered = false

    var body: some View {
        HStack(spacing: 8) {
            // Category icon
            Image(systemName: process.category.icon)
                .font(.system(size: 11))
                .foregroundStyle(process.category.color)
                .frame(width: 16)

            // Name + details
            VStack(alignment: .leading, spacing: 1) {
                HStack(spacing: 4) {
                    Text(process.shortName)
                        .font(.system(size: 12, weight: process.isWatched ? .bold : .medium))
                        .lineLimit(1)

                    if process.cpuPercent > 5 {
                        Text(String(format: "%.0f%%", process.cpuPercent))
                            .font(.system(size: 9, weight: .bold, design: .monospaced))
                            .foregroundStyle(.red)
                            .padding(.horizontal, 3)
                            .padding(.vertical, 1)
                            .background(.red.opacity(0.15), in: RoundedRectangle(cornerRadius: 3))
                    }
                }

                HStack(spacing: 6) {
                    Text("PID \(process.id)")
                        .foregroundStyle(.tertiary)
                    Text(process.elapsedFormatted)
                        .foregroundStyle(process.isWatched ? .orange : .secondary)
                    Text(process.category.rawValue)
                        .foregroundStyle(process.category.color.opacity(0.6))
                }
                .font(.system(size: 10))

                if isHovered {
                    Text(process.fullCommand)
                        .font(.system(size: 9, design: .monospaced))
                        .foregroundStyle(.tertiary)
                        .lineLimit(2)
                }
            }

            Spacer()

            // Watch toggle
            Button {
                scanner.toggleWatch(process.id)
            } label: {
                Image(systemName: process.isWatched ? "eye.fill" : "eye")
                    .font(.system(size: 12))
                    .foregroundStyle(process.isWatched ? .orange : .secondary.opacity(isHovered ? 1 : 0.3))
            }
            .buttonStyle(.borderless)
        }
        .padding(.horizontal, 14)
        .padding(.vertical, 5)
        .background(
            process.isWatched ? Color.orange.opacity(0.06) :
            isHovered ? Color.primary.opacity(0.04) : .clear,
            in: RoundedRectangle(cornerRadius: 6)
        )
        .padding(.horizontal, 4)
        .contentShape(Rectangle())
        .onHover { isHovered = $0 }
    }
}