dimmer.swift

func request(_ dimmer:Dimmer, to r:Dimmer.Request) { dimmer.request(r) }

struct Dimmer: UseCase {
    enum Request  { case increase(Light.Value, by:Light.Value.Increment, on:Light         )
                    case decrease(Light.Value, by:Light.Value.Increment, on:Light         ) }
    enum Response { case increase(Light.Value, by:Light.Value.Increment, on:Light, Outcome)
                    case decrease(Light.Value, by:Light.Value.Increment, on:Light, Outcome) }
    init(lightsStack: LightsStack, store: Store, responder: @escaping (Response) -> ()) {
        self.lightsStack = lightsStack
        self.store       = store
        self.respond     = responder
    }

    fileprivate
    func request(_ request: Request) {
        switch request{
        case let .increase(.brightness, by:.pt(increase), on:light):
            lightsStack.set(values:.bri(min(1.0, brightnessValue(of:light)  + (increase / 100.0))), on:light) { result in
                switch result {
                case .success(let light): store.change(.by(.replacing(.light(with:light)))); respond( .increase(.brightness,by:.pt(increase),on:light,.succeeded)     )
                case .failure(let error):                                                    respond( .increase(.brightness,by:.pt(increase),on:light,.failed(error)) )
                }
            }
        case let .decrease(.brightness, by:.pt(decrease), on:light):
            lightsStack.set(values:.bri(max(0.01, brightnessValue(of:light) - (decrease / 100.0))), on:light) { result in
                switch result {
                case .success(let light): store.change(.by(.replacing(.light(with:light)))); respond( .decrease(.brightness,by:.pt(decrease),on:light,.succeeded)     )
                case .failure(let error):                                                    respond( .decrease(.brightness,by:.pt(decrease),on:light,.failed(error)) )
                }
            }
        case let .increase(.saturation, by:.pt(increase), on:light):
            lightsStack.set(values:.hsb(hueValue(of:light), min(1.0, saturationValue(of:light)  + (increase / 100.0)), brightnessValue(of:light)), on:light) { result in
                switch result {
                case .success(let light): store.change(.by(.replacing(.light(with:light)))); respond( .increase(.saturation,by:.pt(increase),on:light,.succeeded)     )
                case .failure(let error):                                                    respond( .increase(.saturation,by:.pt(increase),on:light,.failed(error)) )
                }
            }
        case let .decrease(.saturation, by:.pt(decrease), on:light):
            lightsStack.set(values:.hsb(hueValue(of:light), max(0.01, saturationValue(of:light)  - (decrease / 100.0)), brightnessValue(of:light)), on:light) { result in
                switch result {
                case .success(let light): store.change(.by(.replacing(.light(with:light)))); respond( .decrease(.saturation,by:.pt(decrease),on:light,.succeeded)     )
                case .failure(let error):                                                    respond( .decrease(.saturation,by:.pt(decrease),on:light,.failed(error)) )
                }
            }
        case let .increase(.hue, by:.pt(increase), on:light):
            lightsStack.set(values:.hsb(min(1.0, hueValue(of:light)  + (increase / 100.0)), saturationValue(of:light), brightnessValue(of:light)), on:light) { result in
                switch result {
                case .success(let light): store.change(.by(.replacing(.light(with:light)))); respond( .increase(.hue,by:.pt(increase),on:light,.succeeded)     )
                case .failure(let error):                                                    respond( .increase(.hue,by:.pt(increase),on:light,.failed(error)) )
                }
            }
        case let .decrease(.hue, by:.pt(decrease), on:light):
            lightsStack.set(values:.hsb(max(0.01, hueValue(of:light) - (decrease / 100.0)), saturationValue(of:light), brightnessValue(of:light)), on:light) { result in
                switch result {
                case .success(let light): change(store, .by(.replacing(.light(with:light)))); respond( .decrease(.saturation,by:.pt(decrease),on:light,.succeeded)     )
                case .failure(let error):                                                     respond( .decrease(.saturation,by:.pt(decrease),on:light,.failed(error)) )
                }
            }
        case let .increase(.colortemp, by:.pt(increase), on:light):
            lightsStack.set(values:.ct( min(500, temperatureValue(of: light) + Int(increase * ((500-153) / 100))), brightnessValue(of:light)), on:light) { result in
                switch result {
                case .success(let light): store.change(.by(.replacing(.light(with:light)))); respond( .increase(.hue,by:.pt(increase),on:light,.succeeded)     )
                case .failure(let error):                                                    respond( .increase(.hue,by:.pt(increase),on:light,.failed(error)) )
                }
            }
        case let .decrease(.colortemp, by:.pt(decrease), on:light):
            lightsStack.set(values:.ct( max(153, temperatureValue(of: light) - Int(decrease * ((500-153) / 100))), brightnessValue(of:light)), on:light) { result in
                switch result {
                case .success(let light): store.change(.by(.replacing(.light(with:light)))); respond( .decrease(.saturation,by:.pt(decrease),on:light,.succeeded)     )
                case .failure(let error):                                                    respond( .decrease(.saturation,by:.pt(decrease),on:light,.failed(error)) )
                }
            }
        }
    }
    
    private let lightsStack: LightsStack
    private let store      : Store
    private let respond    : (Response) -> ()
    
    typealias RequestType = Request
    typealias ResponseType = Response
}