import Foundation
import Testing
@testable import SstCore

struct GatedInserterTests {
    @Test func insertsWhenAllowed() async throws {
        let inner = FakeInserter()
        try await GatedInserter(inner: inner, shouldInsert: { true }).insert("hallo")
        #expect(inner.inserted == ["hallo"])
    }

    @Test func staysSilentWhenNotAllowed() async throws {
        let inner = FakeInserter()
        try await GatedInserter(inner: inner, shouldInsert: { false }).insert("hallo")
        #expect(inner.inserted.isEmpty)
    }

    @Test func askedAtInsertionTimeNotAtCreation() async throws {
        let inner = FakeInserter()
        var allowed = false
        let gated = GatedInserter(inner: inner, shouldInsert: { allowed })
        allowed = true
        try await gated.insert("nu wel")
        #expect(inner.inserted == ["nu wel"])
    }
}

struct SwappableTranscriberTests {
    @Test func throwsWithoutATranscriber() async {
        let swappable = SwappableTranscriber()
        #expect(!swappable.hasTranscriber)
        await #expect(throws: SwappableTranscriber.SwapError.self) {
            _ = try await swappable.transcribe([0])
        }
    }

    @Test func delegatesIncludingTheVocabulary() async throws {
        let inner = FakeVocabularyTranscriber()
        inner.result = "klaar"
        let swappable = SwappableTranscriber(inner)
        #expect(try await swappable.transcribe([0], vocabulary: ["Anthropic"]) == "klaar")
        #expect(inner.vocabularies == [["Anthropic"]])
        #expect(try await swappable.transcribe([0]) == "klaar")
        #expect(inner.vocabularies == [["Anthropic"], []])
    }

    @Test func swapReplacesTheTranscriber() async throws {
        let first = FakeVocabularyTranscriber(), second = FakeVocabularyTranscriber()
        first.result = "een"; second.result = "twee"
        let swappable = SwappableTranscriber(first)
        #expect(try await swappable.transcribe([0]) == "een")
        swappable.swap(to: second)
        #expect(try await swappable.transcribe([0]) == "twee")
        swappable.swap(to: nil)
        #expect(!swappable.hasTranscriber)
    }
}

struct LevelSourceTests {
    @Test func startsSilentAndKeepsTheLatestValue() {
        let source = LevelSource()
        #expect(source.dbfs == AudioLevel.silenceFloorDbfs)
        source.update(-23)
        source.update(-18)
        #expect(source.dbfs == -18)
        source.reset()
        #expect(source.dbfs == AudioLevel.silenceFloorDbfs)
    }
}