//
//  Preference.swift
//  TuskerPreferences
//
//  Created by Shadowfacts on 4/13/24.
//

import Foundation
import Combine

// TODO: once we target iOS 17, use Observable for this
@propertyWrapper
final class Preference<Key: PreferenceKey>: Codable {
    @Published private(set) var storedValue: Key.Value?
    
    var wrappedValue: Key.Value {
        get {
            storedValue ?? Key.defaultValue
        }
        set {
            fatalError("unreachable")
        }
    }
    
    init() {
        self.storedValue = nil
    }
    
    init(from decoder: any Decoder) throws {
        if let keyType = Key.self as? any CustomCodablePreferenceKey.Type {
            self.storedValue = try keyType.decode(from: decoder) as! Key.Value?
        } else if let container = try? decoder.singleValueContainer() {
            self.storedValue = try? container.decode(Key.Value.self)
        }
    }
    
    func encode(to encoder: any Encoder) throws {
        if let storedValue {
            if let keyType = Key.self as? any CustomCodablePreferenceKey.Type {
                func encode<K: CustomCodablePreferenceKey>(_: K.Type) throws {
                    try K.encode(value: storedValue as! K.Value, to: encoder)
                }
                return try _openExistential(keyType, do: encode)
            } else {
                var container = encoder.singleValueContainer()
                try container.encode(storedValue)
            }
        }
    }
    
    static subscript(
        _enclosingInstance instance: PreferenceStore,
        wrapped wrappedKeyPath: ReferenceWritableKeyPath<PreferenceStore, Key.Value>,
        storage storageKeyPath: ReferenceWritableKeyPath<PreferenceStore, Preference>
    ) -> Key.Value {
        get {
            get(enclosingInstance: instance, storage: storageKeyPath)
        }
        set {
            set(enclosingInstance: instance, storage: storageKeyPath, newValue: newValue)
            Key.didSet(in: instance, newValue: newValue)
        }
    }
    
    // for testing only
    @inline(__always)
    static func get<Enclosing>(
        enclosingInstance: Enclosing,
        storage: KeyPath<Enclosing, Preference>
    ) -> Key.Value where Enclosing: ObservableObject, Enclosing.ObjectWillChangePublisher == ObservableObjectPublisher {
        let pref = enclosingInstance[keyPath: storage]
        return pref.storedValue ?? Key.defaultValue
    }
    
    // for testing only
    @inline(__always)
    static func set<Enclosing>(
        enclosingInstance: Enclosing,
        storage: KeyPath<Enclosing, Preference>,
        newValue: Key.Value
    ) where Enclosing: ObservableObject, Enclosing.ObjectWillChangePublisher == ObservableObjectPublisher {
        enclosingInstance.objectWillChange.send()
        let pref = enclosingInstance[keyPath: storage]
        pref.storedValue = newValue
    }
    
    var projectedValue: PreferencePublisher<Key> {
        .init(preference: self)
    }
}

public struct PreferencePublisher<Key: PreferenceKey>: Publisher {
    public typealias Output = Key.Value
    public typealias Failure = Never
    
    let preference: Preference<Key>
    
    public func receive<S>(subscriber: S) where S : Subscriber, Never == S.Failure, Key.Value == S.Input {
        preference.$storedValue.map { $0 ?? Key.defaultValue }.receive(subscriber: subscriber)
    }
}