import Combine
import Foundation

func copyValues<T>(at keyPaths: [PartialKeyPath<T>], from source: T, to destination: inout T) {
    for keyPath in keyPaths.compactMap({ $0 as? any ValueCopyingKeyPath }) {
        keyPath.copyValue(from: source, to: &destination)
    }
}

extension _KeyValueCodingAndObservingPublishing where Self: NSObject {
    func publisher(forAll keyPaths: [PartialKeyPath<Self>], options: NSKeyValueObservingOptions = [.new]) -> AnyPublisher<Void, Never> {
        let publishers = keyPaths.compactMap { ($0 as? any PublishableKeyPath)?.publisher(on: self, options: options) }
        return Publishers.MergeMany(publishers)
            .eraseToAnyPublisher()
    }
}

extension KeyPath: PublishableKeyPath where Root: NSObject {
    func publisher<T: NSObject>(on object: T, options: NSKeyValueObservingOptions) -> AnyPublisher<Void, Never>? {
        precondition(object is Root)
        return unsafeDowncast(object, to: Root.self)
            .publisher(for: self, options: options)
            .map { _ in () }
            .eraseToAnyPublisher()
    }
}

extension WritableKeyPath: ValueCopyingKeyPath {
    func copyValue<T>(from source: T, to destination: inout T) {
        precondition(source is Root)
        precondition(destination is Root)
        let keyPath = unsafeDowncast(self, to: WritableKeyPath<T, Value>.self)
        destination[keyPath: keyPath] = source[keyPath: keyPath]
    }
}

private protocol PublishableKeyPath {
    associatedtype Root

    func publisher<T: NSObject>(on object: T, options: NSKeyValueObservingOptions) -> AnyPublisher<Void, Never>?
}

private protocol ValueCopyingKeyPath {
    associatedtype Root

    func copyValue<T>(from source: T, to destination: inout T)
}