light.swift

public func alter(_ light:Light, by changes:Light.Change...) -> Light { changes.reduce(light) { $0.alter($1) } }

public struct Light:Codable, Equatable, Identifiable {
    public enum Change {
        case renaming(_RenameIt); public enum _RenameIt { case it     (to:String)    }
        case turning (_TurnIt  ); public enum _TurnIt   { case it     (Turn)         }
        case adding  (_Add     ); public enum _Add      { case mode   (Light.Mode)   }
        case toggling(_Toggle  ); public enum _Toggle   { case display(to:Interface) }
        case setting (_Set     ); public enum _Set      {
            case hue        (to:Double     )
            case saturation (to:Double     )
            case brightness (to:Double     )
            case temperature(to:Temperature)
        }
    }
    public init(id:String, name:String) { self.init(id, name, .off, 0, 0, 0, 0, .slider, [], .unset) }

    public enum Mode:Codable { case unset, hsb, ct }
    public let id        : String
    public let name      : String
    public let isOn      : Turn

    public let hue       : Double
    public let saturation: Double
    public let brightness: Double
    public let ct        : Int

    public let modes       : [Mode]
    public let selectedMode: Mode
    public let display     : Interface

    public func alter(_ changes:Change...) -> Self { changes.reduce(self) { $0.alter($1) } }

    private init(_ id          : String,
                 _ name        : String,
                 _ isOn        : Turn,
                 _ brightness  : Double,
                 _ saturation  : Double,
                 _ hue         : Double,
                 _ ct          : Int,
                 _ display     : Interface,
                 _ modes       : [Mode],
                 _ selectedMode: Mode     )
    {
        self.id           = id
        self.name         = name
        self.isOn         = isOn
        self.hue          = hue
        self.saturation   = saturation
        self.brightness   = brightness
        self.ct           = checkCT(ct)
        self.modes        = modes
        self.selectedMode = selectedMode
        self.display      = display
    }
    private func alter(_ change:Change) -> Self {
        func __(_ x: Double) -> Double { min(max(x, 0.0), 1.0) }
        switch change {
        case let .renaming(         .it(to:name      )): return .init(id, name, isOn,   brightness,   saturation,   hue, ct, display, modes,          selectedMode)
        case let .turning (         .it(isOn         )): return .init(id, name, isOn,   brightness,   saturation,   hue, ct, display, modes,          selectedMode)
        case let .setting ( .brightness(to:brightness)): return .init(id, name, isOn,__(brightness),  saturation,   hue, ct, display, modes,          selectedMode)
        case let .setting ( .saturation(to:saturation)): return .init(id, name, isOn,   brightness,__(saturation),  hue, ct, display, modes,          .hsb        )
        case let .setting (        .hue(to:hue       )): return .init(id, name, isOn,   brightness,   saturation,__(hue),ct, display, modes,          .hsb        )
        case let .setting (.temperature(to:.mirek(ct))): return .init(id, name, isOn,   brightness,   saturation,   hue, ct, display, modes,          .ct         )
        case let .toggling(    .display(to:display   )): return .init(id, name, isOn,   brightness,   saturation,   hue, ct, display, modes,          selectedMode)
        case let .adding  (       .mode(mode         )): return .init(id, name, isOn,   brightness,   saturation,   hue, ct, display, modes + [mode], selectedMode)
        }
    }
}