melo-app/lib/services/player_service.dart

import 'dart:async';
import 'dart:io';
import 'package:flutter/foundation.dart';
import 'package:just_audio/just_audio.dart';
import '../models/song.dart';
import '../database/db_helper.dart';
import 'melo_logger.dart';

class PlayerService {
  static final PlayerService _instanz = PlayerService._();
  factory PlayerService() => _instanz;
  PlayerService._();

  AudioPlayer? _player;
  final List<Song> _warteschlange = [];
  int _aktuellerIndex = -1;
  StreamSubscription<PlayerState>? _autoNextSub;

  AudioPlayer get _p {
    if (_player == null) {
      _player = AudioPlayer();
      _autoNextSub = _player!.playerStateStream.listen((state) {
        if (state.processingState == ProcessingState.completed) {
          naechstes();
        } else if (state.processingState == ProcessingState.idle &&
            _aktuellerIndex >= 0 &&
            _aktuellerIndex < _warteschlange.length) {
          final song = _warteschlange[_aktuellerIndex];
          // Nur markieren wenn kein Stream (Stream-Fehler sind oft temporär)
          if (song.streamUrl == null || song.streamUrl!.isEmpty) {
            _markiereAlsKorrupt(song);
          }
        }
      });
    }
    return _player!;
  }

  Song? get aktuellerSong => _aktuellerIndex >= 0 && _aktuellerIndex < _warteschlange.length
    ? _warteschlange[_aktuellerIndex] : null;
  bool get spieltAb => _player?.playing ?? false;
  Duration get position => _player?.position ?? Duration.zero;
  Duration get dauer => _player?.duration ?? Duration.zero;
  Stream<Duration> get positionStream => _p.positionStream;
  Stream<PlayerState> get stateStream => _p.playerStateStream;

  final StreamController<Song?> _songWechsel = StreamController.broadcast();
  Stream<Song?> get onSongWechsel => _songWechsel.stream;

  Future<void> spiele(Song song, {int position = 0}) async {
    _aktuellerIndex = _warteschlange.indexWhere((s) => s.id == song.id);
    if (_aktuellerIndex < 0) {
      _warteschlange.add(song);
      _aktuellerIndex = _warteschlange.length - 1;
    }
    try {
      if (song.streamUrl != null && song.streamUrl!.isNotEmpty) {
        // Streaming vom Server
        await _p.setUrl(song.streamUrl!);
      } else if (song.dateiPfad.isNotEmpty && await File(song.dateiPfad).exists()) {
        // Lokale Datei
        await _p.setFilePath(song.dateiPfad);
      } else {
        MeloLogger().fehler('player_keine_quelle', 'Keine gültige Quelle für: ${song.titel}');
        return;
      }
      if (position > 0) await _p.seek(Duration(seconds: position));
      await _p.play();
      _songWechsel.add(song);
      // Abspiel-Historie für den Jahres-Recap registrieren
      if (song.id != null) {
        try {
          await DbHelper().abspielRegistrieren(song.id!);
        } catch (e) {
          debugPrint('Abspiel-Historie fehlgeschlagen: $e');
        }
      }
    } catch (e) {
      debugPrint('Fehler beim Abspielen: $e');
      MeloLogger().fehler('player_abspiel_fehler', e);
      // Song als korrupt markieren wenn lokale Datei
      if (song.streamUrl == null || song.streamUrl!.isEmpty) {
        _markiereAlsKorrupt(song);
      }
    }
  }

  Future<void> playPause() async {
    if (_player == null) return;
    if (_p.playing) {
      await _p.pause();
    } else if (aktuellerSong != null) {
      await _p.play();
    }
  }

  /// Explizit abspielen (kein Toggle) — für System-Controls (Bluetooth, etc.)
  Future<void> play() async {
    if (_player == null || aktuellerSong == null) return;
    await _p.play();
  }

  /// Explizit pausieren (kein Toggle) — für System-Controls (Bluetooth, etc.)
  Future<void> pause() async {
    if (_player == null) return;
    await _p.pause();
  }

  /// Nur seeken ohne Reload der Quelle
  Future<void> seek(Duration position) async {
    if (_player == null) return;
    await _p.seek(position);
  }

  Future<void> vorheriges() async {
    if (_player == null || aktuellerSong == null) return;
    final pos = _p.position;
    if (pos.inSeconds > 5) {
      await _p.seek(Duration.zero);
    } else {
      final neuerIndex = _aktuellerIndex - 1;
      if (neuerIndex >= 0) {
        await spiele(_warteschlange[neuerIndex]);
      }
    }
  }

  Future<void> naechstes() async {
    final neuerIndex = _aktuellerIndex + 1;
    if (neuerIndex < _warteschlange.length) {
      await spiele(_warteschlange[neuerIndex]);
    }
  }

  void setWarteschlange(List<Song> songs, {int startIndex = 0}) {
    _warteschlange.clear();
    _warteschlange.addAll(songs);
    _aktuellerIndex = startIndex;
  }

  void dispose() {
    _autoNextSub?.cancel();
    _player?.dispose();
    _player = null;
    _songWechsel.close();
  }

  /// Markiert den aktuellen Song in der DB als korrupt
  Future<void> _markiereAlsKorrupt(Song song) async {
    if (song.id == null) return;
    try {
      final db = DbHelper();
      final s = await db.songNachId(song.id!);
      if (s != null && !s.istKorrupt) {
        await db.alsKorruptMarkieren(song.id!);
        debugPrint('⚠️ Song als korrupt markiert: ${song.titel}');
        MeloLogger().fehler('korrupt_markiert', 'Playback-Fehler: ${song.titel} (${song.dateiPfad})');
      }
    } catch (e) {
      debugPrint('Korrupt-Markierung fehlgeschlagen: $e');
    }
  }
}