path: root/menubar/panel.swift

// The floating panel: an always-on-top HUD with the agents waiting for you.
//
// - Never takes focus: a non-activating panel, so typing stays in the
//   terminal. Visible on every Space and over full-screen apps.
// - Modes: off, on, auto (shown while something is blocked or done).
//   The global shortcut shows or hides it on top of the mode.
// - Compact: blocked and done agents in full; working and idle as one
//   summary line. The menu keeps the full list.

import AppKit

// MARK: visibility (pure, tested by --selftest)

enum PanelMode: String, CaseIterable {
    case off, on, auto

    var label: String {
        switch self {
        case .off: return "Off"
        case .on: return "Always"
        case .auto: return "When agents are waiting"
        }
    }
}

struct PanelVisibility: Equatable {
    var mode: PanelMode = .auto
    /// Set by the shortcut: true = shown, false = hidden, nil = follow mode.
    var forced: Bool?
    /// Pane ids of agents currently blocked or done.
    var waiting: Set<String> = []

    var visible: Bool {
        forced ?? (mode == .on || (mode == .auto && !waiting.isEmpty))
    }

    /// The shortcut: flip what is on screen right now.
    mutating func toggle() {
        forced = !visible
    }

    mutating func setMode(_ newMode: PanelMode) {
        mode = newMode
        forced = nil
    }

    /// A newly waiting agent cancels a manual hide (it needs you), except in
    /// mode off, where nothing shows unless asked for.
    mutating func update(waiting newWaiting: Set<String>) {
        if forced == false, !newWaiting.subtracting(waiting).isEmpty {
            forced = nil
        }
        waiting = newWaiting
    }
}

/// Run the visibility rules against expectations; returns failure messages.
func panelSelftest() -> [String] {
    var failures: [String] = []
    func check(_ condition: Bool, _ message: String) {
        if !condition { failures.append(message) }
    }

    var auto = PanelVisibility(mode: .auto)
    check(!auto.visible, "auto: hidden with nothing waiting")
    auto.update(waiting: ["a"])
    check(auto.visible, "auto: shown when an agent waits")
    auto.toggle()
    check(!auto.visible, "auto: shortcut hides")
    auto.update(waiting: ["a"])
    check(!auto.visible, "auto: stays hidden for the same waiting agents")
    auto.update(waiting: ["a", "b"])
    check(auto.visible, "auto: a newly waiting agent shows it again")
    auto.update(waiting: [])
    check(!auto.visible, "auto: hides when nothing waits")
    auto.toggle()
    check(auto.visible, "auto: shortcut shows it with nothing waiting")
    auto.update(waiting: [])
    check(auto.visible, "auto: a manual show stays")
    auto.toggle()
    check(!auto.visible, "auto: shortcut hides again")

    var off = PanelVisibility(mode: .off)
    off.update(waiting: ["a"])
    check(!off.visible, "off: hidden even when an agent waits")
    off.toggle()
    check(off.visible, "off: shortcut shows")
    off.toggle()
    off.update(waiting: ["a", "b"])
    check(!off.visible, "off: a new waiting agent does not show it")

    var on = PanelVisibility(mode: .on)
    check(on.visible, "on: shown with nothing waiting")
    on.toggle()
    check(!on.visible, "on: shortcut hides")
    on.update(waiting: ["a"])
    check(on.visible, "on: a newly waiting agent shows it again")

    var changed = PanelVisibility(mode: .auto, forced: false, waiting: ["a"])
    changed.setMode(.on)
    check(changed.visible && changed.forced == nil, "mode change clears the shortcut override")
    return failures
}

// MARK: compact content (pure, printed by --print-panel)

struct PanelContent {
    static let maxRows = 8

    let waiting: [Row]
    let overflow: Int
    let working: Int
    let idle: Int

    init(rows: [Row]) {
        let waitingRows = rows.filter(\.waiting)
        waiting = Array(waitingRows.prefix(Self.maxRows))
        overflow = max(0, waitingRows.count - Self.maxRows)
        working = rows.filter { $0.status == .working }.count
        idle = rows.filter { $0.status == .idle }.count
    }

    /// "◐ 2 working  ·  ○ 15 idle", or "No agents".
    var summary: NSAttributedString {
        let font = NSFont.systemFont(ofSize: 11)
        let text = NSMutableAttributedString()
        for (status, count) in [(Status.working, working), (.idle, idle)] where count > 0 {
            if text.length > 0 {
                text.append(NSAttributedString(
                    string: "  ·  ", attributes: [.font: font, .foregroundColor: NSColor.tertiaryLabelColor]))
            }
            text.append(NSAttributedString(
                string: "\(status.symbol) ", attributes: [.font: font, .foregroundColor: status.color]))
            text.append(NSAttributedString(
                string: "\(count) \(status.rawValue)",
                attributes: [.font: font, .foregroundColor: NSColor.secondaryLabelColor]))
        }
        if waiting.isEmpty {
            let lead = text.length > 0 ? "Nothing waiting  ·  " : "No agents waiting"
            text.insert(NSAttributedString(
                string: lead, attributes: [.font: font, .foregroundColor: NSColor.secondaryLabelColor]), at: 0)
        }
        return text
    }

    var plainText: String {
        var lines = waiting.map { "\($0.status.symbol) \($0.status.rawValue)\t\($0.label)\t\($0.subtitle)" }
        if overflow > 0 { lines.append("+\(overflow) more waiting") }
        lines.append(summary.string)
        return lines.joined(separator: "\n")
    }
}

// MARK: window

private let panelWidth: CGFloat = 440
private let inset: CGFloat = 8

/// One clickable agent row; a drag anywhere moves the panel instead.
private final class PanelRowView: NSView {
    private let paneId: String
    private let onClick: (String) -> Void
    private var dragged = false
    private var hovered = false { didSet { needsDisplay = true } }

    init(row: Row, onClick: @escaping (String) -> Void) {
        paneId = row.paneId
        self.onClick = onClick
        super.init(frame: .zero)
        let title = NSTextField(labelWithAttributedString: rowTitle(row))
        title.lineBreakMode = .byTruncatingTail
        let subtitle = NSTextField(labelWithString: row.subtitle)
        subtitle.font = .systemFont(ofSize: 11)
        subtitle.textColor = .secondaryLabelColor
        subtitle.lineBreakMode = .byTruncatingTail
        let stack = NSStackView(views: [title, subtitle])
        stack.orientation = .vertical
        stack.alignment = .leading
        stack.spacing = 1
        stack.translatesAutoresizingMaskIntoConstraints = false
        addSubview(stack)
        NSLayoutConstraint.activate([
            stack.leadingAnchor.constraint(equalTo: leadingAnchor, constant: 8),
            stack.trailingAnchor.constraint(lessThanOrEqualTo: trailingAnchor, constant: -8),
            stack.topAnchor.constraint(equalTo: topAnchor, constant: 5),
            stack.bottomAnchor.constraint(equalTo: bottomAnchor, constant: -5),
        ])
        toolTip = row.name.isEmpty ? nil : row.name
    }

    required init?(coder: NSCoder) { fatalError("not used") }

    override func acceptsFirstMouse(for event: NSEvent?) -> Bool { true }

    override func updateTrackingAreas() {
        super.updateTrackingAreas()
        trackingAreas.forEach(removeTrackingArea)
        addTrackingArea(NSTrackingArea(rect: bounds, options: [.mouseEnteredAndExited, .activeAlways],
                                       owner: self))
    }

    override func mouseEntered(with event: NSEvent) { hovered = true }
    override func mouseExited(with event: NSEvent) { hovered = false }

    override func draw(_ dirtyRect: NSRect) {
        guard hovered else { return }
        NSColor.white.withAlphaComponent(0.08).setFill()
        NSBezierPath(roundedRect: bounds, xRadius: 6, yRadius: 6).fill()
    }

    override func mouseDown(with event: NSEvent) { dragged = false }

    override func mouseDragged(with event: NSEvent) {
        if !dragged {
            dragged = true
            window?.performDrag(with: event)
        }
    }

    override func mouseUp(with event: NSEvent) {
        if !dragged { onClick(paneId) }
    }
}

final class PanelController {
    private let panel: NSPanel
    private let stack = NSStackView()
    private let onClick: (String) -> Void

    init(onClick: @escaping (String) -> Void) {
        self.onClick = onClick
        panel = NSPanel(contentRect: NSRect(x: 0, y: 0, width: panelWidth, height: 60),
                        styleMask: [.nonactivatingPanel, .borderless],
                        backing: .buffered, defer: false)
        panel.isFloatingPanel = true
        panel.level = .floating
        panel.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary]
        panel.hidesOnDeactivate = false
        panel.isMovableByWindowBackground = true
        panel.backgroundColor = .clear
        panel.isOpaque = false
        panel.hasShadow = true
        panel.appearance = NSAppearance(named: .vibrantDark)

        let effect = NSVisualEffectView()
        effect.material = .hudWindow
        effect.blendingMode = .behindWindow
        effect.state = .active
        effect.wantsLayer = true
        effect.layer?.cornerRadius = 12
        effect.layer?.masksToBounds = true
        panel.contentView = effect

        stack.orientation = .vertical
        stack.alignment = .leading
        stack.spacing = 0
        stack.translatesAutoresizingMaskIntoConstraints = false
        effect.addSubview(stack)
        NSLayoutConstraint.activate([
            stack.leadingAnchor.constraint(equalTo: effect.leadingAnchor, constant: inset),
            stack.trailingAnchor.constraint(equalTo: effect.trailingAnchor, constant: -inset),
            stack.topAnchor.constraint(equalTo: effect.topAnchor, constant: inset),
        ])

        // Remember where the user put it; first time, top right of the screen.
        if !panel.setFrameUsingName("dingger.panel"), let screen = NSScreen.main {
            let area = screen.visibleFrame
            panel.setFrameTopLeftPoint(NSPoint(x: area.maxX - panelWidth - 16, y: area.maxY - 16))
        }
        panel.setFrameAutosaveName("dingger.panel")
    }

    var isVisible: Bool { panel.isVisible }

    func render(_ content: PanelContent) {
        stack.arrangedSubviews.forEach { $0.removeFromSuperview() }
        for row in content.waiting {
            let view = PanelRowView(row: row, onClick: onClick)
            stack.addArrangedSubview(view)
            view.widthAnchor.constraint(equalTo: stack.widthAnchor).isActive = true
        }
        if content.overflow > 0 {
            stack.addArrangedSubview(caption(NSAttributedString(
                string: "+\(content.overflow) more waiting, see the menu bar",
                attributes: [.font: NSFont.systemFont(ofSize: 11),
                             .foregroundColor: NSColor.secondaryLabelColor])))
        }
        stack.addArrangedSubview(caption(content.summary))

        // Grow or shrink downward from the top edge.
        stack.layoutSubtreeIfNeeded()
        let height = stack.fittingSize.height + inset * 2
        let top = panel.frame.maxY
        panel.setFrame(NSRect(x: panel.frame.minX, y: top - height, width: panelWidth, height: height),
                       display: true)
    }

    private func caption(_ text: NSAttributedString) -> NSView {
        let label = NSTextField(labelWithAttributedString: text)
        let box = NSView()
        label.translatesAutoresizingMaskIntoConstraints = false
        box.addSubview(label)
        NSLayoutConstraint.activate([
            label.leadingAnchor.constraint(equalTo: box.leadingAnchor, constant: 8),
            label.trailingAnchor.constraint(lessThanOrEqualTo: box.trailingAnchor, constant: -8),
            label.topAnchor.constraint(equalTo: box.topAnchor, constant: 6),
            label.bottomAnchor.constraint(equalTo: box.bottomAnchor, constant: -4),
        ])
        return box
    }

    func show() { panel.orderFrontRegardless() }
    func hide() { panel.orderOut(nil) }
}