pluriwave/test/estado/estado_ecualizador_presets_personalizados_test.dart

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

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

/// WU13 task 13.7 — `EstadoEcualizador`'s new custom-preset members
/// (`presetsPersonalizados`, `guardarPresetPersonalizado`,
/// `eliminarPresetPersonalizado`), reading/writing only through the new
/// `ServicioPresetsPersonalizados` (design ADR-5 hazard box).
///
/// **Correction found at apply time, deliberate**: this is a NEW file, not
/// an addition to `estado_ecualizador_test.dart`. That file is one of the
/// three EQ test files this change's master guard requires to pass
/// **unmodified** — it is exercised ~30 times via `cargarPersistido()`
/// using Fakes for `servicio`/`dispositivoAudio` ONLY, with no
/// SharedPreferences awareness anywhere in the file. Because of that,
/// `cargarPersistido()` itself is intentionally left untouched by this WU
/// (see `cargarPresetsPersonalizados` below) rather than folding a third,
/// always-real-by-default collaborator into a method exercised by a file
/// that must never change.
void main() {
  EstadoEcualizador buildEq({FakeServicioPresetsPersonalizados? servicio}) {
    return EstadoEcualizador(
      audio: FakeServicioAudio(),
      servicio: FakeServicioEcualizador(),
      presetsPersonalizadosService:
          servicio ?? FakeServicioPresetsPersonalizados(),
    );
  }

  test('presetsPersonalizados starts empty before loading', () {
    final eq = buildEq();

    expect(eq.presetsPersonalizados, isEmpty);
    eq.dispose();
  });

  test(
    'cargarPresetsPersonalizados populates presetsPersonalizados from the service',
    () async {
      final fakeServicio = FakeServicioPresetsPersonalizados();
      final preexistente = PresetEcualizador(
        nombre: 'Ya guardado',
        bandas: [1, 2, 3, 4, 5],
      );
      await fakeServicio.guardar(preexistente);
      final eq = buildEq(servicio: fakeServicio);

      await eq.cargarPresetsPersonalizados();

      expect(eq.presetsPersonalizados, hasLength(1));
      expect(eq.presetsPersonalizados.single.nombre, equals('Ya guardado'));
      eq.dispose();
    },
  );

  test(
    'guardarPresetPersonalizado saves the CURRENT effective preset bands under the given name',
    () async {
      final eq = buildEq();
      await eq.cambiarPreset(PresetEcualizador.jazz);

      final guardado = await eq.guardarPresetPersonalizado('Mi preset');

      expect(guardado, isTrue);
      expect(eq.presetsPersonalizados, hasLength(1));
      expect(eq.presetsPersonalizados.single.nombre, equals('Mi preset'));
      expect(
        eq.presetsPersonalizados.single.bandas,
        equals(PresetEcualizador.jazz.bandas),
      );
      eq.dispose();
    },
  );

  test('guardarPresetPersonalizado notifies listeners on success', () async {
    final eq = buildEq();
    var avisos = 0;
    eq.addListener(() => avisos++);

    await eq.guardarPresetPersonalizado('Preset con nombre');

    expect(avisos, greaterThanOrEqualTo(1));
    eq.dispose();
  });

  test(
    'guardarPresetPersonalizado rejects an empty name: no save, returns false',
    () async {
      final eq = buildEq();

      final guardado = await eq.guardarPresetPersonalizado('');

      expect(guardado, isFalse);
      expect(eq.presetsPersonalizados, isEmpty);
      eq.dispose();
    },
  );

  test(
    'guardarPresetPersonalizado rejects a whitespace-only name: no save, returns false',
    () async {
      final eq = buildEq();

      final guardado = await eq.guardarPresetPersonalizado('   ');

      expect(guardado, isFalse);
      expect(eq.presetsPersonalizados, isEmpty);
      eq.dispose();
    },
  );

  test(
    'guardarPresetPersonalizado trims surrounding whitespace from a valid name',
    () async {
      final eq = buildEq();

      final guardado = await eq.guardarPresetPersonalizado('  Con espacios  ');

      expect(guardado, isTrue);
      expect(eq.presetsPersonalizados.single.nombre, equals('Con espacios'));
      eq.dispose();
    },
  );

  test(
    'eliminarPresetPersonalizado removes a previously saved preset',
    () async {
      final eq = buildEq();
      await eq.guardarPresetPersonalizado('Para borrar');
      expect(eq.presetsPersonalizados, hasLength(1));

      await eq.eliminarPresetPersonalizado('Para borrar');

      expect(eq.presetsPersonalizados, isEmpty);
      eq.dispose();
    },
  );

  test(
    'guardarPresetPersonalizado reads/writes only through the injected service '
    '(never touches ServicioEcualizador)',
    () async {
      final fakeEcualizador = FakeServicioEcualizador();
      final eq = EstadoEcualizador(
        audio: FakeServicioAudio(),
        servicio: fakeEcualizador,
        presetsPersonalizadosService: FakeServicioPresetsPersonalizados(),
      );

      await eq.guardarPresetPersonalizado('Aislado');

      // ServicioEcualizador's own config is completely untouched by the
      // custom-preset save — it lives in a separate service (ADR-5 hazard
      // box), not folded into servicio_ecualizador.dart's persistence.
      expect(fakeEcualizador.config.porEmisora, isEmpty);
      eq.dispose();
    },
  );
}