vds_ios/VDS/Protocols/Handlerable.swift

//
//  Handlerable.swift
//  VDS
//
//  Created by Matt Bruce on 7/22/22.
//

import Foundation
import Combine
import UIKit

public enum HandlerableUpdateStrategy {
    case immediate
    case delayed
    case alwaysImmediate
    case paused
}

public protocol Handlerable: AnyObject, Initable, Disabling, Surfaceable {
    var subject: PassthroughSubject<Void, Never> { get set }
    var subscribers: Set<AnyCancellable> { get set }
    var updateStrategy: HandlerableUpdateStrategy { get set }
    func updateView()
}

extension Handlerable {
    public func setupNeedsUpdateEvent() {
        subject
            .debounce(for: .milliseconds(50), scheduler: RunLoop.main)
            .sink { [weak self] _ in
            self?.updateView()
        }.store(in: &subscribers)
    }
    
    public func setNeedsUpdate() {
        switch updateStrategy {
        case .delayed:
            subject.send()
        case .immediate, .alwaysImmediate:
            updateView()
        case .paused:
            break
        }
    }
    
    public func updateIfNeeded<T: Equatable>(_ oldValue: T, _ newValue: T) {
        if oldValue != newValue {
            setNeedsUpdate()
        }
    }
}

extension Handlerable where Self: UIControl {
    public func addEvent(event: UIControl.Event, block: @escaping (Self)->()) {
        publisher(for: event)
            .sink(receiveValue: { c in
                block(c)
            }).store(in: &subscribers)
    }
}

extension Handlerable {
    @discardableResult func pausedUpdate(_ closure: (_ instance: inout Self) -> Void) -> Self {
        var copy = self
        let oldStrategy = copy.updateStrategy
        copy.updateStrategy = .paused
        closure(&copy)
        copy.updateStrategy = oldStrategy
        copy.updateView()
        return copy
    }
}