//
//  MultiThreadDictionary.swift
//  Tusker
//
//  Created by Shadowfacts on 5/6/20.
//  Copyright © 2020 Shadowfacts. All rights reserved.
//

import Foundation
import os

// once we target iOS 16, replace uses of this with OSAllocatedUnfairLock<[Key: Value]>
// to make the lock semantics more clear
@available(iOS, obsoleted: 16.0)
class MultiThreadDictionary<Key: Hashable & Sendable, Value: Sendable> {
    private let lock: any Lock<[Key: Value]>
    
    init() {
        if #available(iOS 16.0, *) {
            self.lock = OSAllocatedUnfairLock(initialState: [:])
        } else {
            self.lock = MutexLock(initialState: [:])
        }
    }
    
    subscript(key: Key) -> Value? {
        get {
            return lock.withLock { dict in
                dict[key]
            }
        }
        set(value) {
            lock.withLock { dict in
                dict[key] = value
            }
        }
    }
    
    /// If the result of this function is unused, it is preferable to use `removeValueWithoutReturning` as it executes asynchronously and doesn't block the calling thread.
    func removeValue(forKey key: Key) -> Value? {
        return lock.withLock { dict in
            dict.removeValue(forKey: key)
        }
    }
    
    func contains(key: Key) -> Bool {
        return lock.withLock { dict in
            dict.keys.contains(key)
        }
    }
    
    func withLock<R>(_ body: @Sendable (inout [Key: Value]) throws -> R) rethrows -> R where R: Sendable {
        return try lock.withLock(body)
    }
}

// TODO: replace this only with OSAllocatedUnfairLock
@available(iOS, obsoleted: 16.0)
fileprivate protocol Lock<State> {
    associatedtype State
    func withLock<R>(_ body: @Sendable (inout State) throws -> R) rethrows -> R where R: Sendable
}

@available(iOS 16.0, *)
extension OSAllocatedUnfairLock: Lock {
}

// something is wrong with the UnfairLock impl and it results in segv_accerrs 
fileprivate class MutexLock<State>: Lock {
    private var state: State
    private var lock = NSLock()
    
    init(initialState: State) {
        self.state = initialState
    }
    
    func withLock<R>(_ body: @Sendable (inout State) throws -> R) rethrows -> R where R : Sendable {
        if !lock.lock(before: Date(timeIntervalSinceNow: 1)) {
            // if we can't acquire the lock after 1 second, something has gone catastrophically wrong
            fatalError()
        }
        defer { lock.unlock() }
        return try body(&state)
    }
}

//// from http://www.russbishop.net/the-law
//fileprivate class UnfairLock<State>: Lock {
//    private var lock: UnsafeMutablePointer<os_unfair_lock>
//    private var state: State
//    init(initialState: State) {
//        self.state = initialState
//        self.lock = .allocate(capacity: 1)
//        self.lock.initialize(to: os_unfair_lock())
//    }
//    deinit {
//        self.lock.deinitialize(count: 1)
//        self.lock.deallocate()
//    }
//    func withLock<R>(_ body: (inout State) throws -> R) rethrows -> R where R: Sendable {
//        os_unfair_lock_lock(lock)
//        defer { os_unfair_lock_unlock(lock) }
//        return try body(&state)
//    }
//}