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 '../services/cache_manager.dart';
import '../services/navidrome_service.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;
}

/// Entscheidet, ob für den Titel an [newIndex] eine Wiedergabe gezählt wird.
/// Gezählt wird jeder Titelwechsel; eine Wiederholung desselben Titels
/// (LoopMode.one) zählt bewusst nicht erneut.
bool shouldCountPlay(int? newIndex, int? lastCountedIndex) =>
    newIndex != null && newIndex != lastCountedIndex;

/// 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;
  late final CacheManager _cache;
  final NavidromeService _nav = NavidromeService();
  int? _lastCountedIndex;

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

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

    // 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));
        if (shouldCountPlay(index, _lastCountedIndex)) {
          _lastCountedIndex = index;
          final songId = q[index].extras?['songId'] as String?;
          if (songId != null) db.incrementPlayCount(songId);
        }
      }
    });

    // 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].
  /// Auto-Caching: Streame von Server + speichere lokal gleichzeitig.
  Future<void> loadPlaylist(List<MediaItem> items, {int startIndex = 0}) async {
    queue.add(items);
    // Neue Warteschlange: der erste Titel soll wieder zählen, auch wenn er
    // denselben Index wie der zuletzt gezählte hat.
    _lastCountedIndex = null;
    await _nav.ladeGespeicherteZugangsdaten();

    final sources = <AudioSource>[];
    for (final item in items) {
      Uri sourceUri = Uri.parse(item.id);

      if (_nav.istVerbunden) {
        final cachedUri = await _nav.streamAndCacheToLocal(item.id, _cache);
        if (cachedUri != null) {
          sourceUri = cachedUri;
        }
      }

      sources.add(AudioSource.uri(sourceUri, tag: item));
    }

    await _player.setAudioSources(sources, initialIndex: startIndex);

    // Bei bekannter letzter Position an dieser Stelle fortsetzen,
    // statt immer von vorne zu beginnen. Priorisiert Server-Position über lokal.
    final item = items[startIndex];
    final songId = item.extras?['songId'] as String?;
    if (songId != null) {
      int? resumeMs;

      if (_nav.istVerbunden) {
        final serverMs = await _nav.getBookmark(songId);
        if (serverMs != null && shouldResumeAt(serverMs, item.duration)) {
          resumeMs = serverMs;
        }
      }

      if (resumeMs == null) {
        final localMs = await db.lastPosition(songId);
        if (localMs != null && shouldResumeAt(localMs, item.duration)) {
          resumeMs = localMs;
        }
      }

      if (resumeMs != null) {
        await _player.seek(Duration(milliseconds: resumeMs), 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;
}