import Testing
@testable import MetricsProvider

@Suite("Strom: was gemeldet wird")
struct PowerWatcherTests {

    @Test("Der erste gelesene Zustand meldet nichts")
    func firstReadingIsSilent() {
        var watcher = PowerWatcher()
        // Beim Start ist „am Netz" kein Ereignis, sondern die Lage.
        #expect(watcher.observe(isCharging: false, isPluggedIn: true,
                                charge: 0.8, limit: nil) == nil)
        #expect(watcher.current == .plugged)
    }

    @Test("Derselbe Zustand meldet sich nicht noch einmal")
    func repeatedStateIsSilent() {
        var watcher = PowerWatcher()
        _ = watcher.observe(isCharging: true, isPluggedIn: true, charge: 0.5, limit: nil)
        #expect(watcher.observe(isCharging: true, isPluggedIn: true,
                                charge: 0.51, limit: nil) == nil)
        #expect(watcher.observe(isCharging: true, isPluggedIn: true,
                                charge: 0.99, limit: nil) == nil)
    }

    @Test("Netzteil abgezogen: das ist ein Ereignis")
    func unplugging() {
        var watcher = PowerWatcher()
        _ = watcher.observe(isCharging: true, isPluggedIn: true, charge: 0.5, limit: nil)
        #expect(watcher.observe(isCharging: false, isPluggedIn: false,
                                charge: 0.5, limit: nil) == .unplugged)
    }

    @Test("Fast leer schlägt „am Akku\"")
    func lowBeatsUnplugged() {
        var watcher = PowerWatcher()
        _ = watcher.observe(isCharging: true, isPluggedIn: true, charge: 0.9, limit: nil)
        // Beides trifft zu — gemeldet wird das, was man nicht verpassen darf.
        #expect(watcher.observe(isCharging: false, isPluggedIn: false,
                                charge: 0.15, limit: nil) == .low)
    }

    @Test("Von fast leer zurück auf normal ist wieder ein Wechsel")
    func recoveringFromLow() {
        var watcher = PowerWatcher()
        _ = watcher.observe(isCharging: false, isPluggedIn: false, charge: 0.1, limit: nil)
        #expect(watcher.observe(isCharging: false, isPluggedIn: false,
                                charge: 0.5, limit: nil) == .unplugged)
    }

    @Test("Die Schwelle liegt bei zwanzig Prozent, einschließlich")
    func thresholdIsInclusive() {
        var atThreshold = PowerWatcher()
        _ = atThreshold.observe(isCharging: true, isPluggedIn: true, charge: 0.9, limit: nil)
        #expect(atThreshold.observe(isCharging: false, isPluggedIn: false,
                                    charge: 0.2, limit: nil) == .low)

        var above = PowerWatcher()
        _ = above.observe(isCharging: true, isPluggedIn: true, charge: 0.9, limit: nil)
        #expect(above.observe(isCharging: false, isPluggedIn: false,
                              charge: 0.21, limit: nil) == .unplugged)
    }

    @Test("Am Ladelimit ist ein eigener Zustand, nicht „am Netz\"")
    func limitIsItsOwnState() {
        var watcher = PowerWatcher()
        _ = watcher.observe(isCharging: true, isPluggedIn: true, charge: 0.5, limit: 80)
        #expect(watcher.observe(isCharging: false, isPluggedIn: true,
                                charge: 0.80, limit: 80) == .atLimit(80))
    }
}