pluriwave/test/estado/estado_radio_test.dart

import 'dart:convert';
import 'dart:io';

import 'package:flutter_test/flutter_test.dart';
import 'package:pluriwave/estado/estado_radio.dart';
import 'package:pluriwave/modelos/preset_ecualizador.dart';

import '../helpers/fakes.dart';

void main() {
  group('EstadoRadio integración de custom + EQ persistente', () {
    test('incluye emisoras custom en el listado principal de inicio', () async {
      final archivo = await _crearArchivoCustom([
        emisoraDemo(uuid: 'custom-1', nombre: 'Custom Uno'),
      ]);
      final estado = EstadoRadio(
        audio: FakeServicioAudio(),
        favoritos: FakeServicioFavoritos(),
        radio: FakeServicioRadio(
          populares: [emisoraDemo(uuid: 'api-1', nombre: 'API Uno')],
        ),
        servicioEcualizador: FakeServicioEcualizador(),
        resolverArchivoCustom: () async => archivo,
        iniciarAutomaticamente: false,
      );

      await estado.inicializar();

      expect(
        estado.emisorasInicio.map((e) => e.uuid).toList(),
        equals(['custom-1', 'api-1']),
      );
    });

    test('carga EQ principal persistido antes de decidir EQ de reproducción',
        () async {
      final audio = FakeServicioAudio();
      final principal = PresetEcualizador.rock;
      final emisora = emisoraDemo(uuid: 'api-1', nombre: 'API Uno');
      final estado = EstadoRadio(
        audio: audio,
        favoritos: FakeServicioFavoritos(),
        radio: FakeServicioRadio(populares: [emisora]),
        servicioEcualizador: FakeServicioEcualizador(principal: principal),
        resolverArchivoCustom: _archivoCustomVacio,
        iniciarAutomaticamente: false,
      );

      await estado.inicializar();
      await estado.reproducir(emisora);

      expect(estado.presetEcualizador, principal);
      expect(audio.presetsAplicados.first, principal);
      expect(audio.presetsAplicados.last, principal);
    });

    test('mantiene EQ persistido aunque el ecualizador nativo no esté disponible',
        () async {
      final principal = PresetEcualizador.jazz;
      final porEmisora = {'fav-1': PresetEcualizador.rock};
      final estado = EstadoRadio(
        audio: FakeServicioAudio(ecualizadorActivo: false),
        favoritos: FakeServicioFavoritos(),
        radio: FakeServicioRadio(),
        servicioEcualizador: FakeServicioEcualizador(
          principal: principal,
          porEmisora: porEmisora,
        ),
        resolverArchivoCustom: _archivoCustomVacio,
        iniciarAutomaticamente: false,
      );

      await estado.inicializar();

      expect(estado.ecualizadorDisponible, isFalse);
      expect(estado.presetEcualizador, principal);
      expect(estado.presetPrincipalEcualizador, principal);
      expect(
        estado.presetEcualizadorPorEmisora('fav-1'),
        PresetEcualizador.rock,
      );
    });

    test(
        'inicializar deja error tras fallo y cargarPopulares manual recupera estaciones',
        () async {
      final radio = FakeServicioRadio(
        erroresPopularesPorLlamada: [Exception('sin red')],
        popularesPorLlamada: [
          const [],
          [emisoraDemo(uuid: 'api-ok', nombre: 'API Recuperada')],
        ],
        tendenciasPorLlamada: [
          const [],
          [emisoraDemo(uuid: 'trend-ok', nombre: 'Trend Recuperada')],
        ],
      );
      final estado = EstadoRadio(
        audio: FakeServicioAudio(),
        favoritos: FakeServicioFavoritos(),
        radio: radio,
        servicioEcualizador: FakeServicioEcualizador(),
        resolverArchivoCustom: _archivoCustomVacio,
        iniciarAutomaticamente: false,
      );

      await estado.inicializar();
      expect(estado.error, 'Sin conexión a la API de radio');

      await estado.cargarPopulares();

      expect(estado.error, isNull);
      expect(estado.populares.map((e) => e.uuid), contains('api-ok'));
      expect(estado.tendencias.map((e) => e.uuid), contains('trend-ok'));
      expect(radio.obtenerPopularesCalls, 2);
    });

    test('EQ propio por emisora pisa al principal y puede volver a fallback',
        () async {
      final audio = FakeServicioAudio();
      final favoritos = FakeServicioFavoritos();
      final emisora = emisoraDemo(uuid: 'fav-1', nombre: 'Favorita');
      final principal = PresetEcualizador.pop;
      final propio = PresetEcualizador.jazz;
      await favoritos.agregar(emisora);

      final estado = EstadoRadio(
        audio: audio,
        favoritos: favoritos,
        radio: FakeServicioRadio(populares: [emisora]),
        servicioEcualizador: FakeServicioEcualizador(principal: principal),
        resolverArchivoCustom: _archivoCustomVacio,
        iniciarAutomaticamente: false,
      );

      await estado.inicializar();
      await estado.cargarFavoritos();
      await estado.guardarPresetEcualizadorPorEmisora(emisora.uuid, propio);

      await estado.reproducir(emisora);
      expect(estado.presetEcualizador, propio);
      expect(audio.presetsAplicados.last, propio);

      await estado.deshabilitarPresetEcualizadorPorEmisora(emisora.uuid);
      await estado.reproducir(emisora);
      expect(estado.presetEcualizador, principal);
      expect(audio.presetsAplicados.last, principal);
    });

    test('favorita sin EQ propio usa EQ principal desde el primer play', () async {
      final audio = FakeServicioAudio();
      final favoritos = FakeServicioFavoritos();
      final emisora = emisoraDemo(uuid: 'fav-main', nombre: 'Favorita Main');
      final principal = PresetEcualizador.voz;
      await favoritos.agregar(emisora);

      final estado = EstadoRadio(
        audio: audio,
        favoritos: favoritos,
        radio: FakeServicioRadio(populares: [emisora]),
        servicioEcualizador: FakeServicioEcualizador(principal: principal),
        resolverArchivoCustom: _archivoCustomVacio,
        iniciarAutomaticamente: false,
      );

      await estado.inicializar();
      await estado.cargarFavoritos();
      await estado.reproducir(emisora);

      expect(estado.tienePresetEcualizadorPorEmisora(emisora.uuid), isFalse);
      expect(estado.presetEcualizador, principal);
      expect(audio.presetsAplicados.last, principal);
    });
  });
}

Future<File> _archivoCustomVacio() async => _crearArchivoCustom(const []);

Future<File> _crearArchivoCustom(List<dynamic> emisoras) async {
  final dir = await Directory.systemTemp.createTemp('pluriwave-test-');
  final archivo = File('${dir.path}/emisoras_custom.json');
  await archivo.writeAsString(jsonEncode(emisoras.map((e) => e.toMap()).toList()));
  return archivo;
}