class NetworkStateMachine(
    private val context: Context
) : FlowReduxStateMachine<ConnectionState, Unit>(initialState = defaultConnectionState()) {
    init {
        if (context !is Application) throw IllegalArgumentException("Context passed in NetworkStateMachines must be Application Context")

        spec {
            inState<ConnectionState.Unavailable> {
                collectWhileInState(context.observeConnectivityAsFlow()) { connectionState, state ->
                    state.override { connectionState }
                }
            }

            inState<ConnectionState.Available> {
                collectWhileInState(context.observeConnectivityAsFlow()) { connectionState, state ->
                    state.override { connectionState }
                }
            }
        }
    }

    fun immediateConnectedState(): ConnectionState = context.currentConnectivityState

    companion object {
        fun defaultConnectionState(): ConnectionState = ConnectionState.Unavailable
    }
}

class NetworkPresenter(
    private val networkStateMachines: NetworkStateMachine
) {
    @Composable
    fun uiModel(): ConnectionState {
        var connectionState by remember {
            mutableStateOf(networkStateMachines.immediateConnectedState())
        }

        LaunchedEffect(Unit) {
            networkStateMachines.state.collect {
                connectionState = it
            }
        }

        return connectionState
    }
}

class CounterStateMachine: FlowReduxStateMachine<CounterState, CounterEvent>(initialState = defaultCounterState()) {
    init {
        spec {
            // ....
        }
    }
    companion object {
        fun defaultCounterState(): CounterState = NotInitialized()
    }
}

class CounterPresenter(
    private val counterStateMachine: CounterStateMachine
) {
    private val events = MutableSharedFlow<CounterEvent>(extraBufferCapacity = 1)

    @Composable
    fun uiModel(): CounterState {
        var counterState by remember {
            mutableStateOf(CounterStateMachine.defaultCounterState())
        }

        LaunchedEffect(Unit) {
            events.collect { counterEvent ->
                counterStateMachine.dispatch(counterEvent)
            }
        }

        LaunchedEffect(Unit) {
            counterStateMachine.state.collect { currentState ->
                counterState = currentState
            }
        }

        return counterState
    }

    fun processEvent(event: CounterEvent) {
        events.tryEmit(event)
    }
}