Pith - spline
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()
        }
    }
}