El directo, en su propia clase

import Foundation
import Observation
import Torneo
 
// EL DIRECTO: un partido que se está jugando (gemelo del `Directo` de Android).
//
// Antes todo esto vivía dentro de `PartidoViewModel`: el reloj, los goles del guion, los «a mano» y
// el aviso de cada 15'. Se saca a su propia clase para que el partido no tenga que ser de UNA
// pantalla: un objeto que viva lo que la app puede guardarlo, y varias pantallas mirarlo a la vez.
// El ViewModel se queda fino: traduce este directo a lo que pinta la vista.
//
// No importa `SwiftUI`: se prueba sin dibujar nada. `@Observable`: cuando cambia el minuto o un gol,
// se redibujan las vistas que lo leen (aunque lo lean a través del ViewModel).
@MainActor
@Observable
final class Directo {
    let partidoId: Int
    let partido: Partido
    let duracion: Int
 
    private(set) var minuto = 0
    private(set) var corriendo = false
    private(set) var ultimoAviso = "ninguno"
    // Los goles que va marcando el guion y los que se ponen «a mano» con los botones.
    private(set) var golesEnVivo = Marcador(local: 0, visitante: 0)
    private(set) var golesAMano = Marcador(local: 0, visitante: 0)
 
    // Quien avisa de los goles (nil = nadie). Es un protocolo: en las pruebas, un espía.
    @ObservationIgnored private let notificador: (any Notificador)?
    @ObservationIgnored private let msPorMinuto: Int
    @ObservationIgnored private let eventosDelGuion: [EventoDePartido]
 
    // EL DUEÑO del cronómetro es este directo (referencia FUERTE). Ojo a la flecha inversa: el
    // cronómetro guarda una closure (`alTick`) y esa closure llama al directo. Si la closure captura
    // `self` con una referencia fuerte, hay DOS flechas fuertes que se miran: un ciclo (mira `prepararReloj`).
    @ObservationIgnored private let cronometro = Cronometro()
 
    init(
        partidoId: Int,
        partido: Partido,
        duracion: Int,
        notificador: (any Notificador)? = nil,
        msPorMinuto: Int = Configuracion.msPorMinuto,
        reintroducirElCiclo: Bool = Configuracion.cicloDelCronometro
    ) {
        self.partidoId = partidoId
        self.partido = partido
        self.duracion = duracion
        self.notificador = notificador
        self.msPorMinuto = msPorMinuto
        // Un partido de 60 minutos ignora los goles del guion posteriores al 60.
        eventosDelGuion = partido.eventos.filter { $0.minuto <= duracion }
        prepararReloj(reintroducirElCiclo: reintroducirElCiclo)
    }
 
    // `deinit` sale en el registro cuando ARC libera el directo. Si NO sale al cerrarlo, algo lo
    // retiene: es la prueba más barata de que no hay una fuga.
    deinit {
        Registro.anotar("Directo LIBERADO")
    }
 
    var marcador: Marcador {
        Marcador(local: golesEnVivo.local + golesAMano.local, visitante: golesEnVivo.visitante + golesAMano.visitante)
    }
 
    var terminado: Bool { minuto >= duracion }
 
    func golAMano(_ lado: Lado) {
        switch lado {
        case .local: golesAMano = Marcador(local: golesAMano.local + 1, visitante: golesAMano.visitante)
        case .visitante: golesAMano = Marcador(local: golesAMano.local, visitante: golesAMano.visitante + 1)
        }
    }
 
    // UN SOLO BUCLE marca el tiempo y el cronómetro solo cuenta lo que le mandan. Si lo cancelan,
    // se para donde iba; si se vuelve a llamar, SIGUE desde ese minuto (no borra goles ni repite
    // avisos). Si ya terminó, no hace nada.
    func jugar() async {
        guard !corriendo, !terminado else { return }
        corriendo = true
        while cronometro.minuto < duracion {
            do {
                try await Task.sleep(for: .milliseconds(msPorMinuto))
            } catch {
                Registro.anotar("partido CANCELADO en el minuto \(minuto)")
                corriendo = false
                return
            }
            cronometro.avanzar()   // llama a `alTick`, que llama a `alMinuto()`
        }
        corriendo = false
        Registro.anotar("partido TERMINADO en el minuto \(minuto)")
    }
 
    // EL CICLO DE RETENCIÓN EN UNA APP DE VERDAD.
    //
    //   ASÍ NO VALE:        reloj.alTick = { self.alMinuto() }
    //   BIEN:               reloj.alTick = { [weak self] in self?.alMinuto() }
    //
    // `alTick` es una propiedad del cronómetro: la closure se GUARDA. Si captura `self` fuerte, el
    // directo retiene al cronómetro y el cronómetro retiene al directo (dentro de la closure): ninguno
    // llega a contador cero, `deinit` no sale nunca y el directo de cada partido visitado se queda en
    // memoria para siempre. Se prepara en el `init`: basta con abrir un partido para que el ciclo exista.
    //
    // (El parámetro `reintroducirElCiclo` y el argumento de lanzamiento `-cicloDelCronometro YES`
    // existen SOLO para la lección del Memory Graph: vuelven a meter el bug para verlo. En una app real
    // no existiría ese `if`.)
    private func prepararReloj(reintroducirElCiclo: Bool) {
        if reintroducirElCiclo {
            cronometro.alTick = { self.alMinuto() }
        } else {
            cronometro.alTick = { [weak self] in self?.alMinuto() }
        }
    }
 
    private func alMinuto() {
        let nuevo = cronometro.minuto
        for evento in eventosDelGuion where evento.minuto == nuevo {
            golesEnVivo = golesEnVivo.despuesDe(evento, en: partido)
            // Cada gol del guion avisa (los «a mano» no: los puso el usuario, que ya lo sabe).
            if case let .gol(minutoDelGol, jugador, equipo) = evento {
                notificador?.notificarGol(minuto: minutoDelGol, jugador: jugador.nombre, equipo: equipo.nombre)
            }
        }
        minuto = nuevo
        if nuevo % 15 == 0 { ultimoAviso = "minuto \(nuevo) con \(marcador)" }
    }
}

import Foundation
import Observation
import Torneo
 
// MVVM EN SWIFTUI (gemelo del `PartidoViewModel` de Android)
//
//   Vista (SwiftUI)  ──eventos──▶  ViewModel  ──llama──▶  caso de uso / repositorio  ──▶  datos
//        ▲                            │
//        └──── estado (`uiState`) ────┘
//
// La VISTA solo pinta `uiState` y traduce toques en llamadas al ViewModel. El VIEWMODEL sabe de
// pantalla (qué se ve, en qué orden) pero NO de SwiftUI: no importa `SwiftUI`. Por eso se puede
// probar sin dibujar nada.
//
// `@MainActor`: el ViewModel es estado de INTERFAZ y SwiftUI lo lee desde el hilo principal. Con
// esta anotación el compilador impide tocarlo desde otro hilo sin `await`. En un proyecto de
// Xcode 26 el aislamiento a MainActor ya es el valor por defecto de TODO el módulo, así que aquí es
// redundante; se escribe igualmente porque dice la intención y porque en el paquete `Torneo` (que no
// lo tiene por defecto) sí haría falta. Comparado con Android: `Dispatchers.Main` + `viewModelScope`.
//
// EL VIEWMODEL, FINO. El reloj, los goles y el aviso viven en `Directo`; este ViewModel lo crea, lo
// traduce a `uiState` y le pasa los toques. Las vistas siguen sin saber que existe el directo.
@MainActor
@Observable
final class PartidoViewModel {
    let partidoId: Int
 
    // ---- estado (lo lee la vista; solo este ViewModel lo escribe) ----
    private(set) var directo: Directo?
    private(set) var mensajeDeError: String?
 
    // ---- dependencias (llegan por el constructor: nadie las crea a escondidas) ----
    @ObservationIgnored private let repositorio: any PartidosRepositorio
    @ObservationIgnored private let registrarGol: RegistrarGol
    @ObservationIgnored private let msPorMinuto: Int
    @ObservationIgnored private let reintroducirElCiclo: Bool
    // Quien avisa de los goles (nil = nadie). Se lo pasa al directo.
    @ObservationIgnored private let notificador: (any Notificador)?
 
    init(
        partidoId: Int,
        repositorio: any PartidosRepositorio,
        notificador: (any Notificador)? = nil,
        msPorMinuto: Int = Configuracion.msPorMinuto,
        reintroducirElCiclo: Bool = Configuracion.cicloDelCronometro
    ) {
        self.partidoId = partidoId
        self.repositorio = repositorio
        self.registrarGol = RegistrarGol(repositorio: repositorio)
        self.notificador = notificador
        self.msPorMinuto = msPorMinuto
        self.reintroducirElCiclo = reintroducirElCiclo
        cargar(duracion: Ajustes.duracionPorDefecto)
    }
 
    // `deinit` sale en el registro cuando ARC libera el ViewModel.
    deinit {
        Registro.anotar("PartidoViewModel LIBERADO")
    }
 
    // ---- lo que ve la pantalla ----
    var uiState: MarcadorUiState {
        if let mensajeDeError { return .error(mensajeDeError) }
        guard let directo else { return .cargando }
        return .exito(.init(
            partidoId: partidoId, partido: directo.partido, marcador: directo.marcador, minuto: directo.minuto,
            corriendo: directo.corriendo, ultimoAviso: directo.ultimoAviso, duracion: directo.duracion
        ))
    }
 
    // ---- eventos de la pantalla ----
    func alGol(_ lado: Lado) {
        guard let directo else { return }
        // Se ve al instante en el directo Y se guarda con el caso de uso.
        directo.golAMano(lado)
        if case let .failure(fallo) = registrarGol(partidoId: partidoId, lado: lado, minuto: directo.minuto) {
            Registro.anotar("no se pudo registrar el gol: \(fallo)")
        }
    }
 
    // La vista la llama desde `.task(id: duración)`: se cancela sola al irse la pantalla.
    // `.task` se CANCELA cuando otra pantalla se apila encima (Goleadores) y se RELANZA al volver, pero el
    // ViewModel (y su directo) siguen vivos: si la duración no cambió, `jugar` SIGUE donde iba. Solo hace
    // un directo nuevo si cambia la duración.
    func jugar(duracion nueva: Int) async {
        if directo?.duracion != nueva { cargar(duracion: nueva) }
        await directo?.jugar()
    }
 
    // Leer el partido del repositorio y preparar un directo sin empezar.
    private func cargar(duracion: Int) {
        guard let partido = repositorio.partido(id: partidoId) else {
            directo = nil
            mensajeDeError = "No existe el partido n.º \(partidoId)"
            return
        }
        mensajeDeError = nil
        directo = Directo(
            partidoId: partidoId, partido: partido, duracion: duracion,
            notificador: notificador, msPorMinuto: msPorMinuto, reintroducirElCiclo: reintroducirElCiclo
        )
    }
}

import Testing
import Torneo
@testable import MarcadorApp
 
// Pruebas del directo: el reloj, los goles del guion, los avisos y la memoria. Antes eran del
// ViewModel; se mudaron con el código. `@MainActor`: el directo lo es.
@MainActor
struct DirectoTests {
 
    private func directo(
        duracion: Int = 90, notificador: (any Notificador)? = nil, msPorMinuto: Int = 0, ciclo: Bool = false
    ) -> Directo {
        Directo(
            partidoId: 1, partido: Ejemplo.rayoContraToros, duracion: duracion,
            notificador: notificador, msPorMinuto: msPorMinuto, reintroducirElCiclo: ciclo
        )
    }
 
    @Test func jugarAplicaLosGolesDelGuion() async {
        let directo = directo()
        await directo.jugar()
        #expect(directo.marcador == Marcador(local: 2, visitante: 1))
        #expect(directo.minuto == 90)
        #expect(!directo.corriendo)
        #expect(directo.terminado)
        #expect(directo.ultimoAviso == "minuto 90 con 2-1")
    }
 
    @Test func unPartidoDeSesentaMinutosIgnoraElGolDelMinutoOchenta() async {
        let directo = directo(duracion: 60)
        await directo.jugar()
        #expect(directo.marcador == Marcador(local: 1, visitante: 1))
    }
 
    @Test func cancelarLaTareaDetieneElPartido() async {
        let directo = directo(msPorMinuto: 20)
        let tarea = Task { await directo.jugar() }
        try? await Task.sleep(for: .milliseconds(150))
        tarea.cancel()
        await tarea.value
        #expect(directo.minuto < 90)
        #expect(!directo.corriendo)
    }
 
    // LA PRUEBA DEL CICLO. Con `[weak self]` el directo se libera en cuanto se suelta...
    @Test func elDirectoSeLiberaAlSoltarlo() async {
        weak var referencia: Directo?
        do {
            let directo = directo(duracion: 3)
            referencia = directo
            await directo.jugar()
        }
        #expect(referencia == nil)
    }
 
    // ...y con el ciclo reintroducido, NO: `referencia` sigue viva aunque nadie tenga el directo.
    // (Este objeto se queda en memoria hasta que termina el proceso de pruebas: es la fuga.)
    @Test func conElCicloReintroducidoElDirectoSeQuedaEnMemoria() async {
        weak var referencia: Directo?
        do {
            let directo = directo(duracion: 3, ciclo: true)
            referencia = directo
            await directo.jugar()
        }
        #expect(referencia != nil)
    }
 
    // Cada gol del guion avisa: goles de Ana (12), Iván (55) y Ana (80).
    @Test func cadaGolDelGuionAvisaAlNotificador() async {
        let espia = NotificadorEspia()
        let directo = directo(notificador: espia)
        await directo.jugar()
        #expect(espia.avisos.map(\.minuto) == [12, 55, 80])
        #expect(espia.avisos.map(\.jugador) == ["Ana", "Iván", "Ana"])
        #expect(espia.avisos.first?.equipo == "Rayo FC")
    }
 
    // Los goles «a mano» no avisan, y un partido de 60 minutos no avisa del gol del minuto 80.
    @Test func losGolesAManoNoAvisanYLosPosterioresALaDuracionTampoco() async {
        let espia = NotificadorEspia()
        let directo = directo(duracion: 60, notificador: espia)
        directo.golAMano(.local)
        #expect(espia.avisos.isEmpty)
        await directo.jugar()
        #expect(espia.avisos.map(\.minuto) == [12, 55])
    }
}

import Testing
import Torneo
@testable import MarcadorApp
 
// Pruebas del ViewModel con el repositorio en memoria (en las otras pruebas, un falso).
// `@MainActor`: el ViewModel lo es, y el target de pruebas no tiene el aislamiento por defecto.
@MainActor
struct PartidoViewModelTests {
 
    // El repositorio es un FALSO (ver `Dobles.swift`): sin disco y con los goles anotados.
    private func repositorio() -> RepositorioFalso { RepositorioFalso() }
 
    @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.directo?.marcador == Marcador(local: 0, visitante: 1))
        // El falso anotó UN gol, del equipo visitante, con el jugador que tocaba por turno
        // (Toros lleva 1 gol de 2 jugadores: le toca el índice 1, Sofía).
        #expect(repo.golesRegistrados.count == 1)
        #expect(repo.golesRegistrados.first?.partidoId == 1)
        guard case let .gol(minuto, jugador, equipo)? = repo.golesRegistrados.first?.gol else {
            Issue.record("Se esperaba un gol")
            return
        }
        #expect(minuto == 0)
        #expect(jugador.nombre == "Sofía")
        #expect(equipo == Ejemplo.toros)
    }
 
    // El ViewModel pregunta por SU partido, no por otro.
    @Test func elViewModelPideAlRepositorioSuPartido() {
        let repo = repositorio()
        _ = PartidoViewModel(partidoId: 1, repositorio: repo, msPorMinuto: 0)
        #expect(repo.consultas == [1])
    }
 
}

import XCTest
import Torneo
@testable import MarcadorApp
 
// LAS MISMAS PRUEBAS, EN XCTEST (el marco anterior a Swift Testing, de 2014).
//
// Es lo que vas a encontrar en casi todo el código que ya existe, y sigue siendo OBLIGATORIO para
// las pruebas de UI y de rendimiento. Diferencias con Swift Testing (`PartidoViewModelTests` y `DirectoTests`):
//
//   Swift Testing                     XCTest
//   struct + @Test                    clase que hereda de XCTestCase; el método debe EMPEZAR por `test`
//   #expect(a == b)                   XCTAssertEqual(a, b)   (una función por tipo de comprobación)
//   Issue.record("…")                 XCTFail("…")
//   init() / deinit                   setUp() / tearDown()   (una instancia NUEVA por prueba, en los dos)
//   @Test(arguments: […])             no hay: se escribe un bucle o varias pruebas
//   se ejecutan en paralelo           en serie por defecto
//
// `@MainActor` en la clase: el ViewModel lo es (en XCTest, además, `setUp` y los `test…` heredan el aislamiento de la clase).
@MainActor
final class PartidoViewModelXCTests: XCTestCase {
    var repositorio: RepositorioFalso!
 
    override func setUp() async throws {
        repositorio = RepositorioFalso()
    }
 
    func testJugarAplicaLosGolesDelGuion() async {
        let directo = Directo(partidoId: 1, partido: Ejemplo.rayoContraToros, duracion: 90, msPorMinuto: 0)
        await directo.jugar()
        XCTAssertEqual(directo.marcador, Marcador(local: 2, visitante: 1))
        XCTAssertEqual(directo.minuto, 90)
        XCTAssertFalse(directo.corriendo)
    }
 
    func testUnPartidoQueNoExisteDaUnEstadoDeError() {
        let viewModel = PartidoViewModel(partidoId: 99, repositorio: repositorio, msPorMinuto: 0)
        XCTAssertEqual(viewModel.uiState, .error("No existe el partido n.º 99"))
    }
 
    func testElViewModelSeLiberaAlSoltarlo() async {
        weak var referencia: PartidoViewModel?
        do {
            let viewModel = PartidoViewModel(partidoId: 1, repositorio: repositorio, msPorMinuto: 0)
            referencia = viewModel
        }
        XCTAssertNil(referencia)
    }
 
    // XCTest trae MEDICIÓN de rendimiento (`measure`), que Swift Testing no tiene: ejecuta el bloque
    // varias veces y compara con una línea base. Aquí, jugar 90 minutos sin esperas.
    func testRendimientoDeJugarUnPartidoEntero() {
        measure {
            let directo = Directo(partidoId: 1, partido: Ejemplo.rayoContraToros, duracion: 90, msPorMinuto: 0)
            let terminado = expectation(description: "el partido termina")
            Task { @MainActor in
                await directo.jugar()
                terminado.fulfill()
            }
            wait(for: [terminado], timeout: 10)
        }
    }
}