onyx/Onyx/FanWidget.swift

import SwiftUI
import AppKit
import OnyxDesign
import OnyxWidgetKit
import OnyxMenuBar
import OnyxHelperProtocol

/// Die Lüfter — als Panel-Kachel und als Menüleistenmodul.
///
/// Beide zeigen dieselbe Ansicht auf derselben Datenquelle. Die Steuerung nur
/// in den Einstellungen zu verstecken war falsch: Lüfter regelt man, wenn es
/// gerade laut ist, und dann will man nicht erst ein Fenster suchen.
struct FanView: View {
    let control: FanControl
    /// Im Popover ist Platz für die Erklärung, in der Kachel nicht.
    let roomy: Bool

    var body: some View {
        VStack(alignment: .leading, spacing: Onyx.Space.row) {
            switch control.installState {
            case .installed:
                if let report = control.report, !report.fans.isEmpty {
                    ForEach(Array(report.fans.enumerated()), id: \.offset) { index, fan in
                        FanRow(control: control, index: index, fan: fan, roomy: roomy)
                    }
                    if let hottest = report.hottestCelsius {
                        OnyxHairline()
                        HStack(spacing: Onyx.Space.sm) {
                            Image(systemName: "thermometer.medium")
                                .font(.system(size: Onyx.Symbol.small))
                            Text("\(Int(hottest.rounded())) °C")
                                .font(Onyx.Font.metricSmall).monospacedDigit()
                            Spacer(minLength: 0)
                        }
                        .foregroundStyle(Onyx.Color.textTertiary)
                    }
                } else {
                    OnyxNotice(symbol: "fan",
                               text: String(localized: "fans.noData"),
                               placement: .leading)
                }
            case .requiresApproval:
                OnyxNotice(symbol: "hand.raised",
                           text: String(localized: "fans.approval.needed"),
                           placement: .leading) {
                    OnyxPillButton(String(localized: "fans.install")) {
                        control.openApprovalSettings()
                    }
                }
            case .notInstalled:
                OnyxNotice(symbol: "fan",
                           text: String(localized: "fans.notInstalled"),
                           placement: .leading) {
                    OnyxPillButton(String(localized: "fans.install")) { control.install() }
                }
            case .failed(let reason):
                Text(reason)
                    .font(Onyx.Font.caption)
                    .foregroundStyle(Onyx.Color.critical)
                    .fixedSize(horizontal: false, vertical: true)
            }
        }
        .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading)
        .onAppear { control.refreshInstallState() }
    }

}

private struct FanRow: View {
    let control: FanControl
    let index: Int
    let fan: FanStatus
    let roomy: Bool

    var body: some View {
        VStack(alignment: .leading, spacing: Onyx.Space.xs) {
            HStack(spacing: Onyx.Space.sm) {
                Text("fans.fan \(fan.index + 1)")
                    .font(Onyx.Font.caption)
                    .foregroundStyle(Onyx.Color.textSecondary)
                    .lineLimit(1)
                Spacer(minLength: 4)
                Text("fans.rpm \(Int(fan.currentRPM))")
                    .font(Onyx.Font.metricSmall).monospacedDigit()
                    .foregroundStyle(Onyx.Color.textPrimary)
            }

            HStack(spacing: Onyx.Space.md) {
                // Automatik ist der Ruhezustand und bleibt einen Klick entfernt:
                // wer manuell geregelt hat, muss ohne Nachdenken zurückkönnen.
                // Als gefüllte Pille, wenn sie greift — ein blauer Text sieht
                // aus wie ein Link und nicht wie ein Zustand.
                OnyxPillButton(String(localized: "fans.auto"),
                               isFilled: !fan.isManual,
                               size: .compact) {
                    control.setAutomatic(index: index)
                }
                .disabled(!fan.isManual)

                // Ein Regler über einen leeren Bereich stürzt ab. Meldet der
                // Helfer keine brauchbaren Grenzen — etwa weil der Lüfter steht
                // und der SMC nichts hergibt —, gibt es nichts zu ziehen.
                if fan.limits.maximum > fan.limits.minimum {
                    Slider(value: Binding(
                        get: { min(max(fan.targetRPM, fan.limits.minimum), fan.limits.maximum) },
                        set: { control.setTarget(index: index, rpm: $0) }),
                           in: fan.limits.minimum...fan.limits.maximum)
                        .controlSize(.mini)
                } else {
                    Text("fans.noRange")
                        .font(Onyx.Font.metricSmall)
                        .foregroundStyle(Onyx.Color.textTertiary)
                    Spacer(minLength: 0)
                }
            }
        }
    }
}

// MARK: - Panel-Kachel

struct FanWidget: OnyxWidget {
    let id = "fans"
    var displayName: String { String(localized: "widget.fans.name") }
    let symbolName = "fan"

    private let control: FanControl

    init(control: FanControl) { self.control = control }

    func makeView() -> AnyView {
        AnyView(ScrollView { FanView(control: control, roomy: false) }
            .scrollIndicators(.never))
    }
}

// MARK: - Menüleistenmodul

@MainActor
final class FanMenuBarModule: MenuBarModule {
    let id = "fans"
    var displayName: String { String(localized: "widget.fans.name") }

    var shortLabel: String { String(localized: "fans.menubar.short") }

    private let control: FanControl
    private var view: FanStatusView?
    private var isActive = false

    init(control: FanControl) { self.control = control }

    func makeStatusView(presentation: MenuBarPresentation) -> NSView {
        let view = FanStatusView(presentation: presentation)
        view.update(rpm: control.report?.fans.map(\.currentRPM).max())
        self.view = view
        return view
    }

    func makePopoverView() -> AnyView {
        AnyView(FanView(control: control, roomy: true)
            .padding(Onyx.Space.xl)
            .frame(width: 260))
    }

    func activate() {
        isActive = true
        control.start()
        startObserving()
    }

    func deactivate() {
        isActive = false
        view = nil
    }

    /// Keine eigene Messschleife: `FanControl` fragt den Helfer ohnehin ab, hier
    /// wird nur zugehört. `withObservationTracking` meldet sich **einmal** und
    /// muss danach neu eingerichtet werden.
    private func startObserving() {
        withObservationTracking {
            _ = control.report
        } onChange: {
            Task { @MainActor [weak self] in
                guard let self, isActive else { return }
                view?.update(rpm: control.report?.fans.map(\.currentRPM).max())
                startObserving()
            }
        }
    }
}

/// Die Drehzahl in der Menüleiste.
private final class FanStatusView: NSView, WidthReporting {
    private let presentation: MenuBarPresentation
    private var rpm: Double?

    init(presentation: MenuBarPresentation) {
        self.presentation = presentation
        super.init(frame: NSRect(x: 0, y: 0, width: 22, height: 22))
    }

    @available(*, unavailable)
    required init?(coder: NSCoder) { fatalError() }

    override var intrinsicContentSize: NSSize {
        NSSize(width: MenuBarText.width(for: reference, includesSymbol: true), height: 22)
    }

    /// Die breiteste Zahl, die vorkommen kann — nicht die aktuelle. Sonst
    /// änderte das Element bei jeder Messung seine Breite.
    private var reference: String { presentation == .symbol ? "" : "9999" }

    /// Der Lüfter zeigt ohnehin Symbol und Zahl — die neuen Darstellungen
    /// ändern daran nichts, sie stehen nur in der Auswahl nicht zur Verfügung.

    var onWidthChange: ((CGFloat) -> Void)?

    func update(rpm: Double?) {
        self.rpm = rpm
        needsDisplay = true
    }

    override func draw(_ dirtyRect: NSRect) {
        let color = NSColor.labelColor

        if presentation == .symbol {
            MenuBarText.drawSymbol("fan", color: color,
                                   in: NSRect(x: bounds.midX - 7.5, y: bounds.midY - 7.5,
                                              width: 15, height: 15))
            return
        }

        MenuBarText.drawSymbol("fan", color: color,
                               in: NSRect(x: 0, y: bounds.midY - 6.5, width: 13, height: 13))
        MenuBarText.draw(rpm.map { String(Int($0.rounded())) } ?? "–",
                         color: color,
                         in: NSRect(x: 15, y: 0, width: bounds.width - 15, height: bounds.height))
    }
}