import 'dart:async';

import 'package:flutter/foundation.dart';

import '../modelos/alarma_musical.dart';
import '../servicios/servicio_alarmas.dart';
import '../servicios/servicio_alarmas_android.dart';

class EstadoAlarmas extends ChangeNotifier {
  EstadoAlarmas({
    ServicioAlarmas? servicio,
    PuertoAlarmasAndroid? android,
    bool iniciarAutomaticamente = true,
  }) : servicio = servicio ?? ServicioAlarmas(),
       android = android ?? ServicioAlarmasAndroid() {
    if (iniciarAutomaticamente) {
      inicializar();
    }
  }

  final ServicioAlarmas servicio;
  final PuertoAlarmasAndroid android;

  List<AlarmaMusical> _alarmas = [];
  List<RangoVacaciones> _vacaciones = [];
  List<ExcepcionAlarma> _excepciones = [];
  DiagnosticoAlarmasAndroid? _diagnostico;
  Timer? _refresco;
  Timer? _vigilancia;
  final _alarmasVencidasController =
      StreamController<AlarmaMusical>.broadcast();
  final Set<String> _ejecucionesEmitidas = {};
  static const _margenDisparoLocal = Duration(seconds: 45);
  bool _cargando = false;
  String? _error;

  List<AlarmaMusical> get alarmas => List.unmodifiable(_alarmas);
  List<RangoVacaciones> get vacaciones => List.unmodifiable(_vacaciones);
  List<ExcepcionAlarma> get excepciones => List.unmodifiable(_excepciones);
  DiagnosticoAlarmasAndroid? get diagnostico => _diagnostico;
  bool get cargando => _cargando;
  String? get error => _error;
  Stream<AlarmaMusical> get alarmasVencidasStream =>
      _alarmasVencidasController.stream;

  AlarmaMusical? get proximaAlarma {
    final candidatas =
        _alarmas.where((a) => a.activa && a.proximaProgramable != null).toList()
          ..sort(
            (a, b) => a.proximaProgramable!.compareTo(b.proximaProgramable!),
          );
    return candidatas.isEmpty ? null : candidatas.first;
  }

  Future<void> inicializar() async {
    debugPrint('[PluriWave][alarmas] inicializar');
    _cargando = true;
    _error = null;
    notifyListeners();
    try {
      final config = await servicio.recalcularTodas();
      _aplicar(config);
      debugPrint(
        '[PluriWave][alarmas] cargadas=${_alarmas.length} vacaciones=${_vacaciones.length} excepciones=${_excepciones.length}',
      );
      await _sincronizarTodas();
      await cargarDiagnostico();
      _activarRefresco();
    } catch (e) {
      _error = 'No se pudieron cargar las alarmas: $e';
      debugPrint('[PluriWave][alarmas] inicializar ERROR $e');
    } finally {
      _cargando = false;
      notifyListeners();
    }
  }

  Future<void> guardarAlarma(AlarmaMusical alarma) async {
    debugPrint(
      '[PluriWave][alarmas] guardar id=${alarma.id} activa=${alarma.activa} hora=${alarma.hora}:${alarma.minuto} tipo=${alarma.tipoProgramacion.name}',
    );
    final config = await servicio.guardarAlarma(alarma);
    _aplicar(config);
    try {
      final guardada = _alarmas.firstWhere((a) => a.id == alarma.id);
      debugPrint(
        '[PluriWave][alarmas] guardada id=${guardada.id} proxima=${guardada.proximaEjecucion?.toIso8601String()}',
      );
      await android.programar(guardada);
    } catch (e) {
      _error = 'Alarma guardada, pero Android no pudo programarla todavía: $e';
    }
    notifyListeners();
  }

  Future<void> refrescarProgramacion() async {
    debugPrint('[PluriWave][alarmas] refrescar programacion');
    final config = await servicio.recalcularTodas();
    _aplicar(config);
    debugPrint(
      '[PluriWave][alarmas] proxima tras refrescar=${proximaAlarma?.id} ${proximaAlarma?.proximaEjecucion?.toIso8601String()}',
    );
    await _sincronizarTodas();
    notifyListeners();
  }

  Future<void> cargarPersistidasSinRecalcular() async {
    final config = await servicio.cargar();
    _aplicar(config);
    notifyListeners();
  }

  void marcarEjecucionGestionada(AlarmaMusical alarma) {
    final proxima = alarma.proximaProgramable;
    if (proxima == null) return;
    final key = '${alarma.id}:${proxima.millisecondsSinceEpoch}';
    _ejecucionesEmitidas.add(key);
    debugPrint(
      '[PluriWave][alarmas] ejecucion gestionada id=${alarma.id} proxima=${proxima.toIso8601String()}',
    );
  }

  Future<void> eliminarAlarma(String id) async {
    debugPrint('[PluriWave][alarmas] eliminar id=$id');
    final config = await servicio.eliminarAlarma(id);
    _aplicar(config);
    await android.detenerSonidoNativo(id);
    await android.cancelar(id);
    notifyListeners();
  }

  Future<void> cambiarActiva(AlarmaMusical alarma, bool activa) async {
    await guardarAlarma(alarma.copyWith(activa: activa));
  }

  Future<void> saltarProxima(String alarmaId) async {
    debugPrint('[PluriWave][alarmas] saltar proxima id=$alarmaId');
    final config = await servicio.saltarProxima(alarmaId);
    _aplicar(config);
    AlarmaMusical? alarma;
    for (final item in _alarmas) {
      if (item.id == alarmaId) {
        alarma = item;
        break;
      }
    }
    if (alarma != null) {
      await android.programar(alarma);
    }
    notifyListeners();
  }

  Future<void> guardarVacaciones(List<RangoVacaciones> vacaciones) async {
    debugPrint(
      '[PluriWave][alarmas] guardar vacaciones count=${vacaciones.length}',
    );
    final config = await servicio.guardarVacaciones(vacaciones);
    _aplicar(config);
    await _sincronizarTodas();
    notifyListeners();
  }

  Future<void> posponerAlarma(AlarmaMusical alarma, int minutos) async {
    final ejecucion =
        alarma.snoozeOrigen ?? alarma.proximaEjecucion ?? DateTime.now();
    debugPrint(
      '[PluriWave][alarmas] posponer id=${alarma.id} minutos=$minutos ejecucion=${ejecucion.toIso8601String()}',
    );
    await android.ocultarNotificacionAlarma(alarma.id);
    final config = await servicio.posponerEjecucion(
      alarma.id,
      ejecucion,
      minutos,
    );
    _aplicar(config);
    final actualizada = _buscarAlarma(alarma.id);
    if (actualizada != null) {
      await android.programar(actualizada);
    }
    notifyListeners();
  }

  Future<void> posponerProximaDesdePreaviso(
    AlarmaMusical alarma,
    int minutos,
    DateTime ejecucion,
  ) async {
    final seguros = _snoozeSeguro(minutos);
    final snoozeHasta = ejecucion.add(Duration(minutes: seguros));
    debugPrint(
      '[PluriWave][alarmas] posponer desde preaviso id=${alarma.id} minutos=$seguros ejecucion=${ejecucion.toIso8601String()} hasta=${snoozeHasta.toIso8601String()}',
    );
    await android.ocultarNotificacionAlarma(alarma.id);
    final config = await servicio.posponerEjecucionHasta(
      alarma.id,
      ejecucion,
      snoozeHasta,
    );
    _aplicar(config);
    final actualizada = _buscarAlarma(alarma.id);
    if (actualizada != null) {
      await android.programar(actualizada);
    }
    notifyListeners();
  }

  Future<void> finalizarEjecucion(String alarmaId) async {
    debugPrint('[PluriWave][alarmas] finalizar ejecucion id=$alarmaId');
    final alarma = _buscarAlarma(alarmaId);
    final ejecucion =
        alarma?.snoozeOrigen ??
        alarma?.proximaEjecucion ??
        alarma?.snoozeHasta ??
        DateTime.now();
    await android.ocultarNotificacionAlarma(alarmaId);
    final config = await servicio.completarEjecucion(alarmaId, ejecucion);
    _aplicar(config);
    await _sincronizarTodas();
    notifyListeners();
  }

  Future<void> crearRangoVacaciones(RangoVacaciones rango) async {
    final nuevos = [..._vacaciones, rango];
    await guardarVacaciones(nuevos);
  }

  Future<void> eliminarRangoVacaciones(String id) async {
    final nuevos = _vacaciones.where((v) => v.id != id).toList();
    await guardarVacaciones(nuevos);
  }

  ExcepcionAlarma? ultimaExcepcionPara(String alarmaId) {
    final candidatas =
        _excepciones.where((e) => e.alarmaId == alarmaId).toList()
          ..sort((a, b) => b.ejecucion.compareTo(a.ejecucion));
    return candidatas.isEmpty ? null : candidatas.first;
  }

  Future<void> cargarDiagnostico() async {
    try {
      _diagnostico = await android.diagnostico();
    } catch (e) {
      debugPrint('[PluriWave][alarmas] diagnostico ERROR $e');
      _diagnostico = null;
    }
    notifyListeners();
  }

  Future<void> _sincronizarTodas() async {
    debugPrint(
      '[PluriWave][alarmas] sincronizar todas count=${_alarmas.length}',
    );
    for (final alarma in _alarmas) {
      await android.programar(alarma);
    }
  }

  AlarmaMusical? _buscarAlarma(String id) {
    for (final alarma in _alarmas) {
      if (alarma.id == id) return alarma;
    }
    return null;
  }

  int _snoozeSeguro(int minutos) =>
      minutos == 3 || minutos == 5 || minutos == 10 ? minutos : 5;

  void _aplicar(ConfiguracionAlarmas config) {
    _alarmas = config.alarmas;
    _vacaciones = config.vacaciones;
    _excepciones = config.excepciones;
  }

  void _activarRefresco() {
    _refresco?.cancel();
    _refresco = Timer.periodic(const Duration(minutes: 1), (_) {
      refrescarProgramacion();
    });
    _vigilarAlarmasVencidas();
    _vigilancia?.cancel();
    _vigilancia = Timer.periodic(const Duration(seconds: 10), (_) {
      _vigilarAlarmasVencidas();
    });
  }

  void _vigilarAlarmasVencidas() {
    final ahora = DateTime.now();
    for (final alarma in _alarmas) {
      final proxima = alarma.proximaProgramable;
      if (!alarma.activa || proxima == null) continue;
      if (proxima.isAfter(ahora)) continue;
      final key = '${alarma.id}:${proxima.millisecondsSinceEpoch}';
      final retraso = ahora.difference(proxima);
      if (retraso > _margenDisparoLocal) {
        _ejecucionesEmitidas.add(key);
        debugPrint(
          '[PluriWave][alarmas] vencida local ignorada por antigua id=${alarma.id} proxima=${proxima.toIso8601String()} retraso=${retraso.inSeconds}s',
        );
        continue;
      }
      if (_ejecucionesEmitidas.add(key)) {
        debugPrint(
          '[PluriWave][alarmas] vencida local id=${alarma.id} proxima=${proxima.toIso8601String()}',
        );
        _alarmasVencidasController.add(alarma);
      }
    }
  }

  @override
  void dispose() {
    _refresco?.cancel();
    _vigilancia?.cancel();
    _alarmasVencidasController.close();
    super.dispose();
  }
}