import 'dart:async';
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import 'estado/estado_radio.dart';
import 'estado/estado_alarmas.dart';
import 'estado/estado_idioma.dart';
import 'l10n/gen/app_localizations.dart';
import 'modelos/alarma_musical.dart';
import 'pantallas/pantalla_alarmas.dart';
import 'pantallas/pantalla_alarma_sonando.dart';
import 'pantallas/pantalla_inicio.dart';
import 'pantallas/pantalla_buscar.dart';
import 'pantallas/pantalla_favoritos.dart';
import 'pantallas/pantalla_ajustes.dart';
import 'tema/pluriwave_theme.dart';
import 'widgets/pluri_bottom_navigation.dart';
import 'widgets/pluri_icon.dart';
import 'widgets/pluri_layout.dart';
import 'widgets/pluri_wave_scaffold.dart';
import 'package:pluriwave/widgets/mini_reproductor.dart';
import 'servicios/servicio_alarmas_android.dart';

class PluriWaveApp extends StatelessWidget {
  const PluriWaveApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MultiProvider(
      providers: [
        ChangeNotifierProvider(create: (_) => EstadoRadio()),
        ChangeNotifierProvider(create: (_) => EstadoAlarmas()),
        ChangeNotifierProvider(create: (_) => EstadoIdioma()),
      ],
      child: Consumer<EstadoIdioma>(
        builder:
            (context, estadoIdioma, _) => MaterialApp(
              title: 'PluriWave',
              debugShowCheckedModeBanner: false,
              theme: PluriWaveTheme.dark(),
              darkTheme: PluriWaveTheme.dark(),
              themeMode: ThemeMode.dark,
              localizationsDelegates: AppLocalizations.localizationsDelegates,
              supportedLocales: AppLocalizations.supportedLocales,
              locale: estadoIdioma.localeSeleccionado,
              home: const _PaginaPrincipal(),
            ),
      ),
    );
  }
}

class _PaginaPrincipal extends StatefulWidget {
  const _PaginaPrincipal();

  @override
  State<_PaginaPrincipal> createState() => _PaginaPrincipalState();
}

class _PaginaPrincipalState extends State<_PaginaPrincipal> {
  int _indice = 0;
  StreamSubscription<String>? _errorSubscription;
  StreamSubscription<EventoAlarmaAndroid>? _alarmaSubscription;
  StreamSubscription<AlarmaMusical>? _alarmaVencidaSubscription;
  EstadoRadio? _estadoSuscrito;
  bool _alarmaInicialProcesada = false;
  bool _alarmaSonandoActiva = false;
  String? _alarmaSonandoId;

  static const _paginas = [
    PantallaInicio(),
    PantallaBuscar(),
    PantallaFavoritos(),
    PantallaAlarmas(),
    PantallaAjustes(),
  ];

  List<PluriNavItem> _navItems(AppLocalizations l10n) => [
    PluriNavItem(glyph: PluriIconGlyph.home, label: l10n.navHome),
    PluriNavItem(glyph: PluriIconGlyph.search, label: l10n.navSearch),
    PluriNavItem(glyph: PluriIconGlyph.favorites, label: l10n.navFavorites),
    PluriNavItem(glyph: PluriIconGlyph.alarm, label: l10n.navAlarms),
    PluriNavItem(glyph: PluriIconGlyph.settings, label: l10n.navSettings),
  ];

  @override
  void didChangeDependencies() {
    super.didChangeDependencies();
    final estado = context.read<EstadoRadio>();
    if (identical(_estadoSuscrito, estado) && _errorSubscription != null) {
      return;
    }
    _errorSubscription?.cancel();
    _estadoSuscrito = estado;
    _errorSubscription = estado.errorStream.listen((msg) {
      if (!mounted) return;
      ScaffoldMessenger.of(context).showSnackBar(
        SnackBar(
          content: Text(msg),
          duration: const Duration(seconds: 3),
          action: SnackBarAction(
            label: AppLocalizations.of(context).actionOk,
            onPressed: () {},
          ),
        ),
      );
    });

    final alarmas = context.read<EstadoAlarmas>();
    _alarmaSubscription ??= alarmas.android.eventosAlarma.listen((evento) {
      if (!mounted) return;
      _abrirAlarmaSonando(evento);
    });
    _alarmaVencidaSubscription ??= alarmas.alarmasVencidasStream.listen((
      alarma,
    ) {
      if (!mounted) return;
      _abrirAlarmaDirecta(alarma);
    });
    if (!_alarmaInicialProcesada) {
      _alarmaInicialProcesada = true;
      unawaited(_procesarAlarmaInicial(alarmas));
    }
  }

  @override
  void dispose() {
    _errorSubscription?.cancel();
    _alarmaSubscription?.cancel();
    _alarmaVencidaSubscription?.cancel();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    final l10n = AppLocalizations.of(context);

    return PluriWaveScaffold(
      appBar: AppBar(
        title: Text(l10n.appTitle),
        actions: [
          IconButton(
            icon: const Icon(Icons.bedtime_outlined),
            tooltip: l10n.sleepTimer,
            onPressed: () => _mostrarTimerDialog(context),
          ),
        ],
      ),
      body: SafeArea(
        top: false,
        child: AnimatedSwitcher(
          duration: context.pluriMotion.normal,
          switchInCurve: Curves.easeOutCubic,
          switchOutCurve: Curves.easeInCubic,
          transitionBuilder:
              (child, animation) => FadeTransition(
                opacity: animation,
                child: SlideTransition(
                  position: Tween<Offset>(
                    begin: const Offset(0.035, 0),
                    end: Offset.zero,
                  ).animate(animation),
                  child: child,
                ),
              ),
          child: KeyedSubtree(
            key: ValueKey<int>(_indice),
            child: _paginas[_indice],
          ),
        ),
      ),
      bottomNavigationBar: SafeArea(
        top: false,
        minimum: const EdgeInsets.only(bottom: PluriLayout.compactGap),
        child: Padding(
          padding: const EdgeInsets.fromLTRB(8, 0, 8, 0),
          child: Column(
            mainAxisSize: MainAxisSize.min,
            children: [
              const MiniReproductor(),
              PluriBottomNavigation(
                items: _navItems(l10n),
                selectedIndex: _indice,
                onSelected: (i) => setState(() => _indice = i),
              ),
            ],
          ),
        ),
      ),
    );
  }

  Future<void> _procesarAlarmaInicial(EstadoAlarmas alarmas) async {
    final evento = await alarmas.android.obtenerEventoInicial();
    if (evento != null && mounted) {
      await _abrirAlarmaSonando(evento);
    }
  }

  Future<void> _abrirAlarmaSonando(EventoAlarmaAndroid evento) async {
    final estado = context.read<EstadoAlarmas>();
    await estado.refrescarProgramacion();
    AlarmaMusical? alarma;
    for (final item in estado.alarmas) {
      if (item.id == evento.alarmaId) {
        alarma = item;
        break;
      }
    }
    if (alarma == null || !mounted) return;
    if (evento.accion.endsWith('.SKIP_NEXT')) {
      await estado.saltarProxima(alarma.id);
      if (!mounted) return;
      setState(() => _indice = 3);
      ScaffoldMessenger.of(context).showSnackBar(
        SnackBar(
          content: Text(
            AppLocalizations.of(context).skipCurrentAlarmExecution(
              alarma.nombre,
            ),
          ),
        ),
      );
      return;
    }
    if (evento.accion.endsWith('.PRE_NOTICE')) {
      setState(() => _indice = 3);
      return;
    }
    await _mostrarAlarmaSonando(alarma);
  }

  Future<void> _abrirAlarmaDirecta(AlarmaMusical alarma) async {
    await _mostrarAlarmaSonando(alarma);
  }

  Future<void> _mostrarAlarmaSonando(AlarmaMusical alarma) async {
    final alarmas = context.read<EstadoAlarmas>();
    alarmas.marcarEjecucionGestionada(alarma);

    if (_alarmaSonandoActiva) {
      debugPrint(
        '[PluriWave][alarmas] alarma ignorada porque ya hay una activa id=${alarma.id} activa=$_alarmaSonandoId',
      );
      await alarmas.android.ocultarNotificacionAlarma(alarma.id);
      return;
    }

    _alarmaSonandoActiva = true;
    _alarmaSonandoId = alarma.id;

    try {
      await _prearrancarAudioAlarma(alarma);
      if (!mounted) return;
      await Navigator.of(context).push(
        MaterialPageRoute<void>(
          builder:
              (_) => PantallaAlarmaSonando(
                alarma: alarma,
                audioPrearrancado: alarma.emisora != null,
              ),
          fullscreenDialog: true,
        ),
      );
    } finally {
      if (_alarmaSonandoId == alarma.id) {
        _alarmaSonandoActiva = false;
        _alarmaSonandoId = null;
      }
    }
  }

  Future<void> _prearrancarAudioAlarma(AlarmaMusical alarma) async {
    final emisora = alarma.emisora;
    if (emisora == null) return;
    final radio = context.read<EstadoRadio>();
    debugPrint(
      '[PluriWave][alarmas] prearrancar emisora alarma id=${alarma.id} emisora=${emisora.nombre}',
    );
    await radio.audio.setVolumen(alarma.volumen.clamp(0.0, 1.0));
    unawaited(radio.reproducir(emisora));
  }

  void _mostrarTimerDialog(BuildContext context) {
    showModalBottomSheet(
      context: context,
      showDragHandle: true,
      builder:
          (ctx) => Consumer<EstadoRadio>(
            builder: (ctx, estado, _) => SafeArea(
              child: Padding(
                padding: PluriLayout.sheetPadding,
                child: Column(
                  mainAxisSize: MainAxisSize.min,
                  crossAxisAlignment: CrossAxisAlignment.start,
                  children: [
                    Text(
                      AppLocalizations.of(ctx).sleepTimer,
                      style: Theme.of(ctx).textTheme.titleLarge,
                    ),
                    const SizedBox(height: PluriLayout.sectionGap),
                    Text(
                      AppLocalizations.of(ctx).sleepTimerDescription,
                      style: Theme.of(ctx).textTheme.bodySmall,
                    ),
                    const SizedBox(height: PluriLayout.panelGap),
                    if (estado.timer.activo)
                      StreamBuilder<Duration>(
                        stream: estado.timer.tiempoRestanteStream,
                        builder: (ctx, snap) {
                          final restante =
                              snap.data ?? estado.timer.tiempoRestante;
                          return Column(
                            crossAxisAlignment: CrossAxisAlignment.stretch,
                            children: [
                              Text(
                                _formatearDuracionTimer(restante),
                                style: Theme.of(ctx).textTheme.headlineMedium,
                              ),
                              const SizedBox(height: PluriLayout.compactGap),
                              FilledButton.tonal(
                                onPressed: () {
                                  estado.cancelarTimer();
                                  Navigator.pop(ctx);
                                },
                                child: Text(
                                  AppLocalizations.of(ctx).cancelTimer,
                                ),
                              ),
                            ],
                          );
                        },
                      )
                    else
                      Wrap(
                        spacing: PluriLayout.compactGap,
                        runSpacing: PluriLayout.compactGap,
                        children: [
                          for (final segundos
                              in estado.timerSuenoPresetsSegundos)
                            ActionChip(
                              label: Text(
                                _formatearDuracionTimer(
                                  Duration(seconds: segundos),
                                ),
                              ),
                              onPressed: () {
                                estado.iniciarTimerDuracion(
                                  Duration(seconds: segundos),
                                );
                                Navigator.pop(ctx);
                              },
                            ),
                          ActionChip(
                            avatar: const Icon(Icons.tune_rounded, size: 18),
                            label: Text(
                              AppLocalizations.of(ctx).optionOther,
                            ),
                            onPressed: () async {
                              final duracion =
                                  await _pedirDuracionPersonalizada(ctx);
                              if (duracion == null || !ctx.mounted) return;
                              estado.iniciarTimerDuracion(duracion);
                              Navigator.pop(ctx);
                            },
                          ),
                        ],
                      ),
                  ],
                ),
              ),
            ),
          ),
    );
  }

  Future<Duration?> _pedirDuracionPersonalizada(BuildContext context) {
    return showModalBottomSheet<Duration>(
      context: context,
      isScrollControlled: true,
      showDragHandle: true,
      builder: (ctx) => const _TimerPersonalizadoSheet(),
    );
  }
}

String _formatearDuracionTimer(Duration duracion) {
  final horas = duracion.inHours;
  final minutos = duracion.inMinutes.remainder(60);
  final segundos = duracion.inSeconds.remainder(60);
  if (horas > 0) {
    return '${horas}h ${minutos.toString().padLeft(2, '0')}m ${segundos.toString().padLeft(2, '0')}s';
  }
  if (minutos > 0) {
    return segundos == 0 ? '$minutos min' : '${minutos}m ${segundos}s';
  }
  return '$segundos s';
}

class _TimerPersonalizadoSheet extends StatefulWidget {
  const _TimerPersonalizadoSheet();

  @override
  State<_TimerPersonalizadoSheet> createState() =>
      _TimerPersonalizadoSheetState();
}

class _TimerPersonalizadoSheetState extends State<_TimerPersonalizadoSheet> {
  final _horasCtrl = TextEditingController();
  final _minutosCtrl = TextEditingController(text: '15');
  final _segundosCtrl = TextEditingController();
  bool _guardarPreset = true;

  @override
  void dispose() {
    _horasCtrl.dispose();
    _minutosCtrl.dispose();
    _segundosCtrl.dispose();
    super.dispose();
  }

  int _leer(TextEditingController ctrl) => int.tryParse(ctrl.text.trim()) ?? 0;

  Future<void> _confirmar() async {
    final duracion = Duration(
      hours: _leer(_horasCtrl),
      minutes: _leer(_minutosCtrl),
      seconds: _leer(_segundosCtrl),
    );
    if (duracion <= Duration.zero) {
      ScaffoldMessenger.of(context).showSnackBar(
        SnackBar(
          content: Text(
            AppLocalizations.of(context).durationGreaterThanZero,
          ),
        ),
      );
      return;
    }
    if (_guardarPreset) {
      await context.read<EstadoRadio>().agregarTimerSuenoPreset(duracion);
    }
    if (mounted) Navigator.pop(context, duracion);
  }

  @override
  Widget build(BuildContext context) {
    final bottom = MediaQuery.viewInsetsOf(context).bottom;
    return SafeArea(
      child: Padding(
        padding: EdgeInsets.fromLTRB(18, 0, 18, 18 + bottom),
        child: Column(
          mainAxisSize: MainAxisSize.min,
          crossAxisAlignment: CrossAxisAlignment.stretch,
          children: [
            Text(
              AppLocalizations.of(context).customDurationTitle,
              style: Theme.of(context).textTheme.titleLarge,
            ),
            const SizedBox(height: PluriLayout.sectionGap),
            Row(
              children: [
                Expanded(
                  child: _campoTiempo(
                    _horasCtrl,
                    AppLocalizations.of(context).hoursLabel,
                  ),
                ),
                const SizedBox(width: PluriLayout.compactGap),
                Expanded(
                  child: _campoTiempo(
                    _minutosCtrl,
                    AppLocalizations.of(context).minutesLabel,
                  ),
                ),
                const SizedBox(width: PluriLayout.compactGap),
                Expanded(
                  child: _campoTiempo(
                    _segundosCtrl,
                    AppLocalizations.of(context).secondsLabel,
                  ),
                ),
              ],
            ),
            const SizedBox(height: PluriLayout.compactGap),
            SwitchListTile.adaptive(
              contentPadding: EdgeInsets.zero,
              title: Text(
                AppLocalizations.of(context).saveQuickAccess,
              ),
              value: _guardarPreset,
              onChanged: (value) => setState(() => _guardarPreset = value),
            ),
            const SizedBox(height: PluriLayout.sectionGap),
            FilledButton.icon(
              icon: const Icon(Icons.bedtime_rounded),
              label: Text(
                AppLocalizations.of(context).startTimer,
              ),
              onPressed: _confirmar,
            ),
          ],
        ),
      ),
    );
  }

  Widget _campoTiempo(TextEditingController controller, String label) {
    return TextField(
      controller: controller,
      keyboardType: TextInputType.number,
      decoration: InputDecoration(
        labelText: label,
        border: const OutlineInputBorder(),
      ),
    );
  }
}