// Compact voice UI for narrow / mobile layouts (Plan E hybrid:
// AppBar mutes + status chip with 2-line live readout + wide bottom-
// anchored PTT button + modal sheet for non-essential controls).
//
// rc.8 follow-up: the AppBar gear icon was removed; the modal sheet
// is now the **single** voice-controls surface on mobile. Mode +
// release-tail are surfaced inline (radio buttons + slider) inside
// the modal. Audio output route picker is driven by `audio_session`
// (Ryan Heise, 865k downloads): we enumerate AVAudioSession's
// available inputs + current route ourselves and render a Discord/
// WhatsApp-style 'Choose audio' bottom-sheet. Switching is via
// AVAudioSession.setPreferredInput(port) + overrideOutputAudioPort
// (.speaker | .none). We previously tried `audio_router 1.1.1`
// whose iOS path is AVRoutePickerView (the AirPlay button) \u2014
// wrong UI: that only lists AirPlay output destinations, not the
// speaker/receiver/Bluetooth choices we want.

import 'dart:async' show StreamSubscription;
import 'dart:io' show Platform;

import 'package:audio_session/audio_session.dart';
import 'package:flutter/foundation.dart' show kIsWeb;
import 'package:flutter/material.dart';

import '../l10n/generated/app_localizations.dart';
import '../main.dart' show PttCapabilityBadge;
import '../src/rust/api.dart' as rust;

/// Two-line status chip that summarises the current voice state.
/// Tap to open the voice details modal.
class VoiceStatusChip extends StatelessWidget {
  /// Construct a status chip.
  const VoiceStatusChip({
    super.key,
    required this.transmitMode,
    required this.releaseTailMs,
    required this.pttBoundKeyLabel,
    required this.audioStats,
    required this.isTouchOnly,
    required this.onTap,
  });

  /// Current transmit mode.
  final rust.BridgeTransmitMode transmitMode;

  /// Release-tail in milliseconds.
  final int releaseTailMs;

  /// Bound key label (empty on touch-only hosts).
  final String pttBoundKeyLabel;

  /// Current audio stats; null while audio engine not running.
  final rust.BridgeAudioStats? audioStats;

  /// True on iOS / iPadOS / Android.
  final bool isTouchOnly;

  /// Open the voice details modal.
  final VoidCallback onTap;

  @override
  Widget build(BuildContext context) {
    final theme = Theme.of(context);
    final l10n = AppL10n.of(context);

    final stats = audioStats;
    final micOn = stats?.pttActive ?? false;

    final modeLabel = switch (transmitMode) {
      rust.BridgeTransmitMode.ptt => l10n.voiceModePtt,
      rust.BridgeTransmitMode.continuous => l10n.voiceModeContinuous,
      rust.BridgeTransmitMode.voiceActivity =>
        '${l10n.voiceModeVoiceActivity} (${l10n.voiceModeComingSoon})',
    };

    String line1;
    if (transmitMode == rust.BridgeTransmitMode.ptt) {
      if (isTouchOnly) {
        line1 = '$modeLabel \u00b7 ${l10n.voicePttHoldHint}';
      } else {
        line1 =
            '$modeLabel \u00b7 ${pttBoundKeyLabel.isEmpty ? "\u2014" : pttBoundKeyLabel}';
      }
    } else {
      line1 = modeLabel;
    }

    final tailText = transmitMode == rust.BridgeTransmitMode.ptt
        ? '$releaseTailMs${l10n.voiceReleaseTailHint} ${l10n.voiceReleaseTailLabel.toLowerCase()}'
        : null;
    final micText = micOn ? l10n.voiceMicOn : l10n.voiceMicOff;
    final line2 = tailText == null ? micText : '$tailText \u00b7 $micText';

    return Material(
      type: MaterialType.transparency,
      child: InkWell(
        onTap: onTap,
        borderRadius: BorderRadius.circular(12),
        child: Container(
          padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 8),
          decoration: BoxDecoration(
            color: theme.colorScheme.surfaceContainerHigh,
            borderRadius: BorderRadius.circular(12),
            border: Border.all(
              color: theme.colorScheme.outlineVariant,
              width: 0.5,
            ),
          ),
          child: Row(
            children: [
              Icon(
                micOn
                    ? Icons.fiber_manual_record
                    : Icons.fiber_manual_record_outlined,
                size: 12,
                color: micOn
                    ? theme.colorScheme.primary
                    : theme.colorScheme.outline,
              ),
              const SizedBox(width: 8),
              Expanded(
                child: Column(
                  crossAxisAlignment: CrossAxisAlignment.start,
                  mainAxisSize: MainAxisSize.min,
                  children: [
                    Text(
                      line1,
                      maxLines: 1,
                      overflow: TextOverflow.ellipsis,
                      style: theme.textTheme.bodyMedium?.copyWith(
                        fontWeight: FontWeight.w500,
                      ),
                    ),
                    Text(
                      line2,
                      maxLines: 1,
                      overflow: TextOverflow.ellipsis,
                      style: theme.textTheme.bodySmall?.copyWith(
                        color: theme.colorScheme.onSurfaceVariant,
                      ),
                    ),
                  ],
                ),
              ),
              const SizedBox(width: 8),
              Icon(
                Icons.expand_less,
                size: 18,
                color: theme.colorScheme.onSurfaceVariant,
              ),
            ],
          ),
        ),
      ),
    );
  }
}

/// Wide, bottom-anchored push-to-talk button.
class VoicePttButton extends StatefulWidget {
  /// Construct a PTT button.
  const VoicePttButton({
    super.key,
    required this.active,
    required this.onHeldChanged,
  });

  /// True while the engine reports the gate open.
  final bool active;

  /// Called with `true` on finger-down, `false` on finger-up or cancel.
  final ValueChanged<bool> onHeldChanged;

  @override
  State<VoicePttButton> createState() => _VoicePttButtonState();
}

class _VoicePttButtonState extends State<VoicePttButton> {
  bool _pressed = false;

  void _setHeld(bool held) {
    if (_pressed == held) return;
    setState(() => _pressed = held);
    widget.onHeldChanged(held);
  }

  @override
  Widget build(BuildContext context) {
    final theme = Theme.of(context);
    final l10n = AppL10n.of(context);
    final activeNow = _pressed || widget.active;

    return GestureDetector(
      behavior: HitTestBehavior.opaque,
      onTapDown: (_) => _setHeld(true),
      onTapUp: (_) => _setHeld(false),
      onTapCancel: () => _setHeld(false),
      onPanDown: (_) => _setHeld(true),
      onPanEnd: (_) => _setHeld(false),
      onPanCancel: () => _setHeld(false),
      child: AnimatedContainer(
        duration: const Duration(milliseconds: 80),
        height: 56,
        decoration: BoxDecoration(
          color: activeNow
              ? theme.colorScheme.primary
              : theme.colorScheme.primaryContainer,
          borderRadius: BorderRadius.circular(16),
          boxShadow: activeNow
              ? [
                  BoxShadow(
                    color: theme.colorScheme.primary.withAlpha(100),
                    blurRadius: 16,
                    spreadRadius: 2,
                    offset: const Offset(0, 2),
                  ),
                ]
              : null,
        ),
        child: Center(
          child: Row(
            mainAxisSize: MainAxisSize.min,
            children: [
              Icon(
                activeNow ? Icons.mic : Icons.mic_none,
                color: activeNow
                    ? theme.colorScheme.onPrimary
                    : theme.colorScheme.onPrimaryContainer,
                size: 28,
              ),
              const SizedBox(width: 12),
              Text(
                activeNow ? l10n.voiceMicOn : l10n.voiceModePtt,
                style: theme.textTheme.titleMedium?.copyWith(
                  fontWeight: FontWeight.w600,
                  letterSpacing: 0.4,
                  color: activeNow
                      ? theme.colorScheme.onPrimary
                      : theme.colorScheme.onPrimaryContainer,
                ),
              ),
            ],
          ),
        ),
      ),
    );
  }
}

/// Show the voice controls modal sheet — the single voice-controls
/// surface on mobile. Tiles:
///   1. Audio output route picker (iOS native AVRoutePickerView /
///      Android Material 3 list). Mobile only.
///   2. Mode radio buttons (PTT / Continuous; VoiceActivity disabled
///      coming-soon).
///   3. Release-tail slider (PTT-only).
///   4. Mic level meter.
///   5. TX / RX frame counts.
///   6. PTT capability badge.
///
/// Mode + release-tail are inlined directly here instead of being
/// hidden behind an "Adjust" button → nested dialog. Single-screen
/// control panel, zero navigation depth. `onModeChanged` and
/// `onReleaseTailChanged` are debounced by the caller so users can
/// drag the slider freely.
Future<void> showVoiceDetailsSheet(
  BuildContext context, {
  required rust.BridgeAudioStats? audioStats,
  required rust.BridgeTransmitMode transmitMode,
  required int releaseTailMs,
  required String pttBoundKeyLabel,
  required String pttLevel,
  required String pttBackendId,
  required String pttBoundInputClass,
  required bool isTouchOnly,
  required ValueChanged<rust.BridgeTransmitMode> onModeChanged,
  required ValueChanged<int> onReleaseTailChanged,
}) async {
  await showModalBottomSheet<void>(
    context: context,
    showDragHandle: true,
    isScrollControlled: true,
    builder: (ctx) {
      return _VoiceSheetBody(
        audioStats: audioStats,
        initialMode: transmitMode,
        initialReleaseTailMs: releaseTailMs,
        pttBoundKeyLabel: pttBoundKeyLabel,
        pttLevel: pttLevel,
        pttBackendId: pttBackendId,
        pttBoundInputClass: pttBoundInputClass,
        isTouchOnly: isTouchOnly,
        onModeChanged: onModeChanged,
        onReleaseTailChanged: onReleaseTailChanged,
      );
    },
  );
}

class _VoiceSheetBody extends StatefulWidget {
  const _VoiceSheetBody({
    required this.audioStats,
    required this.initialMode,
    required this.initialReleaseTailMs,
    required this.pttBoundKeyLabel,
    required this.pttLevel,
    required this.pttBackendId,
    required this.pttBoundInputClass,
    required this.isTouchOnly,
    required this.onModeChanged,
    required this.onReleaseTailChanged,
  });

  final rust.BridgeAudioStats? audioStats;
  final rust.BridgeTransmitMode initialMode;
  final int initialReleaseTailMs;
  final String pttBoundKeyLabel;
  final String pttLevel;
  final String pttBackendId;
  final String pttBoundInputClass;
  final bool isTouchOnly;
  final ValueChanged<rust.BridgeTransmitMode> onModeChanged;
  final ValueChanged<int> onReleaseTailChanged;

  @override
  State<_VoiceSheetBody> createState() => _VoiceSheetBodyState();
}

class _VoiceSheetBodyState extends State<_VoiceSheetBody> {
  late rust.BridgeTransmitMode _mode = widget.initialMode;
  late int _tail = widget.initialReleaseTailMs;

  void _setMode(rust.BridgeTransmitMode m) {
    if (m == rust.BridgeTransmitMode.voiceActivity) {
      // Coming-soon \u2014 disabled in UI; defensive guard.
      return;
    }
    setState(() => _mode = m);
    widget.onModeChanged(m);
  }

  void _setTail(double v) {
    final ms = v.round();
    setState(() => _tail = ms);
    widget.onReleaseTailChanged(ms);
  }

  @override
  Widget build(BuildContext context) {
    final theme = Theme.of(context);
    final l10n = AppL10n.of(context);
    final stats = widget.audioStats;
    final levelActive = stats?.pttActive ?? false;
    final isPtt = _mode == rust.BridgeTransmitMode.ptt;

    // Route picker only meaningful on iOS + Android where the OS
    // owns audio routing. Desktop hosts skip the tile entirely.
    final showRoutePicker = !kIsWeb && (Platform.isIOS || Platform.isAndroid);

    return SafeArea(
      child: SingleChildScrollView(
        padding: const EdgeInsets.fromLTRB(20, 8, 20, 24),
        child: Column(
          mainAxisSize: MainAxisSize.min,
          crossAxisAlignment: CrossAxisAlignment.stretch,
          children: [
            Text(l10n.voiceSheetTitle, style: theme.textTheme.titleLarge),
            const SizedBox(height: 12),

            // 1) Audio output route picker tile (mobile only).
            if (showRoutePicker) ...[
              const _AudioOutputTile(),
              const SizedBox(height: 8),
              Divider(height: 1, color: theme.colorScheme.outlineVariant),
              const SizedBox(height: 8),
            ],

            // 2) Mode \u2014 inline radio rows.
            Text(
              l10n.voiceModeLabel,
              style: theme.textTheme.labelLarge?.copyWith(
                color: theme.colorScheme.onSurfaceVariant,
              ),
            ),
            const SizedBox(height: 4),
            _ModeRow(
              label: l10n.voiceModePtt,
              icon: Icons.radio_button_checked,
              selected: _mode == rust.BridgeTransmitMode.ptt,
              onTap: () => _setMode(rust.BridgeTransmitMode.ptt),
            ),
            _ModeRow(
              label: l10n.voiceModeContinuous,
              icon: Icons.podcasts,
              selected: _mode == rust.BridgeTransmitMode.continuous,
              onTap: () => _setMode(rust.BridgeTransmitMode.continuous),
            ),
            _ModeRow(
              label:
                  '${l10n.voiceModeVoiceActivity} (${l10n.voiceModeComingSoon})',
              icon: Icons.graphic_eq,
              selected: false,
              onTap: null,
            ),

            // 3) Release-tail slider (PTT only).
            if (isPtt) ...[
              const SizedBox(height: 8),
              Row(
                children: [
                  Text(
                    l10n.voiceReleaseTailLabel,
                    style: theme.textTheme.labelLarge?.copyWith(
                      color: theme.colorScheme.onSurfaceVariant,
                    ),
                  ),
                  const Spacer(),
                  Text(
                    '$_tail${l10n.voiceReleaseTailHint}',
                    style: theme.textTheme.bodyMedium?.copyWith(
                      fontFeatures: const [FontFeature.tabularFigures()],
                    ),
                  ),
                ],
              ),
              Slider(
                value: _tail.toDouble().clamp(0, 500),
                min: 0,
                max: 500,
                divisions: 20,
                label: '$_tail ms',
                onChanged: _setTail,
              ),
              // Desktop-only: surface the bound key so the user
              // sees what hardware key is wired. On mobile this
              // row is suppressed (there is no hardware key; the
              // PTT button is the input).
              if (!widget.isTouchOnly &&
                  widget.pttBoundKeyLabel.isNotEmpty) ...[
                Padding(
                  padding: const EdgeInsets.only(left: 4),
                  child: Text(
                    '${l10n.voiceBoundKeyLabel}: ${widget.pttBoundKeyLabel}',
                    style: theme.textTheme.bodySmall?.copyWith(
                      color: theme.colorScheme.onSurfaceVariant,
                    ),
                  ),
                ),
              ],
            ],

            const SizedBox(height: 16),
            Divider(height: 1, color: theme.colorScheme.outlineVariant),
            const SizedBox(height: 12),

            // 4) Level meter.
            _LevelMeter(active: levelActive),
            const SizedBox(height: 6),
            if (stats != null)
              Text(
                l10n.audioStatsLine(
                  stats.framesSent,
                  stats.framesReceived,
                  stats.pttActive ? l10n.voiceMicOn : l10n.voiceMicOff,
                ),
                style: theme.textTheme.bodySmall,
              ),

            // 5) PTT capability badge. On iOS this must remain
            // visible even though the resolved level is always
            // `L0Focused`, because the P0 acceptance flow requires
            // honest capability advertising with an explanation of
            // the sandbox limitation.
            if (isPtt) ...[
              const SizedBox(height: 12),
              PttCapabilityBadge(
                level: widget.pttLevel,
                backendId: widget.pttBackendId,
                boundInputClass: widget.pttBoundInputClass,
              ),
            ],
          ],
        ),
      ),
    );
  }
}

class _ModeRow extends StatelessWidget {
  const _ModeRow({
    required this.label,
    required this.icon,
    required this.selected,
    required this.onTap,
  });

  final String label;
  final IconData icon;
  final bool selected;
  final VoidCallback? onTap;

  @override
  Widget build(BuildContext context) {
    final theme = Theme.of(context);
    final disabled = onTap == null;
    final color = disabled
        ? theme.colorScheme.onSurfaceVariant.withAlpha(120)
        : selected
        ? theme.colorScheme.primary
        : theme.colorScheme.onSurface;
    return InkWell(
      onTap: onTap,
      borderRadius: BorderRadius.circular(8),
      child: Padding(
        padding: const EdgeInsets.symmetric(vertical: 10, horizontal: 4),
        child: Row(
          children: [
            Icon(
              selected
                  ? Icons.radio_button_checked
                  : Icons.radio_button_unchecked,
              size: 20,
              color: color,
            ),
            const SizedBox(width: 12),
            Icon(icon, size: 18, color: color),
            const SizedBox(width: 8),
            Expanded(
              child: Text(
                label,
                style: theme.textTheme.bodyLarge?.copyWith(color: color),
              ),
            ),
          ],
        ),
      ),
    );
  }
}

/// Tile that displays the current audio output route + opens the
/// native picker on tap. Subscribes to `currentDeviceStream` so the
/// row auto-updates when the user plugs in headphones, connects
/// AirPods, etc.
/// Tile that displays the **active** audio output port (Speaker /
/// iPhone receiver / AirPods / wired headset / etc.) and opens a
/// 'Choose audio' bottom sheet on tap. Backed by `audio_session`:
///
///   * `AVAudioSession.currentRoute.outputs` for the active label.
///   * `AVAudioSession.availableInputs` for the picker list of
///     selectable inputs (Built-in mic, BT HFP, wired headset, USB).
///   * `routeChangeStream` for live updates.
///   * `setPreferredInput(port)` for input selection (also moves
///     the matching output for HFP/headset/wired).
///   * `overrideOutputAudioPort(.speaker | .none)` for the
///     speakerphone <-> earpiece toggle.
///
/// This is the same primitive used by Discord / WhatsApp / FaceTime
/// for their VoIP audio chooser. It is NOT the AirPlay picker
/// (`AVRoutePickerView`), which is a different UI for streaming
/// audio to other devices.
class _AudioOutputTile extends StatefulWidget {
  const _AudioOutputTile();

  @override
  State<_AudioOutputTile> createState() => _AudioOutputTileState();
}

class _AudioOutputTileState extends State<_AudioOutputTile> {
  AVAudioSessionPortDescription? _activeOutput;
  StreamSubscription<AVAudioSessionRouteChange>? _routeSub;

  @override
  void initState() {
    super.initState();
    _refresh();
    // Live updates when the user plugs / unplugs / connects a
    // headset / BT device while the modal sheet is open.
    _routeSub = AVAudioSession().routeChangeStream.listen((_) {
      if (!mounted) return;
      _refresh();
    });
  }

  @override
  void dispose() {
    _routeSub?.cancel();
    _routeSub = null;
    super.dispose();
  }

  Future<void> _refresh() async {
    try {
      final route = await AVAudioSession().currentRoute;
      if (!mounted) return;
      setState(() {
        // The 'output' port we want to display is whichever output
        // the system has currently routed to. There is normally one.
        _activeOutput = route.outputs.isEmpty ? null : route.outputs.first;
      });
    } catch (_) {
      // Suppress \u2014 AVAudioSession may transiently throw on first
      // call before the session is active.
    }
  }

  static String _portLabel(
    AVAudioSessionPort? type,
    String fallback,
    AppL10n l10n,
  ) {
    switch (type) {
      case AVAudioSessionPort.builtInSpeaker:
        return l10n.audioRouteSpeaker;
      case AVAudioSessionPort.builtInReceiver:
        return l10n.audioRouteReceiver;
      case AVAudioSessionPort.bluetoothHfp:
      case AVAudioSessionPort.bluetoothA2dp:
      case AVAudioSessionPort.bluetoothLe:
        return fallback.isEmpty ? l10n.audioRouteBluetooth : fallback;
      case AVAudioSessionPort.headphones:
      case AVAudioSessionPort.headsetMic:
        return fallback.isEmpty ? l10n.audioRouteWiredHeadset : fallback;
      case AVAudioSessionPort.carAudio:
        return l10n.audioRouteCarAudio;
      case AVAudioSessionPort.airPlay:
        return l10n.audioRouteAirplay;
      case AVAudioSessionPort.builtInMic:
        // Built-in mic is implied 'iPhone' \u2014 only seen if we somehow
        // end up with an input listed as an output.
        return fallback.isEmpty ? l10n.audioRouteReceiver : fallback;
      case null:
      default:
        return fallback.isEmpty ? l10n.audioRouteUnknown : fallback;
    }
  }

  static IconData _portIcon(AVAudioSessionPort? type) {
    switch (type) {
      case AVAudioSessionPort.builtInSpeaker:
        return Icons.volume_up;
      case AVAudioSessionPort.builtInReceiver:
        return Icons.phone_in_talk;
      case AVAudioSessionPort.bluetoothHfp:
      case AVAudioSessionPort.bluetoothA2dp:
      case AVAudioSessionPort.bluetoothLe:
        return Icons.bluetooth_audio;
      case AVAudioSessionPort.headphones:
      case AVAudioSessionPort.headsetMic:
        return Icons.headset;
      case AVAudioSessionPort.carAudio:
        return Icons.directions_car;
      case AVAudioSessionPort.airPlay:
        return Icons.airplay;
      default:
        return Icons.speaker;
    }
  }

  Future<void> _openPicker() async {
    await showModalBottomSheet<void>(
      context: context,
      showDragHandle: true,
      isScrollControlled: true,
      builder: (ctx) {
        return const _AudioOutputPickerSheet();
      },
    );
    // Refresh after the picker closes (user may have changed route).
    await _refresh();
  }

  @override
  Widget build(BuildContext context) {
    final theme = Theme.of(context);
    final l10n = AppL10n.of(context);
    final port = _activeOutput;
    final label = _portLabel(port?.portType, port?.portName ?? '', l10n);
    return InkWell(
      onTap: _openPicker,
      borderRadius: BorderRadius.circular(12),
      child: Padding(
        padding: const EdgeInsets.symmetric(vertical: 10, horizontal: 4),
        child: Row(
          children: [
            Icon(_portIcon(port?.portType), color: theme.colorScheme.primary),
            const SizedBox(width: 14),
            Expanded(
              child: Column(
                crossAxisAlignment: CrossAxisAlignment.start,
                children: [
                  Text(
                    l10n.audioOutputLabel,
                    style: theme.textTheme.bodySmall?.copyWith(
                      color: theme.colorScheme.onSurfaceVariant,
                    ),
                  ),
                  Text(
                    label,
                    style: theme.textTheme.bodyLarge?.copyWith(
                      fontWeight: FontWeight.w500,
                    ),
                  ),
                ],
              ),
            ),
            Icon(
              Icons.chevron_right,
              color: theme.colorScheme.onSurfaceVariant,
            ),
          ],
        ),
      ),
    );
  }
}

/// 'Choose audio' bottom sheet that lists every selectable route
/// (Speaker, iPhone receiver, every connected BT / wired / USB
/// input). Tap to switch; Speaker / Receiver use
/// `overrideOutputAudioPort(.speaker | .none)`, other ports use
/// `setPreferredInput(port)` which also moves the paired output
/// (e.g. AirPods).
class _AudioOutputPickerSheet extends StatefulWidget {
  const _AudioOutputPickerSheet();

  @override
  State<_AudioOutputPickerSheet> createState() =>
      _AudioOutputPickerSheetState();
}

class _AudioOutputPickerSheetState extends State<_AudioOutputPickerSheet> {
  Set<AVAudioSessionPortDescription> _availableInputs = const {};
  AVAudioSessionRouteDescription? _route;
  StreamSubscription<AVAudioSessionRouteChange>? _routeSub;
  bool _loading = true;

  @override
  void initState() {
    super.initState();
    _refresh();
    _routeSub = AVAudioSession().routeChangeStream.listen((_) {
      if (!mounted) return;
      _refresh();
    });
  }

  @override
  void dispose() {
    _routeSub?.cancel();
    _routeSub = null;
    super.dispose();
  }

  Future<void> _refresh() async {
    try {
      final session = AVAudioSession();
      final inputs = await session.availableInputs;
      final route = await session.currentRoute;
      if (!mounted) return;
      setState(() {
        _availableInputs = inputs;
        _route = route;
        _loading = false;
      });
    } catch (_) {
      if (!mounted) return;
      setState(() => _loading = false);
    }
  }

  Future<void> _selectSpeaker() async {
    try {
      // Apple-documented quirk: in .voiceChat mode, calling
      // setPreferredInput(builtInMic) AFTER overrideOutputAudioPort(.speaker)
      // causes iOS to recalculate the route. Built-in mic naturally
      // pairs with the receiver (not the speaker), so the system
      // SILENTLY REVERTS the speaker override and routes audio
      // back through the earpiece. Net: the await chain returns
      // successfully ('no exception'), but the user hears no
      // change.
      //
      // Fix: do NOT call setPreferredInput when forcing speaker.
      // The speaker override is sufficient on its own \u2014 input
      // remains on whatever the system was already using (built-in
      // mic by default, or BT/wired if connected and selected
      // elsewhere). For consistency, only switch input when the
      // user explicitly picks a non-speaker input row.
      await AVAudioSession().overrideOutputAudioPort(
        AVAudioSessionPortOverride.speaker,
      );
      debugPrint('chanora: audio output -> speakerphone (override applied)');
    } catch (e, st) {
      debugPrint('chanora: _selectSpeaker FAILED: $e\n$st');
    }
    if (!mounted) return;
    Navigator.of(context).pop();
  }

  Future<void> _selectReceiver() async {
    try {
      // Same quirk in reverse: removing the speaker override
      // (.none) is enough to restore the .voiceChat default route,
      // which is the built-in receiver. Calling setPreferredInput
      // explicitly here is redundant and risks the same recalc
      // race that broke _selectSpeaker before.
      await AVAudioSession().overrideOutputAudioPort(
        AVAudioSessionPortOverride.none,
      );
      debugPrint('chanora: audio output -> receiver (override cleared)');
    } catch (e, st) {
      debugPrint('chanora: _selectReceiver FAILED: $e\n$st');
    }
    if (!mounted) return;
    Navigator.of(context).pop();
  }

  Future<void> _selectInput(AVAudioSessionPortDescription port) async {
    try {
      // Drop any speakerphone override so the route follows the
      // selected input. BT / wired headset / USB inputs pair their
      // OWN output (the user hears audio through the same device
      // they speak into), so .none + setPreferredInput is the
      // correct combo here.
      await AVAudioSession().overrideOutputAudioPort(
        AVAudioSessionPortOverride.none,
      );
      await AVAudioSession().setPreferredInput(port);
      debugPrint(
        'chanora: audio output -> ${port.portName} (${port.portType})',
      );
    } catch (e, st) {
      debugPrint('chanora: _selectInput FAILED: $e\n$st');
    }
    if (!mounted) return;
    Navigator.of(context).pop();
  }

  @override
  Widget build(BuildContext context) {
    final theme = Theme.of(context);
    final l10n = AppL10n.of(context);

    if (_loading) {
      return const SafeArea(
        child: Padding(
          padding: EdgeInsets.all(40),
          child: Center(child: CircularProgressIndicator()),
        ),
      );
    }

    final currentOutputType = _route?.outputs.isNotEmpty == true
        ? _route!.outputs.first.portType
        : null;
    final currentInputUid = _route?.inputs.isNotEmpty == true
        ? _route!.inputs.first.uid
        : null;

    // Whether the active route is the speakerphone override (built-in
    // speaker is the output but the actual session category isn't
    // playback \u2014 it's playAndRecord + override).
    final isSpeaker = currentOutputType == AVAudioSessionPort.builtInSpeaker;
    final isReceiver = currentOutputType == AVAudioSessionPort.builtInReceiver;

    // Non-built-in inputs (BT / wired / USB / car audio) for the
    // device-specific rows. Built-in mic is rendered as 'iPhone
    // (receiver)' above; we filter it out here.
    final externalInputs = _availableInputs
        .where((p) => p.portType != AVAudioSessionPort.builtInMic)
        .toList();

    return SafeArea(
      child: SingleChildScrollView(
        padding: const EdgeInsets.fromLTRB(20, 8, 20, 24),
        child: Column(
          mainAxisSize: MainAxisSize.min,
          crossAxisAlignment: CrossAxisAlignment.stretch,
          children: [
            Text(l10n.audioOutputLabel, style: theme.textTheme.titleLarge),
            const SizedBox(height: 16),
            _PickerRow(
              icon: Icons.volume_up,
              label: l10n.audioRouteSpeaker,
              selected: isSpeaker,
              onTap: _selectSpeaker,
            ),
            _PickerRow(
              icon: Icons.phone_in_talk,
              label: l10n.audioRouteReceiver,
              selected: isReceiver,
              onTap: _selectReceiver,
            ),
            for (final port in externalInputs)
              _PickerRow(
                icon: _AudioOutputTileState._portIcon(port.portType),
                label: _AudioOutputTileState._portLabel(
                  port.portType,
                  port.portName,
                  l10n,
                ),
                selected: !isSpeaker && port.uid == currentInputUid,
                onTap: () => _selectInput(port),
              ),
          ],
        ),
      ),
    );
  }
}

class _PickerRow extends StatelessWidget {
  const _PickerRow({
    required this.icon,
    required this.label,
    required this.selected,
    required this.onTap,
  });

  final IconData icon;
  final String label;
  final bool selected;
  final VoidCallback onTap;

  @override
  Widget build(BuildContext context) {
    final theme = Theme.of(context);
    final color = selected
        ? theme.colorScheme.primary
        : theme.colorScheme.onSurface;
    return InkWell(
      onTap: onTap,
      borderRadius: BorderRadius.circular(8),
      child: Padding(
        padding: const EdgeInsets.symmetric(vertical: 14, horizontal: 4),
        child: Row(
          children: [
            Icon(icon, color: color),
            const SizedBox(width: 16),
            Expanded(
              child: Text(
                label,
                style: theme.textTheme.bodyLarge?.copyWith(color: color),
              ),
            ),
            if (selected) Icon(Icons.check, color: theme.colorScheme.primary),
          ],
        ),
      ),
    );
  }
}

class _LevelMeter extends StatelessWidget {
  const _LevelMeter({required this.active});

  final bool active;

  @override
  Widget build(BuildContext context) {
    final theme = Theme.of(context);
    return Container(
      height: 8,
      decoration: BoxDecoration(
        color: theme.colorScheme.surfaceContainerHighest,
        borderRadius: BorderRadius.circular(4),
      ),
      child: FractionallySizedBox(
        alignment: AlignmentDirectional.centerStart,
        widthFactor: active ? 0.75 : 0.05,
        child: Container(
          decoration: BoxDecoration(
            color: active
                ? theme.colorScheme.primary
                : theme.colorScheme.outlineVariant,
            borderRadius: BorderRadius.circular(4),
          ),
        ),
      ),
    );
  }
}