Implementation details

guard let tap = CGEvent.tapCreate(
    tap: .cgSessionEventTap,
    place: .headInsertEventTap,
    options: .defaultTap,
    eventsOfInterest: mask,
    callback: hotkeyCallback,
    userInfo: Unmanaged.passUnretained(self).toOpaque()
) else {
    NSLog("[HotkeyService] Failed to create event tap — Accessibility not granted?")
    DispatchQueue.main.async { [weak self] in
        self?.onTapFailed?()
    }
    return
}

private(set) var isModifierHeld = false
private(set) var isSwitcherActive = false
private(set) var isProfileModifierHeld = false
private(set) var isProfileSwitcherActive = false

if type == .tapDisabledByTimeout {
    if let tap = eventTap {
        if isSwitcherActive {
            isSwitcherActive = false
            onSwitcherCancelled?()
        }
        if isProfileSwitcherActive {
            isProfileSwitcherActive = false
            onProfileSwitcherCancelled?()
        }
        isModifierHeld = false
        isProfileModifierHeld = false

        CGEvent.tapEnable(tap: tap, enable: true)
        NSLog("[HotkeyService] Re-enabled event tap after timeout — reset modifier state")
    }
    return event
}

private static func activateRunning(_ app: NSRunningApplication) {
    // 1. Unhide first — hidden apps won't come to front otherwise
    if app.isHidden {
        app.unhide()
    }

    // 2. Use the older, more aggressive activate API
    //    The macOS 14+ parameterless activate() is weaker and doesn't
    //    always raise windows for apps like Simulator, Terminal, etc.
    app.activate(options: .activateIgnoringOtherApps)

    // 3. Raise the frontmost window via Accessibility API as a fallback.
    //    This forces the window to the top of the window stack, solving
    //    the issue where activate() updates the menu bar but leaves
    //    the window behind other apps.
    raiseWindows(of: app)
}

private static func raiseWindows(of app: NSRunningApplication) {
    let axApp = AXUIElementCreateApplication(app.processIdentifier)

    var value: CFTypeRef?
    let result = AXUIElementCopyAttributeValue(axApp, kAXWindowsAttribute as CFString, &value)
    guard result == .success, let windows = value as? [AXUIElement] else { return }

    for window in windows {
        AXUIElementPerformAction(window, kAXRaiseAction as CFString)
    }
}

private static func launchApp(at url: URL) {
    let config = NSWorkspace.OpenConfiguration()
    config.activates = true
    NSWorkspace.shared.openApplication(at: url, configuration: config) { _, error in
        if let error {
            NSLog("[AppSwitcherService] Failed to launch app: %@", error.localizedDescription)
        }
    }
}

final class OverlayPanel: NSPanel {
    init() {
        super.init(
            contentRect: .zero,
            styleMask: [.borderless, .nonactivatingPanel],
            backing: .buffered,
            defer: true
        )
        isFloatingPanel = true
        level = .screenSaver
        collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary, .stationary]
        isOpaque = false
        backgroundColor = .clear
        hasShadow = false
        hidesOnDeactivate = false
        isMovableByWindowBackground = false
        isReleasedWhenClosed = false
    }

    override var canBecomeKey: Bool { false }
    override var canBecomeMain: Bool { false }
}

func show(apps: [PinnedApp], selectedIndex: Int) {
    let panel = OverlayPanel()

    let overlayView = OverlayView(apps: apps, selectedIndex: selectedIndex)
    let hostingView = NSHostingView(rootView: overlayView)
    hostingView.frame = NSRect(x: 0, y: 0, width: 1, height: 1) // will resize
    panel.contentView = hostingView

    // Size to fit the content
    let fittingSize = hostingView.fittingSize
    let screenFrame = NSScreen.main?.frame ?? .zero
    let panelFrame = NSRect(
        x: (screenFrame.width - fittingSize.width) / 2 + screenFrame.origin.x,
        y: (screenFrame.height - fittingSize.height) / 2 + screenFrame.origin.y,
        width: fittingSize.width,
        height: fittingSize.height
    )
    panel.setFrame(panelFrame, display: true)

    panel.orderFrontRegardless()
    self.panel = panel
}

/// Returns the numeric ID of the currently active Space, or nil if
/// the private API is unavailable.
static var currentSpaceId: Int? {
    let conn = CGSMainConnectionID()
    guard conn > 0 else { return nil }
    let spaceId = CGSGetActiveSpace(conn)
    guard spaceId > 0 else { return nil }
    return spaceId
}

// MARK: - Private CGS declarations

/// Connection ID for the current login session.
@_silgen_name("CGSMainConnectionID")
private func CGSMainConnectionID() -> Int32

/// Returns the Space ID of the currently active desktop.
@_silgen_name("CGSGetActiveSpace")
private func CGSGetActiveSpace(_ cid: Int32) -> Int

private func observeWorkspace() {
    let center = NSWorkspace.shared.notificationCenter

    // Auto-switch profile when the active Space changes
    let spaceObserver = center.addObserver(
        forName: NSWorkspace.activeSpaceDidChangeNotification,
        object: nil,
        queue: .main
    ) { [weak self] _ in
        Task { @MainActor in
            self?.handleSpaceChange()
        }
    }
    workspaceObservers.append(spaceObserver)
}

private func handleSpaceChange() {
    guard let spaceId = SpaceService.currentSpaceId,
          let profileId = store.profileForSpace(spaceId)
    else { return }
    store.setActiveProfile(id: profileId)
}

func applicationDidFinishLaunching(_ notification: Notification) {
    if appState.permissions.isTrusted {
        appState.startHotkey()
    } else {
        // Prompt only on first-ever launch; poll silently afterwards
        appState.permissions.promptIfNeeded()

        // Start hotkey as soon as permission is granted
        appState.permissions.$isTrusted
            .removeDuplicates()
            .filter { $0 }
            .first()
            .receive(on: DispatchQueue.main)
            .sink { [weak self] _ in
                self?.appState.startHotkey()
            }
            .store(in: &cancellables)
    }
}