import SwiftUI
import AppKit
import OnyxCore
import OnyxDesign
import OnyxNotch
import OnyxMenuBar
import OnyxWidgetKit
import CalendarProvider
import WeatherProvider
import MediaProvider
import MetricsProvider
import NetworkProvider
import AudioProvider
import ShelfProvider
import OSLog

private let log = Logger(subsystem: "com.scarriffleservices.onyx", category: "App")

@main
struct OnyxApp: App {
    @NSApplicationDelegateAdaptor(AppDelegate.self) private var delegate

    var body: some Scene {
        // Onyx hat kein Hauptfenster — alles lebt in der Notch und in der
        // Menüleiste. Die Einstellungen sind die einzige Ausnahme; im Panel
        // wäre dafür zu wenig Platz.
        // Eine Szene ist Pflicht, benutzt wird sie nicht: das
        // Einstellungsfenster führt SettingsWindowController selbst.
        // Siehe die Begründung dort.
        Settings { EmptyView() }
    }
}

@MainActor
final class AppDelegate: NSObject, NSApplicationDelegate {

    private(set) var model: AppModel?
    private var coordinator: NotchCoordinator?
    private var menuBar: MenuBarController?
    private var onyxItem: NSStatusItem?
    private var calendarModel: CalendarModel?
    private var weatherModel: WeatherModel?
    private var mediaModel: MediaModel?
    private var metricsModel: MetricsModel?
    private var networkModel: NetworkModel?
    private var shelfStore: ShelfStore?
    private let settingsWindow = SettingsWindowController()
    private let fanControl = FanControl()
    private let audioMixer = AudioMixer()
    private let launchAtLogin = LaunchAtLogin()
    private let onboarding = OnboardingWindowController()

    func applicationDidFinishLaunching(_ notification: Notification) {
        NSApp.setActivationPolicy(.accessory)

        // Vor allem anderen: sicherstellen, dass wir allein sind. Zwei Instanzen
        // bringen zwei Zustandsmaschinen und zwei Animationen auf dieselbe
        // Notch — das sieht aus wie ein Ruckler und ist keiner.
        if case .blocked(let pids) = SingleInstance.claim() {
            SingleInstance.explainBlocked(by: pids)
            NSApp.terminate(nil)
            return
        }

        registerWidgets()

        let model = AppModel()
        self.model = model
        // Die gespeicherte Wahl gleich anwenden — sonst steht Onyx nach einem
        // Neustart wieder ohne Dock-Symbol da, obwohl es eingeschaltet ist.
        NSApp.setActivationPolicy(model.showsDockIcon ? .regular : .accessory)

        let coordinator = NotchCoordinator(policy: model.displayPolicy) { _, presentation in
            NotchHostingView(
                rootView: NotchContainer(presentation: presentation) {
                    NotchPanelContent(model: model)
                },
                presentation: presentation)
        }
        coordinator.start()
        self.coordinator = coordinator
        applyContentSize()

        // Einstellungen wirken sofort. Eine Änderung, die erst nach einem
        // Neustart greift, ist in einer App ohne Fenster praktisch unauffindbar.
        model.onLayoutChanged = { [weak self] _ in self?.applyContentSize() }
        model.onDisplayPolicyChanged = { [weak self] policy in
            self?.coordinator?.policy = policy
            self?.applyContentSize()
        }

        let menuBar = MenuBarController()
        if let metricsModel {
            for metric in MetricKind.allCases {
                menuBar.register(MetricMenuBarModule(metric: metric, model: metricsModel),
                                 settings: model.menuBarSettings(for: "metric.\(metric.rawValue)"))
            }
        }
        if let networkModel {
            menuBar.register(NetworkMenuBarModule(model: networkModel),
                             settings: model.menuBarSettings(for: "network"))
        }
        // Mixer und Lüfter gehören genauso in die Leiste wie die Messwerte:
        // beides regelt man mitten in etwas anderem, und dafür ist der Weg
        // über ein Fenster zu weit.
        menuBar.register(MixerMenuBarModule(mixer: audioMixer),
                         settings: model.menuBarSettings(for: "audio"))
        menuBar.register(FanMenuBarModule(control: fanControl),
                         settings: model.menuBarSettings(for: "fans"))
        menuBar.start()
        self.menuBar = menuBar
        model.menuBar = menuBar

        installOnyxStatusItem()
        observeMenuBarPreference()
        requestPermissions()
    }

    /// Berechtigungen beim Start anfragen, nicht erst wenn ein Widget sichtbar
    /// wird.
    ///
    /// Das Panel ist beim Start zu. Eine an die View gebundene Anfrage kommt
    /// deshalb erst, wenn jemand die Notch berührt — und bis dahin taucht Onyx
    /// in den Systemeinstellungen gar nicht auf, es gibt also nichts, das man
    /// dort freischalten könnte. Genau dieser Zustand ist beim Testen
    /// aufgetreten.
    private func requestPermissions() {
        guard let calendarModel, let weatherModel else { return }
        log.notice("Start: Einrichtung erledigt = \(self.onboarding.isDone, privacy: .public)")
        // Immer einmal laden: mit Berechtigung kommen Termine, ohne sie zeigt
        // das Widget den Berechtigungshinweis statt einer leeren Liste.
        calendarModel.refresh()

        // Die Einrichtung kommt beim ersten Start immer — auch wenn zufällig
        // schon alles erlaubt ist. Sie erklärt nicht nur Berechtigungen,
        // sondern auch den Helfer und den Autostart, und sie ist der einzige
        // Moment, in dem jemand erfährt, was Onyx eigentlich alles kann.
        guard onboarding.isDone else {
            onboarding.show(calendarModel: calendarModel, weatherModel: weatherModel,
                            mixer: audioMixer, fanControl: fanControl,
                            launchAtLogin: launchAtLogin)
            return
        }

        // Danach nur noch, wenn wirklich etwas fehlt.
        let needsLocation = weatherModel.locationIsUndetermined
        guard !calendarModel.hasAccess || needsLocation else { return }

        // Nicht im Hintergrund anfragen.
        //
        // Onyx ist eine App ohne Fenster. TCC bereitet den Dialog zwar vor
        // (promptType 1), entscheidet sich dann aber dagegen (promptPolicy 0),
        // weil keine App im Vordergrund ist, an die er gehören könnte. Die
        // Anfrage kommt kommentarlos mit `false` zurück, der Status bleibt
        // `notDetermined` — und in den Systemeinstellungen taucht Onyx nie auf.
        // `NSApp.activate` davor hilft nicht: Aktivierung wirkt asynchron und
        // ist beim Aufruf noch nicht durch.
        //
        // Deshalb der ehrliche Weg: ein echtes Fenster im Vordergrund. Die
        // Einrichtung lief schon einmal, hier fehlt nur noch etwas — dann
        // genügt der Berechtigungsbereich der Einstellungen.
        showSettings(tab: .permissions)
    }

    /// Die Einrichtung noch einmal zeigen — aus den Einstellungen heraus.
    private func showOnboarding() {
        guard let calendarModel, let weatherModel else { return }
        onboarding.show(calendarModel: calendarModel, weatherModel: weatherModel,
                        mixer: audioMixer, fanControl: fanControl,
                        launchAtLogin: launchAtLogin)
    }

    /// Ausdrücklich `false`, auch wenn es der Standard ist.
    ///
    /// Onyx lebt in der Menüleiste und in der Notch. Dass das letzte Fenster
    /// zugeht, sagt über das Beenden nichts aus — und die Voreinstellung darf
    /// sich nicht unbemerkt ändern.
    func applicationShouldTerminateAfterLastWindowClosed(_ sender: NSApplication) -> Bool {
        false
    }

    func applicationWillTerminate(_ notification: Notification) {
        coordinator?.stop()
        menuBar?.stop()
        // Der Herzschlag endet damit. Der Helfer stellt die Lüfter binnen fünf
        // Sekunden auf Automatik zurück — auch wenn Onyx abstürzt statt sauber
        // zu beenden.
        fanControl.stop()
        // Ohne das bleiben die abgegriffenen Programme stumm zurück: der Tap
        // schaltet das Original stumm, und ohne laufenden Mixer gibt niemand
        // mehr etwas aus.
        audioMixer.disable()
    }

    private func registerWidgets() {
        let calendarModel = CalendarModel()
        self.calendarModel = calendarModel
        WidgetRegistry.shared.register(CalendarWidget(model: calendarModel))

        let weatherModel = WeatherModel()
        self.weatherModel = weatherModel
        WidgetRegistry.shared.register(WeatherWidget(model: weatherModel))

        let mediaModel = MediaModel()
        self.mediaModel = mediaModel
        WidgetRegistry.shared.register(MediaWidget(model: mediaModel))

        let metricsModel = MetricsModel()
        // Der Akku bekommt seinen Ladelimit-Regler über den Helfer, den sonst
        // die Lüfter benutzen — es ist derselbe SMC-Zugang.
        metricsModel.chargeControl = fanControl
        self.metricsModel = metricsModel
        for metric in MetricKind.allCases {
            WidgetRegistry.shared.register(MetricWidget(metric: metric, model: metricsModel))
        }

        let networkModel = NetworkModel()
        self.networkModel = networkModel
        WidgetRegistry.shared.register(NetworkWidget(model: networkModel))

        WidgetRegistry.shared.register(AudioMixerWidget(mixer: audioMixer))

        WidgetRegistry.shared.register(FanWidget(control: fanControl))

        let shelfStore = ShelfStore()
        self.shelfStore = shelfStore
        WidgetRegistry.shared.register(ShelfWidget(store: shelfStore))
        WidgetRegistry.shared.register(AirDropWidget())
    }

    private func applyContentSize() {
        guard let model, let coordinator else { return }
        let size = model.panelContentSize
        coordinator.activeControllers.forEach { $0.contentSize = size }
    }

    // MARK: - Menüleiste

    /// Das feste Onyx-Element.
    ///
    /// **Kein „Panel öffnen" im Menü.** Das Panel öffnet sich, wenn man die
    /// Notch berührt — ein Menüeintrag dafür beschreibt einen Umweg um die
    /// eigentliche Bedienung herum und wirft die Frage auf, wozu es die Notch
    /// dann gibt. Als Notausgang bleibt es trotzdem erreichbar, nur ohne
    /// eigene Zeile: **Linksklick auf das Symbol fährt das Panel aus,
    /// Rechtsklick zeigt das Menü.**
    private func installOnyxStatusItem() {
        let item = NSStatusBar.system.statusItem(withLength: NSStatusItem.squareLength)
        item.autosaveName = "onyx.menubar.main"
        item.button?.image = Self.menuBarIcon()
        item.button?.target = self
        item.button?.action = #selector(onyxItemClicked)
        item.button?.sendAction(on: [.leftMouseUp, .rightMouseUp])

        onyxItem = item
    }

    /// Links: Panel. Rechts: Menü.
    @objc private func onyxItemClicked() {
        guard let item = onyxItem, let button = item.button else { return }
        if NSApp.currentEvent?.type == .rightMouseUp {
            let menu = NSMenu()
            menu.addItem(withTitle: String(localized: "menu.settings"),
                         action: #selector(openSettings), keyEquivalent: ",").target = self
            menu.addItem(.separator())
            menu.addItem(withTitle: String(localized: "menu.quit"),
                         action: #selector(quit), keyEquivalent: "q").target = self
            // Das Menü nur für diesen Klick anhängen und danach wieder lösen —
            // bleibt es hängen, verschluckt es den Linksklick.
            item.menu = menu
            button.performClick(nil)
            item.menu = nil
        } else {
            togglePanel()
        }
    }

    /// Das Glyph aus dem App-Icon, auf Menüleistengröße gebracht.
    ///
    /// Nicht das vollständige App-Icon: das bringt die abgerundete Kachel samt
    /// Farbverlauf mit, und die gehört in Dock und Finder, nicht in die
    /// Menüleiste. Dort steht sie als farbiger Klotz zwischen lauter
    /// Strichsymbolen.
    ///
    /// **Eine eigene Konturfassung, nicht das App-Icon.**
    ///
    /// Das Glyph des App-Icons besteht aus deckenden Flächen in sehr dunklen
    /// Tönen. Auf dem blauen Verlauf des Icons liest es sich als Kristall,
    /// allein auf einer dunklen Menüleiste ist es schwarz auf schwarz. Und als
    /// Template-Bild — der einzige Weg, macOS zum Einfärben zu bewegen —
    /// verschmelzen die Facetten zu einer flachen Silhouette, weil dabei nur
    /// der Alphakanal zählt.
    ///
    /// `MenuBarIcon.svg` ist deshalb als Kontur gezeichnet: zwischen den Linien
    /// ist nichts, also bleibt beim Einfärben die Struktur erhalten. Das Symbol
    /// wird damit automatisch weiß auf dunkler und schwarz auf heller
    /// Menüleiste, ohne zweite Datei für den zweiten Fall.
    ///
    /// 18 pt ist die übliche Höhe; die Leiste ist 22 pt hoch und braucht oben
    /// und unten Luft.
    private static func menuBarIcon() -> NSImage {
        let size = NSSize(width: 18, height: 18)

        if let url = Bundle.main.url(forResource: "MenuBarIcon", withExtension: "svg"),
           let glyph = NSImage(contentsOf: url) {
            let image = NSImage(size: size, flipped: false) { rect in
                glyph.draw(in: rect, from: .zero, operation: .sourceOver, fraction: 1)
                return true
            }
            image.isTemplate = true
            image.accessibilityDescription = "Onyx"
            return image
        }

        // Ein Menüleisteneintrag ohne Bild wäre unsichtbar und die App darüber
        // unerreichbar — deshalb ein Rückfall statt eines leeren Knopfs.
        let fallback = NSImage(systemSymbolName: "circle.hexagongrid.fill",
                               accessibilityDescription: "Onyx") ?? NSImage()
        fallback.isTemplate = true
        return fallback
    }

    private func observeMenuBarPreference() {
        guard let model else { return }
        withObservationTracking {
            _ = model.showsMenuBarIcon
        } onChange: {
            Task { @MainActor [weak self] in
                self?.onyxItem?.isVisible = model.showsMenuBarIcon
                self?.observeMenuBarPreference()
            }
        }
        onyxItem?.isVisible = model.showsMenuBarIcon
    }

    @objc private func togglePanel() { coordinator?.togglePanelUnderPointer() }

    @objc private func openSettings() { showSettings(tab: .widgets) }

    private func showSettings(tab: SettingsTab) {
        guard let model, let calendarModel, let weatherModel else { return }
        settingsWindow.show(model: model, calendarModel: calendarModel,
                            weatherModel: weatherModel, metricsModel: metricsModel,
                            shelfStore: shelfStore, fanControl: fanControl,
                            launchAtLogin: launchAtLogin,
                            showOnboarding: { [weak self] in self?.showOnboarding() },
                            tab: tab)
    }

    @objc private func quit() { NSApp.terminate(nil) }
}

/// Der Inhalt des Panels. Liest `model.layout` und zeichnet sich damit neu,
/// sobald in den Einstellungen etwas geändert wird.
private struct NotchPanelContent: View {
    let model: AppModel

    var body: some View {
        WidgetGrid(placements: model.layout, availableWidth: AppModel.availableWidth)
    }
}