package com.vgmlr.spline
import android.app.Application
import android.content.Intent
import androidx.lifecycle.AndroidViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.receiveAsFlow
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
internal class SplineReady(val dl: Long, val intent: Intent)
class SplineViewModel(app: Application) : AndroidViewModel(app) {
private val ctx: Application get() = getApplication()
private var apps: List<SplineApp> = SplineRepo.cached(app)
private val inFlight = mutableMapOf<Long, String>()
private val _entries = MutableStateFlow<List<SplineEntry>>(emptyList())
internal val entries: StateFlow<List<SplineEntry>> = _entries.asStateFlow()
val updates: StateFlow<Int> = _entries
.map { SplineRepo.updates(it) }
.stateIn(viewModelScope, SharingStarted.Eagerly, 0)
private val _failed = MutableStateFlow(false)
val failed: StateFlow<Boolean> = _failed.asStateFlow()
private val _scanning = MutableStateFlow(false)
val scanning: StateFlow<Boolean> = _scanning.asStateFlow()
private val _interval = MutableStateFlow(SplinePrefs.interval(app))
internal val interval: StateFlow<SplineInterval> = _interval.asStateFlow()
private val _lastScan = MutableStateFlow(SplinePrefs.lastScan(app))
val lastScan: StateFlow<Long> = _lastScan.asStateFlow()
private val _notify = MutableStateFlow(SplinePrefs.notifyOn(app))
val notify: StateFlow<Boolean> = _notify.asStateFlow()
private val _busy = MutableStateFlow<Set<String>>(emptySet())
val busy: StateFlow<Set<String>> = _busy.asStateFlow()
private val _progress = MutableStateFlow<Map<String, Float>>(emptyMap())
val progress: StateFlow<Map<String, Float>> = _progress.asStateFlow()
private val _ready = Channel<SplineReady>(Channel.BUFFERED)
internal val ready: Flow<SplineReady> = _ready.receiveAsFlow()
init {
refresh()
scan()
SplineSchedule.apply(app, _interval.value)
}
fun scan() {
if (_scanning.value) return
_scanning.value = true
viewModelScope.launch {
val ok = SplineRepo.scan(ctx)
_failed.value = !ok
if (ok) {
apps = withContext(Dispatchers.IO) { SplineRepo.cached(ctx) }
_lastScan.value = SplinePrefs.lastScan(ctx)
}
reload()
_scanning.value = false
}
}
fun refresh() {
viewModelScope.launch { reload() }
}
private suspend fun reload() {
val list = apps
_entries.value = withContext(Dispatchers.IO) {
SplineInstall.sweep(ctx)
SplineRepo.entries(ctx, list)
}
}
internal fun setInterval(v: SplineInterval) {
SplinePrefs.setInterval(ctx, v)
_interval.value = v
SplineSchedule.apply(ctx, v)
}
fun setNotify(v: Boolean) {
SplinePrefs.setNotifyOn(ctx, v)
_notify.value = v
if (!v) SplineNotify.clear(ctx)
}
internal fun get(app: SplineApp) {
if (app.id in _busy.value) return
_busy.update { it + app.id }
viewModelScope.launch {
val direct = withContext(Dispatchers.IO) { SplineInstall.direct(app.apk) }
if (!direct) {
SplineInstall.browse(ctx, app.apk)
_busy.update { it - app.id }
return@launch
}
val dl = withContext(Dispatchers.IO) {
SplineInstall.discardFor(ctx, app.id)
runCatching { SplineInstall.enqueue(ctx, app) }.getOrNull()
}
if (dl == null) {
_busy.update { it - app.id }
return@launch
}
inFlight[dl] = app.id
_progress.update { it + (app.id to 0f) }
val done = SplineInstall.await(ctx, dl) { p ->
_progress.update { it + (app.id to p) }
}
val intent = if (done) {
withContext(Dispatchers.IO) { SplineInstall.intent(ctx, dl) }
} else null
if (intent != null) _ready.send(SplineReady(dl, intent))
else installed(dl, false)
}
}
internal fun installed(dl: Long, ok: Boolean) {
inFlight.remove(dl)?.let { id ->
_busy.update { it - id }
_progress.update { it - id }
}
viewModelScope.launch {
if (!ok) withContext(Dispatchers.IO) { SplineInstall.discard(ctx, dl) }
reload()
}
}
}