#if os(macOS)
import XCTest
@testable import RastrilloMacUpdates

final class QuietUpdateRulesTests: XCTestCase {
    func testBusyDefersOnlyScheduledChecksAndRunsThemWhenIdle() {
        var rules = QuietUpdateRules()
        XCTAssertTrue(rules.mayPerform(.background))
        XCTAssertFalse(rules.setBusy(true))
        XCTAssertFalse(rules.mayPerform(.background))
        // Asked for by the person: never held back.
        XCTAssertTrue(rules.mayPerform(.userInitiated))
        XCTAssertTrue(rules.mayPerform(.information))
        XCTAssertTrue(rules.setBusy(false), "the declined check runs when the call ends")
        XCTAssertFalse(rules.setBusy(true))
        XCTAssertFalse(rules.setBusy(false), "and only once")
    }

    func testNoDeferredCheckWhenNothingWasDeclined() {
        var rules = QuietUpdateRules()
        _ = rules.setBusy(true)
        XCTAssertTrue(rules.mayPerform(.userInitiated))
        XCTAssertFalse(rules.setBusy(false))
    }

    func testStagedUpdateIsReadyButNotActionableWhileBusy() {
        var rules = QuietUpdateRules()
        XCTAssertFalse(rules.canInstall)
        rules.staged(version: "0.3.5")
        XCTAssertEqual(rules.pending, .ready(version: "0.3.5"))
        XCTAssertTrue(rules.canInstall)
        _ = rules.setBusy(true)
        XCTAssertEqual(rules.pending, .ready(version: "0.3.5"), "busy hides the action, not the fact")
        XCTAssertFalse(rules.canInstall)
        _ = rules.setBusy(false)
        XCTAssertTrue(rules.canInstall)
        rules.clear()
        XCTAssertEqual(rules.pending, .none)
        XCTAssertFalse(rules.canInstall)
    }

    func testGentleReminderDistinguishesDownloadedFromAvailable() {
        var rules = QuietUpdateRules()
        rules.found(version: "0.3.5", downloaded: false)
        XCTAssertEqual(rules.pending, .available(version: "0.3.5"))
        rules.found(version: "0.3.5", downloaded: true)
        XCTAssertEqual(rules.pending, .ready(version: "0.3.5"))
    }
}

@MainActor final class QuietUpdaterTests: XCTestCase {
    /// Sparkle finds its optional delegate methods by selector. A Swift signature
    /// that drifts from the header compiles without a word and turns quiet updates
    /// back into Sparkle's alerts.
    func testDelegateAnswersSparklesSelectors() {
        let delegate = QuietUpdateDelegate()
        for selector in [
            "updater:mayPerformUpdateCheck:error:",
            "updater:willInstallUpdateOnQuit:immediateInstallationBlock:",
            "updater:didFinishUpdateCycleForUpdateCheck:error:",
            "supportsGentleScheduledUpdateReminders",
            "standardUserDriverShouldHandleShowingScheduledUpdate:andInImmediateFocus:",
            "standardUserDriverWillHandleShowingUpdate:forUpdate:state:",
            "standardUserDriverDidReceiveUserAttentionForUpdate:",
            "standardUserDriverWillFinishUpdateSession",
        ] {
            XCTAssertTrue(delegate.responds(to: NSSelectorFromString(selector)), selector)
        }
        XCTAssertTrue(delegate.supportsGentleScheduledUpdateReminders)
    }

    func testQuietUpdaterDefersAndReplaysScheduledCheck() {
        let updater = NativeUpdater(policy: .quiet)
        var replayed = 0
        updater.runDeferredCheck = { replayed += 1 }
        updater.isBusy = true
        XCTAssertFalse(updater.mayPerform(.background))
        XCTAssertTrue(updater.mayPerform(.userInitiated))
        XCTAssertEqual(replayed, 0)
        updater.isBusy = false
        XCTAssertEqual(replayed, 1)
    }

    func testStandardUpdaterNeverDefers() {
        let updater = NativeUpdater()
        XCTAssertEqual(updater.policy, .standard)
        updater.isBusy = true
        XCTAssertTrue(updater.mayPerform(.background))
    }

    func testRestartWaitsForIdleAndUsesSparklesInstallBlock() {
        let updater = NativeUpdater(policy: .quiet)
        var installs = 0
        updater.isBusy = true
        updater.staged(version: "0.3.5") { installs += 1 }
        XCTAssertEqual(updater.pendingUpdate, .ready(version: "0.3.5"))
        XCTAssertFalse(updater.canInstallPendingUpdate)
        updater.installPendingUpdate()
        XCTAssertEqual(installs, 0, "never relaunch during a call")
        updater.isBusy = false
        XCTAssertTrue(updater.canInstallPendingUpdate)
        updater.installPendingUpdate()
        XCTAssertEqual(installs, 1)
    }

    func testEndedSessionDropsNoticeAndInstallBlock() {
        let updater = NativeUpdater(policy: .quiet)
        var installs = 0
        updater.staged(version: "0.3.5") { installs += 1 }
        updater.sessionEnded()
        XCTAssertEqual(updater.pendingUpdate, .none)
        updater.installPendingUpdate()
        XCTAssertEqual(installs, 0)
    }

    func testUnconfiguredBundleCannotTurnOnAutomaticInstalls() {
        let updater = NativeUpdater(policy: .quiet)
        XCTAssertFalse(updater.canInstallUpdatesAutomatically)
        updater.automaticallyInstallsUpdates = true
        XCTAssertFalse(updater.automaticallyInstallsUpdates)
    }
}
#endif