pluriwave/lib/servicios/servicio_ecualizador.dart

import 'dart:convert';

import 'package:shared_preferences/shared_preferences.dart';

import '../modelos/preset_ecualizador.dart';

class ConfiguracionEcualizador {
  const ConfiguracionEcualizador({
    required this.principal,
    required this.porEmisora,
  });

  final PresetEcualizador principal;
  final Map<String, PresetEcualizador> porEmisora;
}

class ServicioEcualizador {
  static const _keyPresetPrincipal = 'eq_preset_principal_v1';
  static const _keyPresetsPorEmisora = 'eq_presets_por_emisora_v1';

  Future<ConfiguracionEcualizador> cargar() async {
    final prefs = await SharedPreferences.getInstance();
    final principal = _leerPresetPrincipal(prefs);
    final porEmisora = _leerPresetsPorEmisora(prefs);
    return ConfiguracionEcualizador(
      principal: principal,
      porEmisora: porEmisora,
    );
  }

  Future<void> guardarPrincipal(PresetEcualizador preset) async {
    final prefs = await SharedPreferences.getInstance();
    await prefs.setString(_keyPresetPrincipal, jsonEncode(preset.toJson()));
  }

  Future<void> guardarPorEmisora(String uuid, PresetEcualizador preset) async {
    final prefs = await SharedPreferences.getInstance();
    final mapa = _leerPresetsPorEmisora(prefs);
    mapa[uuid] = preset;
    await _guardarPresetsPorEmisora(prefs, mapa);
  }

  Future<void> eliminarPorEmisora(String uuid) async {
    final prefs = await SharedPreferences.getInstance();
    final mapa = _leerPresetsPorEmisora(prefs);
    mapa.remove(uuid);
    await _guardarPresetsPorEmisora(prefs, mapa);
  }

  Future<void> guardarConfiguracion(ConfiguracionEcualizador config) async {
    final prefs = await SharedPreferences.getInstance();
    await prefs.setString(
      _keyPresetPrincipal,
      jsonEncode(config.principal.toJson()),
    );
    await _guardarPresetsPorEmisora(prefs, config.porEmisora);
  }

  PresetEcualizador _leerPresetPrincipal(SharedPreferences prefs) {
    final raw = prefs.getString(_keyPresetPrincipal);
    if (raw == null || raw.isEmpty) {
      return PresetEcualizador.flat;
    }
    try {
      return PresetEcualizador.desdeJson(
        Map<String, dynamic>.from(jsonDecode(raw) as Map),
      );
    } catch (_) {
      return PresetEcualizador.flat;
    }
  }

  Map<String, PresetEcualizador> _leerPresetsPorEmisora(
    SharedPreferences prefs,
  ) {
    final raw = prefs.getString(_keyPresetsPorEmisora);
    if (raw == null || raw.isEmpty) {
      return {};
    }
    try {
      final data = Map<String, dynamic>.from(jsonDecode(raw) as Map);
      return data.map(
        (uuid, preset) => MapEntry(
          uuid,
          PresetEcualizador.desdeJson(
            Map<String, dynamic>.from(preset as Map),
          ),
        ),
      );
    } catch (_) {
      return {};
    }
  }

  Future<void> _guardarPresetsPorEmisora(
    SharedPreferences prefs,
    Map<String, PresetEcualizador> mapa,
  ) async {
    final serializado = mapa.map(
      (uuid, preset) => MapEntry(uuid, preset.toJson()),
    );
    await prefs.setString(_keyPresetsPorEmisora, jsonEncode(serializado));
  }
}