Settings and effective values

val active = checkbox(
    name = "active", label = "Enabled",
    description = "Use this model’s rules.", defaultValue = true
)
rules {
    when {
        !enabled(active) -> Indication(Aspect.Closed, Reason.Disabled)
        !fresh || !routeKnown || block != Occupancy.Clear ||
            observation.forcedStop || observation.lampFailed ->
            Indication(Aspect.Closed, Reason.Unknown)
        else -> Indication(Aspect.Open, Reason.Clear)
    }
}

val work = checkbox("work", "Work zone", defaultValue = false)
val workBlocks = NumberSetting(
    "workBlocks", "Following blocks", maximum = 64,
    defaultValue = 0, visibleWhen = work.name
)
number(workBlocks)

// Inside rules:
// val following = workBlocks.read(settings)

package wiki.prepared

import nimby.*

val work = Checkbox("work", "Work zone", "Apply this model's work-zone rule.")
val workBlocks = NumberSetting("workBlocks", "Following blocks", maximum = 64,
    defaultValue = 0, visibleWhen = work.name)
enum class Aspect { Closed, Open }
enum class Reason { Unknown, Clear, Work }

val model = signalModel(
    SignalType("example.work", "Work signal", "example_work", checkboxes = listOf(work)),
    fallback = Indication(Aspect.Closed, Reason.Unknown)) {
    number(workBlocks)
    construction(listOf("closed.svg", "open.svg"))
    rules {
        if (!fresh || !routeKnown || block != Occupancy.Clear || observation.forcedStop || observation.lampFailed)
            Indication(Aspect.Closed, Reason.Unknown)
        else if (enabled(work)) Indication(Aspect.Closed, Reason.Work)
        else Indication(Aspect.Open, Reason.Clear)
    }
    images { if (it.aspect == Aspect.Open) "open.svg" else "closed.svg" }
    driving { if (it.aspect == Aspect.Open) AutomaticDriving.clear() else AutomaticDriving.stop() }
}

// Example policy: propagate along nextSignal, not physical distance.
// Zero means source only. No derived setting is written to persistent storage.
fun effectiveWorkSettings(signals: List<Signal>): List<Signal> {
    val byId = signals.associateBy { it.id }
    val affected = HashSet<Long>()
    for (source in signals) {
        if (source.type != model.type.id || source.settingsStatus != SettingsStatus.Present ||
            !source.observation.fresh || source.settings[work.name] != true) continue
        var current: Signal? = source
        val seen = HashSet<Long>()
        repeat(workBlocks.read(source.settings) + 1) {
            val signal = current ?: return@repeat
            if (!seen.add(signal.id) || signal.type != model.type.id ||
                signal.settingsStatus != SettingsStatus.Present || !signal.observation.fresh) {
                current = null
                return@repeat
            }
            affected.add(signal.id)
            current = byId[signal.nextSignal]
        }
    }
    return signals.map { signal ->
        if (signal.id in affected && signal.settings[work.name] != true)
            signal.copy(settings = signal.settings + (work.name to true))
        else signal
    }
}

fun createPreparedMod() = signalMod("prepared-example", "Prepared settings") {
    signal(model)
    prepareNetwork(::effectiveWorkSettings)
}