onyx/Packages/OnyxKit/Sources/OnyxNotch/NotchScreenController.swift

import AppKit

/// Führt für genau einen Bildschirm Geometrie, Zustandsmaschine und Fenster zusammen.
///
/// Die Entscheidungen trifft `NotchStateMachine`; diese Klasse übersetzt sie nur
/// in Timer, Fensteraufrufe und Animationszustände. Deshalb steht hier auch kein
/// `if phase == …`.
@MainActor
public final class NotchScreenController {

    public private(set) var geometry: NotchGeometry
    public let displayID: CGDirectDisplayID
    public let presentation: NotchPresentation

    private var machine = NotchStateMachine()
    private let panel: NotchPanel
    private var armTimer: DispatchWorkItem?
    private var closeTimer: DispatchWorkItem?
    /// Entfernt das Fenster erst, wenn das Einfahren zu Ende ist.
    private var teardownTimer: DispatchWorkItem?

    /// Größe des **Inhalts**, nicht des Fensters. Die Layout-Engine liefert sie;
    /// den Freiraum für die Notch schlägt der Controller selbst auf, damit keine
    /// Aufrufstelle daran denken muss.
    public var contentSize: CGSize {
        didSet {
            guard contentSize != oldValue else { return }
            presentation.expandedSize = expandedSize
            layoutPanel()
        }
    }

    /// Fenstergröße: Inhalt plus der von der Notch verdeckte Streifen.
    private var expandedSize: CGSize {
        CGSize(width: contentSize.width, height: contentSize.height + geometry.rect.height)
    }

    public init(metrics: ScreenMetrics,
                virtualSize: CGSize,
                contentSize: CGSize = CGSize(width: 640, height: 320),
                makeContent: (NotchPresentation) -> NSView) {
        self.displayID = metrics.displayID
        let geometry = NotchGeometry.resolve(metrics, virtualSize: virtualSize)
        self.geometry = geometry
        self.contentSize = contentSize
        self.presentation = NotchPresentation(
            collapsedSize: geometry.rect.size,
            expandedSize: CGSize(width: contentSize.width,
                                 height: contentSize.height + geometry.rect.height),
            contentTopInset: geometry.rect.height)
        self.panel = NotchPanel(contentRect: .zero)
        panel.contentView = makeContent(presentation)
        layoutPanel()
    }

    public var phase: NotchPhase { machine.phase }
    public var isVisible: Bool { machine.isVisible }

    /// Meldet, wenn das Panel sichtbar wird oder verschwindet. Der Koordinator
    /// schaltet daran die Zeigerabfrage an und aus.
    public var onVisibilityChanged: ((Bool) -> Void)?

    // MARK: - Eingaben

    /// Zeigerposition in globalen Bildschirmkoordinaten.
    public func pointerMoved(to point: CGPoint) {
        // Nur die tatsächlich sichtbare Fläche zählt. Das Fenster ist immer so
        // groß wie das ausgefahrene Panel, damit die Animation Platz hat —
        // würde man `panel.frame` nehmen, hielte ein Zeiger in der noch leeren
        // Fläche das Panel offen.
        let inside = geometry.triggerRect.contains(point)
            || (presentation.isExpanded && panel.frame.contains(point))
        send(inside ? .pointerEntered : .pointerExited)
    }

    public func click() { send(.click) }
    public func escape() { send(.escape) }
    public func setSuppressed(_ suppressed: Bool) { send(.suppressed(suppressed)) }

    /// Nach einem Wechsel von Auflösung, Anordnung oder Skalierung.
    public func update(metrics: ScreenMetrics, virtualSize: CGSize) {
        geometry = NotchGeometry.resolve(metrics, virtualSize: virtualSize)
        presentation.collapsedSize = geometry.rect.size
        // Beim Wechsel zwischen eingebautem Display (38 pt Notch) und externem
        // (virtueller Balken) ändert sich der Freiraum mit.
        presentation.contentTopInset = geometry.rect.height
        presentation.expandedSize = expandedSize
        layoutPanel()
    }

    public func tearDown() {
        armTimer?.cancel()
        closeTimer?.cancel()
        teardownTimer?.cancel()
        panel.orderOut(nil)
    }

    // MARK: - Wirkungen

    /// Der einzige Weg, die Maschine zu bewegen.
    ///
    /// Sichtbarkeit wird hier verglichen und nicht in `apply`: `handle` hat den
    /// Zustand dort bereits geändert, ein Vergleich käme also immer negativ zurück.
    private func send(_ input: NotchInput) {
        let wasVisible = machine.isVisible
        apply(machine.handle(input))
        if machine.isVisible != wasVisible { onVisibilityChanged?(machine.isVisible) }
    }

    private func apply(_ effects: [NotchEffect]) {
        for effect in effects {
            switch effect {
            case .startArmTimer(let delay):
                armTimer?.cancel()
                armTimer = schedule(after: delay) { [weak self] in
                    self?.send(.armTimerFired)
                }

            case .cancelArmTimer:
                armTimer?.cancel()
                armTimer = nil

            case .startCloseTimer(let delay):
                closeTimer?.cancel()
                closeTimer = schedule(after: delay) { [weak self] in
                    self?.send(.closeTimerFired)
                }

            case .cancelCloseTimer:
                closeTimer?.cancel()
                closeTimer = nil

            case .show:
                show()

            case .hide:
                hide()
            }
        }
    }

    private func show() {
        // Ein noch laufendes Einfahren abbrechen: wer sofort zurückkehrt, soll
        // das Panel wieder aufgehen sehen und nicht dabei zusehen, wie es
        // mittendrin verschwindet.
        teardownTimer?.cancel()
        teardownTimer = nil

        layoutPanel()
        panel.orderFrontRegardless()

        // Erst im nächsten Durchlauf ausfahren. Im selben Durchlauf wie
        // `orderFrontRegardless` sieht SwiftUI keinen Zustandswechsel, sondern
        // nur den Endzustand — das Panel wäre schlagartig da.
        DispatchQueue.main.async { [weak self] in
            self?.presentation.isExpanded = true
        }
    }

    private func hide() {
        presentation.isExpanded = false
        teardownTimer?.cancel()
        teardownTimer = schedule(after: NotchPresentation.collapseDuration) { [weak self] in
            guard let self, !presentation.isExpanded else { return }
            panel.orderOut(nil)
        }
    }

    private func schedule(after delay: TimeInterval, _ body: @escaping @MainActor () -> Void)
    -> DispatchWorkItem {
        let item = DispatchWorkItem { MainActor.assumeIsolated { body() } }
        DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: item)
        return item
    }

    /// Das Fenster hat immer die Größe des ausgefahrenen Panels — die Animation
    /// findet im Inhalt statt, nicht am Fenster. Fensterrahmen zu animieren
    /// überlässt die Interpolation dem Fensterserver und ruckelt sichtbar.
    private func layoutPanel() {
        panel.setFrame(geometry.panelRect(for: expandedSize), display: presentation.isExpanded)
    }
}