app_for_indeed/App for Indeed/AppDelegate.swift

//
//  AppDelegate.swift
//  App for Indeed
//
//  Created by Mql Mac 2 on 11/05/2026.
//

import Cocoa

enum AppWindowConfiguration {
    static let defaultContentSize = NSSize(width: 1120, height: 800)
    static let minimumContentSize = NSSize(width: 1120, height: 800)

    @MainActor
    static func apply(to window: NSWindow) {
        MainWindowCloseBehavior.install(on: window)
        window.minSize = minimumContentSize
        window.isRestorable = false
        window.title = AppMarketingLinks.appDisplayName
        window.styleMask.insert(.fullSizeContentView)
        window.titlebarAppearsTransparent = true
        window.titleVisibility = .hidden
        window.isMovableByWindowBackground = true
        // Same as dashboard chrome — avoids a halo outside the frame with fullSizeContentView.
        window.backgroundColor = AppAppearanceManager.shared.windowChromeColor

        let targetContent = NSRect(origin: .zero, size: defaultContentSize)
        let targetFrame = window.frameRect(forContentRect: targetContent)
        var frame = targetFrame
        let current = window.frame
        frame.origin.x = current.midX - frame.width / 2
        frame.origin.y = current.midY - frame.height / 2
        window.setFrame(frame, display: false, animate: false)
        window.setContentSize(defaultContentSize)
    }

    @MainActor
    static func mainWindow(in app: NSApplication = .shared) -> NSWindow? {
        app.mainWindow
            ?? app.keyWindow
            ?? app.windows.first(where: { $0.isVisible && $0.canBecomeKey })
            ?? app.windows.first(where: { $0.canBecomeKey })
    }
}

@main
class AppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate {

    /// Avoids hammering StoreKit when `didBecomeActive` fires in quick succession (e.g. after system sheets).
    private var lastSubscriptionRefreshAt: Date?

    /// Window menu item that re-opens the main window after the user closes it with the red button.
    private var showMainWindowMenuItem: NSMenuItem?

    func applicationWillFinishLaunching(_ notification: Notification) {
        AppLanguageManager.shared.applyStoredPreferenceOnLaunch()
        AppAppearanceManager.shared.apply()
    }

    func applicationDidFinishLaunching(_ aNotification: Notification) {
        AppRatingCoordinator.shared.start()

        NotificationCenter.default.addObserver(
            forName: NSApplication.didBecomeActiveNotification,
            object: nil,
            queue: .main
        ) { [weak self] _ in
            Task { @MainActor in
                guard let self else { return }
                let now = Date()
                if let last = self.lastSubscriptionRefreshAt, now.timeIntervalSince(last) < 2.5 {
                    return
                }
                self.lastSubscriptionRefreshAt = now
                await SubscriptionStore.shared.refreshEntitlements(deep: true)
            }
        }

        // Initial StoreKit refresh runs on `LoadingViewController` before the dashboard is shown.
        installMainWindowMenuItem()
        AppMenuLocalizer.apply()
        NotificationCenter.default.addObserver(
            forName: AppLanguageManager.didChangeNotification,
            object: nil,
            queue: .main
        ) { _ in
            AppMenuLocalizer.apply()
        }
        NSApp.activate(ignoringOtherApps: true)
        applyDefaultWindowSize()
    }

    func refreshMainWindowMenuItemTitle() {
        showMainWindowMenuItem?.title = AppMarketingLinks.appDisplayName
    }

    @MainActor
    private func applyDefaultWindowSize() {
        DispatchQueue.main.async { [weak self] in
            guard let self, let window = AppWindowConfiguration.mainWindow() else { return }
            AppWindowConfiguration.apply(to: window)
            window.center()
            window.makeKeyAndOrderFront(nil)

            // Layout can run after the first pass; enforce default size once more.
            DispatchQueue.main.asyncAfter(deadline: .now() + 0.05) { [weak self] in
                guard self != nil, let window = AppWindowConfiguration.mainWindow() else { return }
                AppWindowConfiguration.apply(to: window)
                window.center()
            }
        }
    }

    func applicationWillTerminate(_ aNotification: Notification) {
        // Insert code here to tear down your application
    }

    func applicationSupportsSecureRestorableState(_ app: NSApplication) -> Bool {
        // Opt out until real `NSWindowRestoration` is implemented (avoids null className restore logs).
        return false
    }

    /// Keep running in the Dock when the user closes the last window (standard single-window macOS apps).
    func applicationShouldTerminateAfterLastWindowClosed(_ sender: NSApplication) -> Bool {
        false
    }

    /// Clicking the Dock icon after closing the window should bring it back.
    func applicationShouldHandleReopen(_ sender: NSApplication, hasVisibleWindows flag: Bool) -> Bool {
        guard !flag else { return true }
        showMainWindow(self)
        return true
    }

    /// Adds a persistent Window menu entry so reviewers and users can reopen the app after closing its window.
    private func installMainWindowMenuItem() {
        guard let windowMenu = NSApp.windowsMenu else { return }
        guard showMainWindowMenuItem == nil else { return }

        let item = NSMenuItem(
            title: AppMarketingLinks.appDisplayName,
            action: #selector(showMainWindow(_:)),
            keyEquivalent: ""
        )
        item.target = self
        showMainWindowMenuItem = item
        windowMenu.insertItem(item, at: 0)
        windowMenu.insertItem(NSMenuItem.separator(), at: 1)
        windowMenu.delegate = self
    }

    @objc func showMainWindow(_ sender: Any?) {
        guard let window = AppWindowConfiguration.mainWindow() else { return }
        window.makeKeyAndOrderFront(sender)
        NSApp.activate(ignoringOtherApps: true)
    }

    func menuNeedsUpdate(_ menu: NSMenu) {
        guard menu === NSApp.windowsMenu, let item = showMainWindowMenuItem else { return }
        let window = AppWindowConfiguration.mainWindow()
        let isVisible = window?.isVisible == true
        item.isEnabled = !isVisible
        item.state = isVisible ? .on : .off
    }
}

// MARK: - Main window close (hide on red button, do not quit)

@MainActor
private enum MainWindowCloseBehavior {
    private final class WindowDelegate: NSObject, NSWindowDelegate {
        static let shared = WindowDelegate()

        func windowShouldClose(_ sender: NSWindow) -> Bool {
            sender.orderOut(nil)
            return false
        }
    }

    static func install(on window: NSWindow) {
        window.isReleasedWhenClosed = false
        if window.delegate !== WindowDelegate.shared {
            window.delegate = WindowDelegate.shared
        }
    }
}