La pantalla pinta el uiState

    @Environment(\.dismiss) private var cerrar   // quita esta pantalla de la hoja; lo usa el estado de error
 
    var body: some View {
        // `switch` exhaustivo sobre el estado: si mañana hay uno más, no compila hasta que lo trates
        Group {
            switch viewModel.uiState {
            case .cargando:
                ProgressView()                                  // la ruedecita
            case let .error(mensaje):
                VStack(spacing: 16) {
                    Text(mensaje).foregroundStyle(.red)
                    Button("Volver") { cerrar() }
                }
            case let .exito(datos):
                contenido(datos)                                // el dibujo de siempre, ahora con los datos del estado
            }
        }
        // Lo que antes colgaba del ScrollView ahora cuelga del Group: la vista sigue lanzando el partido
        .task(id: ajustes.duracion) {
            await viewModel.jugar(duracion: ajustes.duracion)
        }
        .onChange(of: fase) { _, nueva in
            if nueva == .background { pausas += 1 }
        }
    }
 
    // El dibujo de antes, en una función que recibe los datos del estado
    private func contenido(_ datos: MarcadorUiState.Exito) -> some View {
        @Bindable var ajustes = ajustes   // sigue haciendo falta para `$ajustes.duracion`
        return ScrollView {               // `return` explícito: el cuerpo ya no es una sola expresión, tiene una línea antes
            VStack(spacing: 24) {
                TarjetaDePartido(partido: datos.partido, marcador: datos.marcador)
 
                // Se pasa el método del ViewModel como valor: la vista avisa de QUÉ pasó y no decide nada
                BotonesDeGolConAccion(partido: datos.partido, alGol: viewModel.alGol)
 
                VStack(alignment: .leading, spacing: 8) {
                    Text("Minuto \(datos.minuto)'")
                        .font(.title)
                        .monospacedDigit()
                        .accessibilityIdentifier("minuto")
                    Text(estado(datos))
                        .foregroundStyle(.secondary)
                        .accessibilityIdentifier("estado")
                    Text("Último aviso (cada 15'): \(datos.ultimoAviso)")
                    Text("Veces que la pantalla pasó a segundo plano: \(pausas)")
                }
                .frame(maxWidth: .infinity, alignment: .leading)
 
                VStack(alignment: .leading, spacing: 8) {
                    Text("Duración del partido")
                    Picker("Duración", selection: $ajustes.duracion) {
                        ForEach(AjustesModelo.duraciones, id: \.self) { minutos in
                            Text("\(minutos) min").tag(minutos)
                        }
                    }
                    .pickerStyle(.segmented)
                }
                .frame(maxWidth: .infinity, alignment: .leading)
            }
            .padding(16)
        }
    }
 
    // `estado` era una propiedad que leía el modelo; ahora es una función que lee los datos
    private func estado(_ datos: MarcadorUiState.Exito) -> String {
        // un `if` que da un valor: cada rama es el texto que devuelve la función
        if datos.minuto >= datos.duracion { "Partido terminado" }
        else if datos.corriendo { "En juego" }
        else { "Sin empezar" }
    }
}

import Testing
import Torneo
@testable import MarcadorApp
 
// Pruebas del ViewModel con el repositorio en memoria.
// `@MainActor`: el ViewModel lo es, y el target de pruebas no tiene el aislamiento por defecto.
@MainActor
struct PartidoViewModelTests {
 
    // Un repositorio con un solo partido, el de ejemplo (id 1)
    private func repositorio() -> RepositorioEnMemoria {
        RepositorioEnMemoria(
            equipos: [Ejemplo.rayo, Ejemplo.toros],
            partidos: [PartidoDeLista(id: 1, partido: Ejemplo.rayoContraToros)]
        )
    }
 
    @Test func jugarAplicaLosGolesDelGuionYActualizaElEstado() async {
        let viewModel = PartidoViewModel(partidoId: 1, repositorio: repositorio(), msPorMinuto: 0)
        await viewModel.jugar(duracion: 90)
        // `guard case let` mira si el estado es `.exito` y saca sus datos; si no, rellena `else`
        guard case let .exito(datos) = viewModel.uiState else {
            // `Issue.record` apunta un fallo en la prueba sin parar el programa, como un `#expect` que no se cumple
            Issue.record("Se esperaba .exito y salió \(viewModel.uiState)")
            return
        }
        #expect(datos.marcador == Marcador(local: 2, visitante: 1))
        #expect(datos.minuto == 90)
        #expect(!datos.corriendo)
        #expect(datos.ultimoAviso == "minuto 90 con 2-1")
    }
 
    @Test func unPartidoDeSesentaMinutosIgnoraElGolDelMinutoOchenta() async {
        let viewModel = PartidoViewModel(partidoId: 1, repositorio: repositorio(), msPorMinuto: 0)
        await viewModel.jugar(duracion: 60)
        #expect(viewModel.marcador == Marcador(local: 1, visitante: 1))
    }
 
    @Test func unPartidoQueNoExisteDaUnEstadoDeError() {
        let viewModel = PartidoViewModel(partidoId: 99, repositorio: repositorio(), msPorMinuto: 0)
        #expect(viewModel.uiState == .error("No existe el partido n.º 99"))
    }
 
    @Test func unGolAManoSeVeYSeGuardaEnElRepositorio() {
        let repo = repositorio()
        let viewModel = PartidoViewModel(partidoId: 1, repositorio: repo, msPorMinuto: 0)
        viewModel.alGol(.visitante)
        #expect(viewModel.marcador == Marcador(local: 0, visitante: 1))
        // El repositorio ya tiene un gol más (el 2-1 de ejemplo pasa a 2-2).
        #expect(repo.partido(id: 1)?.marcador() == Marcador(local: 2, visitante: 2))
    }
 
    @Test func cancelarLaTareaDetieneElPartido() async {
        let viewModel = PartidoViewModel(partidoId: 1, repositorio: repositorio(), msPorMinuto: 20)
        let tarea = Task { await viewModel.jugar(duracion: 90) }
        try? await Task.sleep(for: .milliseconds(150))
        tarea.cancel()
        await tarea.value
        #expect(viewModel.minuto < 90)
        #expect(!viewModel.corriendo)
    }
 
    // La prueba del ciclo. Con `[weak self]` el ViewModel se libera en cuanto se suelta...
    @Test func elViewModelSeLiberaAlSoltarlo() async {
        weak var referencia: PartidoViewModel?   // referencia débil: no cuenta para ARC; pasa a nil cuando el objeto se libera
        do {                                     // un `do { }` solo es un bloque: lo que se crea dentro desaparece al salir
            let viewModel = PartidoViewModel(partidoId: 1, repositorio: repositorio(), msPorMinuto: 0, reintroducirElCiclo: false)
            referencia = viewModel
            await viewModel.jugar(duracion: 3)
        }                                        // el ViewModel sale de su alcance aquí
        #expect(referencia == nil)               // y se ha liberado
    }
 
    // ...y con el ciclo reintroducido, NO: `referencia` sigue viva aunque nadie tenga el ViewModel.
    // (Este objeto se queda en memoria hasta que termina el proceso de pruebas: es la fuga.)
    @Test func conElCicloReintroducidoElViewModelSeQuedaEnMemoria() async {
        weak var referencia: PartidoViewModel?
        do {
            let viewModel = PartidoViewModel(partidoId: 1, repositorio: repositorio(), msPorMinuto: 0, reintroducirElCiclo: true)
            referencia = viewModel
            await viewModel.jugar(duracion: 3)
        }
        #expect(referencia != nil)               // sigue vivo: lo retiene su propio cronómetro
    }
}