class TimerFlow(
    val type: TimerType,
    val tickIntervalMillis: Long,
    private val externalScope: CoroutineScope
) {
    private val _timer = MutableSharedFlow<TimerTick>(replay = 0)
    val timer: SharedFlow<TimerTick> = _timer

    private var state: TimerState = TimerState.NotStarted
    private var _elapsedTimeMillis = 0L
    val elapsedTimeMillis: Long
        get() = _elapsedTimeMillis

    private val timerAsync: Deferred<Unit> = getCorrectTimerAsync(type)

    fun start() {
        if (state == TimerState.Completed || state == TimerState.Stopped) return

        externalScope.launch { handleStateChange(TimerState.Started) }
    }

    fun stop() {
        externalScope.launch { handleStateChange(TimerState.Stopped) }
    }

    private suspend fun tick() {
        _timer.emit(TimerTick(
            elapsedTimeMillis = _elapsedTimeMillis,
            state = state
        ))
        delay(tickIntervalMillis)
        _elapsedTimeMillis += tickIntervalMillis
    }

    private suspend fun handleStateChange(state: TimerState) {
        this.state = state
        when (state) {
            TimerState.NotStarted -> {
                /**
                 * Do nothing
                 */
            }
            TimerState.Started -> {
                timerAsync.start()
            }
            /**
             * Cancel the timer and send the final tick
             */
            TimerState.Stopped,
            TimerState.Completed -> {
                timerAsync.cancel()
                _timer.emit(TimerTick(
                    elapsedTimeMillis = elapsedTimeMillis,
                    state = state
                ))
            }
        }
    }

    private fun getCorrectTimerAsync(type: TimerType): Deferred<Unit> {
        return when (type) {
            TimerType.Indefinite -> {
                externalScope.async(start = CoroutineStart.LAZY) {
                    while (state != TimerState.Stopped &&
                        state != TimerState.Completed && this.isActive) {
                        tick()
                    }
                }
            }
            is TimerType.Duration -> {
                externalScope.async(start = CoroutineStart.LAZY) {
                    while (state != TimerState.Stopped &&
                        state != TimerState.Completed && this.isActive) {
                        if (_elapsedTimeMillis < type.durationMillis) {
                            tick()
                        } else {
                            handleStateChange(TimerState.Completed)
                        }
                    }
                }
            }
        }
    }
}

// given
val myTimer = TimerTask(Duration(100L), 50L, theScope)

// when
myTimer.start()
val result = myTimer.timer.first()

// then
result.elapsedTime shouldBeEqualTo 50
result.state shouldBeEqualTo Started

val result = myTimer.timer.first()