El partido sigue aunque salgas

package com.sebastiannarvaez.marcador.feature.marcador.domain
 
import com.sebastiannarvaez.marcador.di.AlcanceDeApp
import com.sebastiannarvaez.marcador.feature.partidos.domain.PartidosRepository
import com.sebastiannarvaez.marcador.torneo.Gol
import com.sebastiannarvaez.marcador.torneo.intentar
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.async
import javax.inject.Inject
 
// CASO DE USO: una accion del usuario con sentido para el negocio.
//
// Un caso de uso es una clase con UNA operacion (`invoke`, asi se llama como una funcion:
// `registrarGol(1, Lado.LOCAL, 30)`). Vale la pena cuando hay REGLA: aqui, «quien marca».
// Si solo reenviara la llamada al repositorio, sobraria: el ViewModel lo llamaria directo.
//
// Regla: el gol a mano no dice quien lo marco, asi que lo marca el jugador de la
// plantilla que toca por turno (los goles que ya lleva el equipo, modulo el tamano).
// Los errores esperables (no existe el partido, el equipo no tiene jugadores) salen como
// `Result`, no como excepcion. Se atrapan con `intentar` (Cronometro.kt): como
// `runCatching`, pero RELANZA la CancellationException.
//
// UN GOL NO SE QUEDA A MEDIAS. Quien llama es la pantalla del partido, desde viewModelScope; si
// se cierra justo despues del gol, ese alcance se cancela y el gol se perderia a mitad de
// guardar. Por eso el trabajo se lanza en el ALCANCE DE LA APP (`alcance.async`) y aqui solo
// se ESPERA su resultado (`await`): si cancelan al que espera, el guardado sigue.
//
// @Inject constructor: le dice a Hilt «asi se construye esta clase; dame lo que pide entre
// parentesis». Hilt busca un PartidosRepository y el alcance con la etiqueta @AlcanceDeApp.
class RegistrarGol @Inject constructor(
    private val repositorio: PartidosRepository,
    @AlcanceDeApp private val alcance: CoroutineScope,
) {
 
    suspend operator fun invoke(partidoId: Int, lado: Lado, minuto: Int): Result<Gol> = alcance.async {
        intentar {
            val partido = repositorio.partido(partidoId) ?: error("No existe el partido $partidoId")
            val equipo = if (lado == Lado.LOCAL) partido.local else partido.visitante
            check(equipo.plantilla.isNotEmpty()) { "${equipo.nombre} no tiene jugadores" }
            val jugador = equipo.plantilla[partido.golesDe(equipo) % equipo.plantilla.size]
            Gol(minuto, jugador, equipo).also { repositorio.registrarGol(partidoId, it) }
        }
    }.await()
}

import com.sebastiannarvaez.marcador.feature.marcador.domain.PartidoEnJuego

//
// LA PANTALLA OBSERVA, NO ES LA DUENA. El partido ya no corre en viewModelScope (moriria al
// cerrar la pantalla): lo empieza `PartidoEnJuego`, en el alcance de la app. Este ViewModel
// solo lo busca (si ya esta en juego, lo reutiliza), lo traduce a un UiState y le pasa los eventos.
@HiltViewModel(assistedFactory = PartidoViewModel.Fabrica::class)
class PartidoViewModel @AssistedInject constructor(
    private val estadoGuardado: SavedStateHandle,
    private val repositorio: PartidosRepository,
    private val registrarGol: RegistrarGol,
    private val preferencias: PreferenciasRepository,
    private val enJuego: PartidoEnJuego,
    @Assisted partidoInicial: Int,
) : ViewModel() {

    // UNICA puerta de entrada de los eventos de la pantalla.
    fun alEvento(evento: MarcadorEvento) = when (evento) {
        // Lo empieza el partido en juego, no este ViewModel. Si hay otro sin terminar, no hace
        // nada.
        MarcadorEvento.Empezar -> {
            (carga.value as? Carga.Lista)?.let { enJuego.empezar(it.directo) }
            Unit
        }
        is MarcadorEvento.Gol -> (carga.value as? Carga.Lista)?.directo?.let { directo ->
            // Se ve al instante en el directo Y se guarda con el caso de uso (que termina de
            // guardarlo aunque esta pantalla se cierre: mira RegistrarGol).
            directo.golAMano(evento.lado)
            // El `Result` con el fallo (no existe el partido, plantilla vacia) se descarta:
            // por ahora no hay donde mostrarlo, y el gol ya se ve en el directo.
            viewModelScope.launch {
                registrarGol(directo.partidoId, evento.lado, directo.instante.value.minuto)
            }
            Unit
        } ?: Unit
        // Se guarda en DataStore y se prepara un directo NUEVO con esa duracion. Mientras este
        // partido se juega, se ignora: lo juega `PartidoEnJuego` y esta pantalla no puede reiniciarlo.
        is MarcadorEvento.CambiarDuracion -> {
            val directo = (carga.value as? Carga.Lista)?.directo
            if (directo?.instante?.value?.corriendo != true) {
                viewModelScope.launch {
                    preferencias.cambiarDuracion(evento.minutos)
                    cargar(partidoId.value, reutilizar = false)
                }
            }
            Unit
        }
    }
 
    // Cargar el partido `id`. Si es el que esta en juego (o el que acaba de terminar), se REUTILIZA
    // su directo: volver a la pantalla no lo reinicia. Si no, uno nuevo, sin empezar. Ahora el id llega en la
    // NavKey de la pantalla y solo se pide aqui (al crear y al cambiar la duracion): nadie lo cambia
    // desde dentro, asi que el handle y la clave no pueden discrepar.
    // La lectura va al repositorio: es `suspend`, asi que ya puede tardar (con Room).
    private fun cargar(id: Int, reutilizar: Boolean = true) {
        val vivo = enJuego.directo(id)
        if (reutilizar && vivo != null) {
            estadoGuardado[CLAVE_PARTIDO] = id
            carga.value = Carga.Lista(vivo)
            return
        }
        carga.value = Carga.EnCurso
        viewModelScope.launch {
            val elegido = repositorio.partido(id)
            if (elegido == null) {
                carga.value = Carga.Fallo("No existe el partido n.º $id")
            } else {
                // Solo se guarda el id si es valido: un id malo en el handle
                // rompería la app tambien tras un am kill.
                estadoGuardado[CLAVE_PARTIDO] = id
                carga.value = Carga.Lista(Directo(id, elegido, MS_POR_MINUTO, preferencias.duracionDelPartido.first()))
            }
        }
    }

import kotlinx.coroutines.delay

class FakePartidosRepository(
    partidos: List<PartidoDeLista> = listOf(PartidoDeLista(1, Partido(Ejemplo.rayo, Ejemplo.toros))),
    // Lo que tarda en guardar un gol (Room tambien tarda): para probar que no se pierde a medias.
    private val retrasoAlGuardar: Long = 0,
) : PartidosRepository {
    private val lista = MutableStateFlow(partidos)
 
    // Las plantillas, por nombre de equipo: hacen de tabla `jugador`.
    private val plantillas = MutableStateFlow(listOf(Ejemplo.rayo, Ejemplo.toros).associate { it.nombre to it.plantilla })
 
    override fun observarPartidos(): Flow<List<PartidoDeLista>> = lista
 
    override suspend fun partido(id: Int): Partido? = lista.value.firstOrNull { it.id == id }?.partido
 
    override suspend fun registrarGol(partidoId: Int, gol: Gol) {
        delay(retrasoAlGuardar)
        lista.value = lista.value.map { if (it.id == partidoId) it.copy(partido = it.partido.registrar(gol)) else it }
    }

import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.ViewModelStore
import androidx.lifecycle.viewmodel.initializer
import androidx.lifecycle.viewmodel.viewModelFactory
import com.sebastiannarvaez.marcador.feature.marcador.domain.PartidoEnJuego

    private fun TestScope.crear(
        repo: FakePartidosRepository = FakePartidosRepository(),
        preferencias: FakePreferencias = FakePreferencias(),
        partidoInicial: Int = 1,
        // `backgroundScope` hace de alcance de la app: el partido en juego vive ahi, no en el ViewModel.
        enJuego: PartidoEnJuego = PartidoEnJuego(backgroundScope),
    ) = PartidoViewModel(SavedStateHandle(), repo, RegistrarGol(repo, backgroundScope), preferencias, enJuego, partidoInicial)
 
    // Crea el ViewModel DENTRO de un almacen, como hace Android: `almacen.clear()` es cerrar la
    // pantalla (llama a onCleared y cancela viewModelScope).
    private fun TestScope.crearEn(almacen: ViewModelStore, crearlo: TestScope.() -> PartidoViewModel) =
        ViewModelProvider.create(almacen, viewModelFactory { initializer { crearlo() } })[PartidoViewModel::class]

        val registrar = RegistrarGol(repo, backgroundScope)

    // Cerrar la pantalla justo despues de un gol no lo pierde, aunque guardar tarde (como Room).
    @Test
    fun unGolSeGuardaAunqueSeCierreLaPantalla() = runTest {
        val repo = FakePartidosRepository(retrasoAlGuardar = 100)
        val almacen = ViewModelStore()
        val viewModel = crearEn(almacen) { crear(repo) }
        runCurrent()
        viewModel.alEvento(MarcadorEvento.Gol(Lado.LOCAL))
        runCurrent()          // el guardado empieza...
        almacen.clear()       // ...y la pantalla se cierra antes de que termine
        advanceTimeBy(1_000)  // (advanceUntilIdle no espera a lo que corre en backgroundScope)
        runCurrent()
        assertEquals(1, repo.partido(1)!!.eventos.filterIsInstance<Gol>().size)
    }
 
    // EL PARTIDO SIGUE AUNQUE SE CIERRE SU PANTALLA, y al volver se ve por donde va.
    @Test
    fun elPartidoSigueAunqueSeCierreLaPantalla() = runTest {
        val enJuego = PartidoEnJuego(backgroundScope)
        val almacen = ViewModelStore()
        val viewModel = crearEn(almacen) { crear(enJuego = enJuego) }
        runCurrent()
        viewModel.alEvento(MarcadorEvento.Empezar)
        advanceTimeBy(10 * PartidoViewModel.MS_POR_MINUTO + 1)
        almacen.clear()
        advanceTimeBy(20 * PartidoViewModel.MS_POR_MINUTO)
        runCurrent()
        assertEquals(30, enJuego.actual.value?.minuto)
        // Otra pantalla del MISMO partido reutiliza el directo: no empieza de cero.
        crear(enJuego = enJuego).uiState.test {
            skipItems(1) // Cargando, el valor inicial de stateIn
            assertEquals(30, (awaitItem() as MarcadorUiState.Exito).minuto)
            cancelAndIgnoreRemainingEvents()
        }
    }
 
    // Mientras se juega, la duracion no cambia (el ViewModel lo ignora).
    @Test
    fun laDuracionNoCambiaMientrasSeJuega() = runTest {
        val preferencias = FakePreferencias()
        val viewModel = crear(preferencias = preferencias)
        runCurrent()
        viewModel.alEvento(MarcadorEvento.Empezar)
        viewModel.alEvento(MarcadorEvento.CambiarDuracion(60))
        runCurrent()
        assertEquals(90, preferencias.duracion.value)
    }