package io.oxygenhub.android.ui.common

import androidx.lifecycle.ViewModel

import androidx.lifecycle.viewModelScope

import io.oxygenhub.android.api.userMessage

import kotlinx.coroutines.CancellationException

import kotlinx.coroutines.Job

import kotlinx.coroutines.flow.MutableStateFlow

import kotlinx.coroutines.launch

/** Something fetched from the hub: on its way, here, or failed. */

sealed interface Load<out T> {

    data object Loading : Load<Nothing>

    /** [refreshing] while a pull-to-refresh fetches it again. */

    data class Ready<T>(val value: T, val refreshing: Boolean = false) : Load<T>

    data class Failed(val message: String) : Load<Nothing>

    val valueOrNull: T? get() = (this as? Ready<T>)?.value

    companion object {

        fun failed(e: Throwable): Failed = Failed(e.userMessage())

    }

}

/** The same value, marked as being fetched again (or Loading if there is none yet). */

fun <T> Load<T>.refreshing(): Load<T> = when (this) {

    is Load.Ready -> copy(refreshing = true)

    else -> Load.Loading

}

/**

 * Fetches into [into], keeping what is shown while it refreshes; cancels

 * [previous] first, so a second pull never races the first.

 */

fun <T> ViewModel.load(into: MutableStateFlow<Load<T>>, previous: Job?, fetch: suspend () -> T): Job {

    previous?.cancel()

    into.value = into.value.refreshing()

    return viewModelScope.launch {

        into.value = try {

            Load.Ready(fetch())

        } catch (e: CancellationException) {

            throw e

        } catch (e: Exception) {

            Load.failed(e)

        }

    }

}