// Inspired by https://github.com/groue/CombineExpectations
import XCTest
@testable import GRDB

// MARK: - ValueObservationRecorder

public class ValueObservationRecorder<Value> {
    private struct RecorderExpectation {
        var expectation: XCTestExpectation
        var remainingCount: Int? // nil for error expectation
        var isIncluded: ((Value) -> Bool)? // nil for error expectation
    }
    
    /// The recorder state
    private struct State {
        var values: [Value]
        var error: Error?
        var recorderExpectation: RecorderExpectation?
        var cancellable: AnyDatabaseCancellable?
    }
    
    private let lock = NSLock()
    private var state = State(values: [], recorderExpectation: nil, cancellable: nil)
    private var consumedCount = 0
    
    /// Internal for testability. Use ValueObservation.record(in:) instead.
    init() { }
    
    private func synchronized<T>(_ execute: () throws -> T) rethrows -> T {
        lock.lock()
        defer { lock.unlock() }
        return try execute()
    }
    
    // MARK: ValueObservation API
    
    // Internal for testability.
    func onChange(_ value: Value) {
        return synchronized {
            if state.error != nil {
                // This is possible with ValueObservation, but not supported by ValueObservationRecorder
                XCTFail("ValueObservationRecorder got unexpected value after error: \(String(reflecting: value))")
            }
            
            state.values.append(value)
            
            if let exp = state.recorderExpectation,
                let remainingCount = exp.remainingCount,
                let isIncluded = exp.isIncluded
            {
                assert(remainingCount > 0)
                if isIncluded(value) {
                    exp.expectation.fulfill()
                    if remainingCount > 1 {
                        state.recorderExpectation = RecorderExpectation(
                            expectation: exp.expectation,
                            remainingCount: remainingCount - 1,
                            isIncluded: isIncluded)
                    } else {
                        state.recorderExpectation = nil
                    }
                }
            }
        }
    }
    
    // Internal for testability.
    func onError(_ error: Error) {
        return synchronized {
            if state.error != nil {
                // This is possible with ValueObservation, but not supported by ValueObservationRecorder
                XCTFail("f got unexpected error after error: \(String(describing: error))")
            }
            
            if let exp = state.recorderExpectation {
                exp.expectation.fulfill(count: exp.remainingCount ?? 1)
                state.recorderExpectation = nil
            }
            state.error = error
        }
    }
    
    // MARK: ValueObservationExpectation API
    
    func fulfillOnValue(_ expectation: XCTestExpectation, includingConsumed: Bool, isIncluded: @escaping (Value) -> Bool) {
        synchronized {
            preconditionCanFulfillExpectation()
            
            let expectedFulfillmentCount = expectation.expectedFulfillmentCount
            
            if state.error != nil {
                expectation.fulfill(count: expectedFulfillmentCount)
                return
            }
            
            let values = state.values.filter(isIncluded)
            let consumedValues = state.values[0..<consumedCount].filter(isIncluded)
            let maxFulfillmentCount = includingConsumed
                ? values.count
                : values.count - consumedValues.count
            let fulfillmentCount = min(expectedFulfillmentCount, maxFulfillmentCount)
            expectation.fulfill(count: fulfillmentCount)
            
            let remainingCount = expectedFulfillmentCount - fulfillmentCount
            if remainingCount > 0 {
                state.recorderExpectation = RecorderExpectation(
                    expectation: expectation,
                    remainingCount: remainingCount,
                    isIncluded: isIncluded)
            } else {
                state.recorderExpectation = nil
            }
        }
    }
    
    func fulfillOnError(_ expectation: XCTestExpectation) {
        synchronized {
            preconditionCanFulfillExpectation()
            
            if state.error != nil {
                expectation.fulfill()
                return
            }
            
            state.recorderExpectation = RecorderExpectation(
                expectation: expectation,
                remainingCount: nil,
                isIncluded: nil)
        }
    }
    
    /// Returns a value based on the recorded state.
    ///
    /// - parameter value: A function which returns the value, given the
    ///   recorded state.
    /// - parameter values: All recorded values.
    /// - parameter remainingValues: The values that were not consumed yet.
    /// - parameter consume: A function which consumes values.
    /// - parameter count: The number of consumed values.
    /// - returns: The value
    func value<T>(_ value: (
        _ values: [Value],
        _ error: Error?,
        _ remainingValues: ArraySlice<Value>,
        _ consume: (_ count: Int) -> ()) throws -> T)
        rethrows -> T
    {
        try synchronized {
            let values = state.values
            let remainingValues = values[consumedCount...]
            return try value(values, state.error, remainingValues, { count in
                precondition(count >= 0)
                precondition(count <= remainingValues.count)
                consumedCount += count
            })
        }
    }
    
    /// Checks that recorder can fulfill an expectation.
    ///
    /// The reason this method exists is that a recorder can fulfill a single
    /// expectation at a given time. It is a programmer error to wait for two
    /// expectations concurrently.
    ///
    /// This method MUST be called within a synchronized block.
    private func preconditionCanFulfillExpectation() {
        if let exp = state.recorderExpectation {
            // We are already waiting for an expectation! Is it a programmer
            // error? Recorder drops references to non-inverted expectations
            // when they are fulfilled. But inverted expectations are not
            // fulfilled, and thus not dropped. We can't quite know if an
            // inverted expectations has expired yet, so just let it go.
            precondition(exp.expectation.isInverted, "Already waiting for an expectation")
        }
    }
    
    fileprivate func receive(_ cancellable: AnyDatabaseCancellable) {
        synchronized {
            if state.cancellable != nil {
                XCTFail("ValueObservationRecorder is already observing")
            }
            state.cancellable = cancellable
        }
    }
}

// MARK: - ValueObservationRecorder + Expectations

extension ValueObservationRecorder {
    public func failure() -> ValueObservationExpectations.Failure<Value> {
        ValueObservationExpectations.Failure(recorder: self)
    }
    
    public func next() -> ValueObservationExpectations.NextOne<Value> {
        ValueObservationExpectations.NextOne(recorder: self)
    }
    
    public func next(_ count: Int) -> ValueObservationExpectations.Next<Value> {
        ValueObservationExpectations.Next(recorder: self, count: count)
    }
    
    public func prefix(_ maxLength: Int) -> ValueObservationExpectations.Prefix<Value> {
        ValueObservationExpectations.Prefix(
            recorder: self,
            expectedFulfillmentCount: maxLength,
            isIncluded: { _ in true })
    }
    
    public func prefix(until predicate: @escaping (Value) -> Bool) -> ValueObservationExpectations.Prefix<Value> {
        ValueObservationExpectations.Prefix(
            recorder: self,
            expectedFulfillmentCount: 1,
            isIncluded: predicate)
    }
}

// MARK: - ValueObservation + ValueObservationRecorder

extension ValueObservation {
    public func record(
        in reader: some DatabaseReader,
        scheduling scheduler: some ValueObservationScheduler = .async(onQueue: .main),
        onError: ((Error) -> Void)? = nil,
        onChange: ((Reducer.Value) -> Void)? = nil)
    -> ValueObservationRecorder<Reducer.Value>
    where Reducer: ValueReducer
    {
        let recorder = ValueObservationRecorder<Reducer.Value>()
        let cancellable = start(
            in: reader,
            scheduling: scheduler,
            onError: { [weak recorder] in
                onError?($0)
                recorder?.onError($0)
        },
            onChange: { [weak recorder] in
                onChange?($0)
                recorder?.onChange($0)
        })
        recorder.receive(cancellable)
        return recorder
    }
}

// MARK: - ValueObservationExpectation

public enum ValueRecordingError: Error {
    case notEnoughValues
    case notFailed
}

extension ValueRecordingError: LocalizedError {
    public var errorDescription: String? {
        switch self {
        case .notEnoughValues:
            return "ValueRecordingError.notEnoughValues"
        case .notFailed:
            return "ValueRecordingError.notFailed"
        }
    }
}

public protocol _ValueObservationExpectationBase {
    func _setup(_ expectation: XCTestExpectation)
}

public protocol ValueObservationExpectation: _ValueObservationExpectationBase {
    associatedtype Output
    func get() throws -> Output
}

// MARK: - XCTestCase + ValueObservationExpectation

extension XCTestCase {
    public func wait<E: ValueObservationExpectation>(
        for valueObservationExpectation: E,
        timeout: TimeInterval,
        description: String = "")
        throws -> E.Output
    {
        let expectation = self.expectation(description: description)
        valueObservationExpectation._setup(expectation)
        wait(for: [expectation], timeout: timeout)
        return try valueObservationExpectation.get()
    }
    
    /// This test checks the fundamental promise of ValueObservation by
    /// comparing recorded values with expected values.
    ///
    /// Recorded values match the expected values if and only if:
    ///
    /// - The last recorded value is the last expected value
    /// - Recorded values are in the same order as expected values
    ///
    /// However, both missing and repeated values are allowed - with the only
    /// exception of the last expected value which can not be missed.
    ///
    /// For example, if the expected values are [0, 1], then the following
    /// recorded values match:
    ///
    /// - `[0, 1]` (identical values)
    /// - `[1]` (missing value but the last one)
    /// - `[0, 0, 1, 1]` (repeated value)
    ///
    /// However the following recorded values don't match, and fail the test:
    ///
    /// - `[1, 0]` (wrong order)
    /// - `[0]` (missing last value)
    /// - `[]` (missing last value)
    /// - `[0, 1, 2]` (unexpected value)
    /// - `[1, 0, 1]` (unexpected value)
    func assertValueObservationRecordingMatch<R, E>(
        recorded: R,
        expected: E,
        _ message: @autoclosure () -> String = "",
        file: StaticString = #file,
        line: UInt = #line)
        where
        R: Collection,
        E: Collection,
        R.Element == E.Element,
        R.Element: Equatable
    {
        XCTAssertTrue(
            valueObservationRecordingMatch(recorded: recorded, expected: expected),
            "Unexpected recording \(Array(recorded)) - \(message())",
            file: file, line: line)
    }
    
    func valueObservationRecordingMatch<R, E>(
        recorded: R,
        expected: E)
    -> Bool
    where R: Collection,
          E: Collection,
          R.Element == E.Element,
          R.Element: Equatable
    {
        guard let first = recorded.first else {
            return expected.isEmpty
        }
        
        return expected.indices.lazy
            .filter { expected[$0] == first }
            .contains {
                valueObservationRecordingMatch(
                    recorded: recorded.drop(while: { $0 == first }),
                    expected: expected[$0...].dropFirst())
            }
    }
}

// MARK: - GRDBTestCase + ValueObservationExpectation

extension GRDBTestCase {
    func assertValueObservation<Reducer: ValueReducer>(
        _ observation: ValueObservation<Reducer>,
        records expectedValues: [Reducer.Value],
        setup: (Database) throws -> Void,
        recordedUpdates: @escaping (Database) throws -> Void,
        file: StaticString = #file,
        line: UInt = #line)
        throws
        where Reducer.Value: Equatable
    {
        func test(
            observation: ValueObservation<Reducer>,
            scheduling scheduler: some ValueObservationScheduler,
            testValueDispatching: @escaping () -> Void) throws
        {
            func testRecordingEqualWhenWriteAfterStart(writer: some DatabaseWriter) throws {
                try writer.write(setup)
                
                var value: Reducer.Value?
                let recorder = observation.record(
                    in: writer,
                    scheduling: scheduler,
                    onChange: {
                        testValueDispatching()
                        value = $0
                })
                
                // Test that initial value is set when scheduler is immediate
                if scheduler.immediateInitialValue() {
                    XCTAssertNotNil(value)
                }
                
                // Perform writes after start
                try writer.writeWithoutTransaction(recordedUpdates)
                
                let expectation = recorder.next(expectedValues.count)
                let values = try wait(for: expectation, timeout: 5)
                XCTAssertEqual(
                    values, expectedValues,
                    "\(#function), \(writer), \(scheduler)", file: file, line: line)
            }
            
            func testRecordingEqualWhenWriteAfterFirstValue(writer: some DatabaseWriter) throws {
                try writer.write(setup)
                
                var valueCount = 0
                var value: Reducer.Value?
                let recorder = observation.record(
                    in: writer,
                    scheduling: scheduler,
                    onChange: { [unowned writer] in
                        testValueDispatching()
                        valueCount += 1
                        if valueCount == 1 {
                            // Perform writes after initial value
                            try! writer.writeWithoutTransaction(recordedUpdates)
                        }
                        value = $0
                })
                
                // Test that initial value is set when scheduler is immediate
                if scheduler.immediateInitialValue() {
                    XCTAssertNotNil(value)
                }
                
                let expectation = recorder.next(expectedValues.count)
                let values = try wait(for: expectation, timeout: 5)
                XCTAssertEqual(
                    values, expectedValues,
                    "\(#function), \(writer), \(scheduler)", file: file, line: line)
            }
            
            func testRecordingMatchWhenWriteAfterStart(writer: some DatabaseWriter) throws {
                try writer.write(setup)
                
                var value: Reducer.Value?
                let recorder = observation.record(
                    in: writer,
                    scheduling: scheduler,
                    onChange: {
                        testValueDispatching()
                        value = $0
                })
                
                // Test that initial value is set when scheduler is immediate
                if scheduler.immediateInitialValue() {
                    XCTAssertNotNil(value)
                }
                
                try writer.writeWithoutTransaction(recordedUpdates)
                
                let recordedValues: [Reducer.Value]
                let lastExpectedValue = expectedValues.last!
                let waitForLast = expectedValues.firstIndex(of: lastExpectedValue) == expectedValues.count - 1
                if waitForLast {
                    // Optimization!
                    let expectation = recorder.prefix(until: { $0 == lastExpectedValue } )
                    recordedValues = try wait(for: expectation, timeout: 5)
                } else {
                    // Slow!
                    assertionFailure("Please rewrite your test, because it is too slow: make sure the last expected value is unique.")
                    let expectation = recorder
                        .prefix(expectedValues.count + 2 /* pool may perform double initial fetch */)
                        .inverted
                    recordedValues = try wait(for: expectation, timeout: 5)
                }
                
                if scheduler.immediateInitialValue() {
                    XCTAssertEqual(recordedValues.first, expectedValues.first)
                }
                
                assertValueObservationRecordingMatch(
                    recorded: recordedValues,
                    expected: expectedValues,
                    "\(#function), \(writer), \(scheduler)", file: file, line: line)
            }
            
            func testRecordingMatchWhenWriteAfterFirstValue(writer: some DatabaseWriter) throws {
                try writer.write(setup)
                
                var valueCount = 0
                var value: Reducer.Value?
                let recorder = observation.record(
                    in: writer,
                    scheduling: scheduler,
                    onChange: { [unowned writer] in
                        testValueDispatching()
                        valueCount += 1
                        if valueCount == 1 {
                            // Perform writes after initial value
                            try! writer.writeWithoutTransaction(recordedUpdates)
                        }
                        value = $0
                })
                
                // Test that initial value is set when scheduler is immediate
                if scheduler.immediateInitialValue() {
                    XCTAssertNotNil(value)
                }
                
                let recordedValues: [Reducer.Value]
                let lastExpectedValue = expectedValues.last!
                let waitForLast = expectedValues.firstIndex(of: lastExpectedValue) == expectedValues.count - 1
                if waitForLast {
                    // Optimization!
                    let expectation = recorder.prefix(until: { $0 == lastExpectedValue } )
                    recordedValues = try wait(for: expectation, timeout: 5)
                } else {
                    // Slow!
                    assertionFailure("Please rewrite your test, because it is too slow: make sure the last expected value is unique.")
                    let expectation = recorder
                        .prefix(expectedValues.count + 2 /* pool may perform double initial fetch */)
                        .inverted
                    recordedValues = try wait(for: expectation, timeout: 5)
                }
                
                XCTAssertEqual(recordedValues.first, expectedValues.first)
                
                assertValueObservationRecordingMatch(
                    recorded: recordedValues,
                    expected: expectedValues,
                    "\(#function), \(writer), \(scheduler)", file: file, line: line)
            }
            
            try testRecordingEqualWhenWriteAfterStart(writer: DatabaseQueue())
            try testRecordingEqualWhenWriteAfterFirstValue(writer: DatabaseQueue())
            
            try testRecordingEqualWhenWriteAfterStart(writer: makeDatabaseQueue())
            try testRecordingEqualWhenWriteAfterFirstValue(writer: makeDatabaseQueue())
            
            if observation.requiresWriteAccess {
                try testRecordingEqualWhenWriteAfterStart(writer: makeDatabasePool())
                try testRecordingEqualWhenWriteAfterFirstValue(writer: makeDatabasePool())
            } else {
                // DatabasePool may miss some changes
                try testRecordingMatchWhenWriteAfterStart(writer: makeDatabasePool())
                try testRecordingMatchWhenWriteAfterFirstValue(writer: makeDatabasePool())
            }
        }
        
        do {
            let key = DispatchSpecificKey<()>()
            DispatchQueue.main.setSpecific(key: key, value: ())
            
            try test(
                observation: observation,
                scheduling: .immediate,
                testValueDispatching: { XCTAssertNotNil(DispatchQueue.getSpecific(key: key)) })
        }
        
        do {
            let key = DispatchSpecificKey<()>()
            DispatchQueue.main.setSpecific(key: key, value: ())
            
            try test(
                observation: observation,
                scheduling: .async(onQueue: .main),
                testValueDispatching: { XCTAssertNotNil(DispatchQueue.getSpecific(key: key)) })
        }
        
        do {
            let queue = DispatchQueue(label: "custom")
            let key = DispatchSpecificKey<()>()
            queue.setSpecific(key: key, value: ())
            
            try test(
                observation: observation,
                scheduling: .async(onQueue: queue),
                testValueDispatching: { XCTAssertNotNil(DispatchQueue.getSpecific(key: key)) })
        }
    }
    
    func assertValueObservation<Reducer: ValueReducer, Failure: Error>(
        _ observation: ValueObservation<Reducer>,
        fails testFailure: (Failure, any DatabaseWriter) throws -> Void,
        setup: (Database) throws -> Void,
        file: StaticString = #file,
        line: UInt = #line)
        throws
    {
        func test(
            observation: ValueObservation<Reducer>,
            scheduling scheduler: some ValueObservationScheduler,
            testErrorDispatching: @escaping () -> Void) throws
        {
            func test(writer: some DatabaseWriter) throws {
                try writer.write(setup)
                
                let recorder = observation.record(
                    in: writer,
                    scheduling: scheduler,
                    onError: { _ in testErrorDispatching() })
                
                let (_, error) = try wait(for: recorder.failure(), timeout: 5)
                if let error = error as? Failure {
                    try testFailure(error, writer)
                } else {
                    throw error
                }
            }
            
            try test(writer: DatabaseQueue())
            try test(writer: makeDatabaseQueue())
            try test(writer: makeDatabasePool())
        }
        
        do {
            let key = DispatchSpecificKey<()>()
            DispatchQueue.main.setSpecific(key: key, value: ())
            
            try test(
                observation: observation,
                scheduling: .immediate,
                testErrorDispatching: { XCTAssertNotNil(DispatchQueue.getSpecific(key: key)) })
        }
        
        do {
            let key = DispatchSpecificKey<()>()
            DispatchQueue.main.setSpecific(key: key, value: ())
            
            try test(
                observation: observation,
                scheduling: .async(onQueue: .main),
                testErrorDispatching: { XCTAssertNotNil(DispatchQueue.getSpecific(key: key)) })
        }
        
        do {
            let queue = DispatchQueue(label: "custom")
            let key = DispatchSpecificKey<()>()
            queue.setSpecific(key: key, value: ())
            
            try test(
                observation: observation,
                scheduling: .async(onQueue: queue),
                testErrorDispatching: { XCTAssertNotNil(DispatchQueue.getSpecific(key: key)) })
        }
    }
}

// MARK: - ValueObservationExpectations

public enum ValueObservationExpectations { }

extension ValueObservationExpectations {
    
    // MARK: Inverted
    
    public struct Inverted<Base: ValueObservationExpectation>: ValueObservationExpectation {
        let base: Base
        
        public func _setup(_ expectation: XCTestExpectation) {
            base._setup(expectation)
            expectation.isInverted.toggle()
        }
        
        public func get() throws -> Base.Output {
            try base.get()
        }
    }
    
    // MARK: NextOne
    
    public struct NextOne<Value>: ValueObservationExpectation {
        let recorder: ValueObservationRecorder<Value>
        
        public func _setup(_ expectation: XCTestExpectation) {
            recorder.fulfillOnValue(expectation, includingConsumed: false, isIncluded: { _ in true })
        }
        
        public func get() throws -> Value {
            try recorder.value { (_, error, remainingValues, consume) in
                if let next = remainingValues.first {
                    consume(1)
                    return next
                }
                if let error {
                    throw error
                } else {
                    throw ValueRecordingError.notEnoughValues
                }
            }
        }
        
        public var inverted: NextOneInverted<Value> {
            return NextOneInverted(recorder: recorder)
        }
    }
    
    // MARK: NextOneInverted
    
    public struct NextOneInverted<Value>: ValueObservationExpectation {
        let recorder: ValueObservationRecorder<Value>
        
        public func _setup(_ expectation: XCTestExpectation) {
            expectation.isInverted = true
            recorder.fulfillOnValue(expectation, includingConsumed: false, isIncluded: { _ in true })
        }
        
        public func get() throws {
            try recorder.value { (_, error, remainingValues, consume) in
                if remainingValues.isEmpty == false {
                    return
                }
                if let error {
                    throw error
                }
            }
        }
    }
    
    // MARK: Next
    
    public struct Next<Value>: ValueObservationExpectation {
        let recorder: ValueObservationRecorder<Value>
        let count: Int
        
        init(recorder: ValueObservationRecorder<Value>, count: Int) {
            precondition(count >= 0, "Invalid negative count")
            self.recorder = recorder
            self.count = count
        }
        
        public func _setup(_ expectation: XCTestExpectation) {
            if count == 0 {
                // Such an expectation is immediately fulfilled, by essence.
                expectation.expectedFulfillmentCount = 1
                expectation.fulfill()
            } else {
                expectation.expectedFulfillmentCount = count
                recorder.fulfillOnValue(expectation, includingConsumed: false, isIncluded: { _ in true })
            }
        }
        
        public func get() throws -> [Value] {
            try recorder.value { (_, error, remainingValues, consume) in
                if remainingValues.count >= count {
                    consume(count)
                    return Array(remainingValues.prefix(count))
                }
                if let error {
                    throw error
                } else {
                    throw ValueRecordingError.notEnoughValues
                }
            }
        }
    }
    
    // MARK: Prefix
    
    public struct Prefix<Value>: ValueObservationExpectation {
        let recorder: ValueObservationRecorder<Value>
        let expectedFulfillmentCount: Int
        let isIncluded: (Value) -> Bool
        
        init(recorder: ValueObservationRecorder<Value>, expectedFulfillmentCount: Int, isIncluded: @escaping (Value) -> Bool) {
            precondition(expectedFulfillmentCount >= 0, "Invalid negative count")
            self.recorder = recorder
            self.expectedFulfillmentCount = expectedFulfillmentCount
            self.isIncluded = isIncluded
        }
        
        public func _setup(_ expectation: XCTestExpectation) {
            if expectedFulfillmentCount == 0 {
                // Such an expectation is immediately fulfilled, by essence.
                expectation.expectedFulfillmentCount = 1
                expectation.fulfill()
            } else {
                expectation.expectedFulfillmentCount = expectedFulfillmentCount
                recorder.fulfillOnValue(expectation, includingConsumed: true, isIncluded: isIncluded)
            }
        }
        
        public func get() throws -> [Value] {
            if expectedFulfillmentCount == 0 {
                return []
            }
            
            return try recorder.value { (values, error, remainingValues, consume) in
                let includedValues = values.filter(isIncluded)
                if includedValues.count >= expectedFulfillmentCount {
                    let matchedCount = values
                        .indices
                        .filter { isIncluded(values[$0]) }
                        .prefix(expectedFulfillmentCount)
                        .last! + 1
                    let extraCount = max(matchedCount + remainingValues.count - values.count, 0)
                    consume(extraCount)
                    return Array(values.prefix(matchedCount))
                }
                if let error {
                    throw error
                }
                consume(remainingValues.count)
                return values
            }
        }
        
        public var inverted: Inverted<Self> {
            return Inverted(base: self)
        }
    }
    
    // MARK: Failure
    
    public struct Failure<Value>: ValueObservationExpectation {
        let recorder: ValueObservationRecorder<Value>
        
        public func _setup(_ expectation: XCTestExpectation) {
            recorder.fulfillOnError(expectation)
        }
        
        public func get() throws -> (values: [Value], error: Error) {
            try recorder.value { (values, error, remainingValues, consume) in
                if let error {
                    consume(remainingValues.count)
                    return (values: values, error: error)
                } else {
                    throw ValueRecordingError.notFailed
                }
            }
        }
    }
}

// MARK: - Convenience

extension XCTestExpectation {
    fileprivate func fulfill(count: Int) {
        for _ in 0..<count {
            fulfill()
        }
    }
}