Melo/lib/player/audio_handler.dart

import 'dart:async';

import 'package:audio_service/audio_service.dart';
import 'package:just_audio/just_audio.dart';
import '../library/database.dart';
import 'sleep_timer.dart';

/// Entscheidet, ob eine gespeicherte Wiedergabeposition beim Laden
/// wiederhergestellt werden soll. Kein Resume bei Position 0 oder wenn die
/// Position zu nah am (bekannten) Ende des Tracks liegt — sonst würde die
/// Wiedergabe sofort wieder enden.
bool shouldResumeAt(int lastPositionMs, Duration? trackDuration) {
  if (lastPositionMs <= 0) return false;
  if (trackDuration != null &&
      lastPositionMs >= trackDuration.inMilliseconds - 3000) {
    return false;
  }
  return true;
}

/// Kern der Wiedergabe: kapselt just_audio hinter audio_service,
/// damit Hintergrund-Wiedergabe + Lockscreen/Notification funktionieren.
class MeloAudioHandler extends BaseAudioHandler with QueueHandler, SeekHandler {
  final AudioPlayer _player = AudioPlayer();
  final MeloDb db;
  late final SleepTimer sleepTimer;
  late final Timer _positionRecordTimer;

  MeloAudioHandler({required this.db}) {
    sleepTimer = SleepTimer(onElapsed: pause);
    // just_audio-Events → audio_service PlaybackState
    _player.playbackEventStream.map(_transformEvent).pipe(playbackState);

    // Wiedergabeposition alle ~5s persistieren, solange aktiv abgespielt wird.
    _positionRecordTimer = Timer.periodic(const Duration(seconds: 5), (_) {
      final songId = mediaItem.value?.extras?['songId'] as String?;
      if (_player.playing && songId != null) {
        db.recordPlayback(songId, _player.position.inMilliseconds);
      }
    });

    // Aktuellen Track ans System melden (Lockscreen/Notification).
    // Bereits bekannte Dauer erhalten, damit sie nicht auf null zurückfällt.
    _player.currentIndexStream.listen((index) {
      final q = queue.value;
      if (index != null && index < q.length) {
        mediaItem.add(q[index].copyWith(duration: _player.duration));
      }
    });

    // Ermittelte Dauer nachtragen
    _player.durationStream.listen((duration) {
      final item = mediaItem.value;
      if (item != null && duration != null) {
        mediaItem.add(item.copyWith(duration: duration));
      }
    });
  }

  /// Ersetzt die Warteschlange und startet ab [startIndex].
  Future<void> loadPlaylist(List<MediaItem> items, {int startIndex = 0}) async {
    queue.add(items);
    final sources = items
        .map((item) => AudioSource.uri(Uri.parse(item.id), tag: item))
        .toList();
    await _player.setAudioSources(sources, initialIndex: startIndex);

    // Bei bekannter letzter Position an dieser Stelle fortsetzen,
    // statt immer von vorne zu beginnen.
    final songId = items[startIndex].extras?['songId'] as String?;
    if (songId != null) {
      final lastMs = await db.lastPosition(songId);
      if (lastMs != null && shouldResumeAt(lastMs, items[startIndex].duration)) {
        await _player.seek(Duration(milliseconds: lastMs), index: startIndex);
      }
    }

    await play();
  }

  @override
  Future<void> play() => _player.play();

  @override
  Future<void> pause() => _player.pause();

  @override
  Future<void> stop() async {
    sleepTimer.cancel();
    _positionRecordTimer.cancel();
    await _player.stop();
    await super.stop();
  }

  /// Gibt Hintergrund-Ressourcen frei (Positions-Timer), ohne die Wiedergabe
  /// zu stoppen. Für Tests, die den Handler ohne vollständigen App-Lifecycle
  /// verwenden und daher [stop] nicht durchlaufen.
  void dispose() {
    _positionRecordTimer.cancel();
  }

  @override
  Future<void> seek(Duration position) => _player.seek(position);

  @override
  Future<void> skipToNext() => _player.seekToNext();

  @override
  Future<void> skipToPrevious() => _player.seekToPrevious();

  @override
  Future<void> skipToQueueItem(int index) => _player.seek(Duration.zero, index: index);

  @override
  Future<void> setShuffleMode(AudioServiceShuffleMode shuffleMode) async {
    final enabled = shuffleMode == AudioServiceShuffleMode.all;
    if (enabled) await _player.shuffle();
    await _player.setShuffleModeEnabled(enabled);
  }

  @override
  Future<void> setRepeatMode(AudioServiceRepeatMode repeatMode) {
    return _player.setLoopMode(switch (repeatMode) {
      AudioServiceRepeatMode.one => LoopMode.one,
      AudioServiceRepeatMode.all => LoopMode.all,
      _ => LoopMode.off,
    });
  }

  PlaybackState _transformEvent(PlaybackEvent event) {
    return PlaybackState(
      controls: [
        MediaControl.skipToPrevious,
        if (_player.playing) MediaControl.pause else MediaControl.play,
        MediaControl.skipToNext,
      ],
      systemActions: const {
        MediaAction.seek,
        MediaAction.seekForward,
        MediaAction.seekBackward,
      },
      androidCompactActionIndices: const [0, 1, 2],
      processingState: const {
        ProcessingState.idle: AudioProcessingState.idle,
        ProcessingState.loading: AudioProcessingState.loading,
        ProcessingState.buffering: AudioProcessingState.buffering,
        ProcessingState.ready: AudioProcessingState.ready,
        ProcessingState.completed: AudioProcessingState.completed,
      }[_player.processingState] ??
          AudioProcessingState.idle,
      playing: _player.playing,
      updatePosition: _player.position,
      bufferedPosition: _player.bufferedPosition,
      speed: _player.speed,
      queueIndex: event.currentIndex,
    );
  }

  // Streams, die die UI beobachtet. Dauer direkt vom Player — zuverlässiger
  // als mediaItem.duration, das beim Track-Wechsel kurzzeitig null sein kann.
  Stream<Duration> get positionStream => _player.positionStream;
  Stream<Duration?> get durationStream => _player.durationStream;
}