QingTing-Player/lib/services/audio_service.dart

// lib/services/audio_service.dart
import 'dart:async';
import 'package:flutter/material.dart';
import 'package:media_kit/media_kit.dart';
import 'playback_service.dart';
import '../metadata/metadata_service.dart';

enum PlayMode {
  sequential,
  repeatOne,
  shuffle,
}

class Song {
  final String id;
  final String title;
  final String artist;
  final String? url;

  Song({
    required this.id,
    required this.title,
    required this.artist,
    this.url,
  });
}

class AudioService extends ChangeNotifier {
  static final AudioService _instance = AudioService._internal();
  factory AudioService() => _instance;
  AudioService._internal();

  // ---- 基础状态 ----
  Song? _currentSong;
  bool _isPlaying = false;
  PlayMode _playMode = PlayMode.sequential;

  // ---- 播放队列 ----
  List<Song> _queue = [];
  int _currentIndex = -1;
  List<int> _shuffledIndices = [];
  int _shuffledIndex = -1;

  // ---- 高频进度 ----
  final ValueNotifier<Duration> positionNotifier = ValueNotifier(Duration.zero);
  final ValueNotifier<Duration> durationNotifier = ValueNotifier(Duration.zero);
  final ValueNotifier<Duration> bufferedNotifier = ValueNotifier(Duration.zero);

  bool _listening = false;
  final List<StreamSubscription> _subscriptions = [];

  bool _handlingCompletion = false;
  void Function(Song)? _onSongChanged;

  // ---- Getter ----
  Song? get currentSong => _currentSong;
  bool get isPlaying => _isPlaying;
  PlayMode get playMode => _playMode;
  List<Song> get queue => List.unmodifiable(_queue);
  int get currentIndex => _currentIndex;
  bool get hasQueue => _queue.isNotEmpty;

  Duration get position => positionNotifier.value;
  Duration get duration => durationNotifier.value;
  Duration get bufferedPosition => bufferedNotifier.value;

  IconData get playModeIcon {
    switch (_playMode) {
      case PlayMode.sequential:
        return Icons.repeat;
      case PlayMode.repeatOne:
        return Icons.repeat_one;
      case PlayMode.shuffle:
        return Icons.shuffle;
    }
  }

  void setOnSongChanged(void Function(Song) callback) {
    _onSongChanged = callback;
  }

  void togglePlayMode() {
    switch (_playMode) {
      case PlayMode.sequential:
        _playMode = PlayMode.repeatOne;
        break;
      case PlayMode.repeatOne:
        _playMode = PlayMode.shuffle;
        break;
      case PlayMode.shuffle:
        _playMode = PlayMode.sequential;
        break;
    }
    notifyListeners();
  }

  void setQueue(List<Song> queue, {int startIndex = 0}) {
    if (queue.isEmpty) {
      _clearQueue();
      return;
    }

    _queue = List.from(queue);
    _currentIndex = startIndex.clamp(0, _queue.length - 1);

    _shuffledIndices = List.generate(_queue.length, (i) => i);
    _shuffledIndices.shuffle();
    _shuffledIndex = _shuffledIndices.indexOf(_currentIndex);
    if (_shuffledIndex == -1) {
      _shuffledIndex = 0;
      _currentIndex = _shuffledIndices[0];
    }

    _playCurrent();
  }

  void _clearQueue() {
    _queue.clear();
    _currentIndex = -1;
    _shuffledIndices.clear();
    _shuffledIndex = -1;
    stopPlay();
  }

  Future<void> playSong(Song song) async {
    if (_queue.isEmpty || _queue[_currentIndex].id != song.id) {
      setQueue([song], startIndex: 0);
    } else {
      _playCurrent();
    }
  }

  // ============================================================
  // 核心播放逻辑
  // ============================================================
  void _playCurrent() {
    if (_currentIndex < 0 || _currentIndex >= _queue.length) {
      stopPlay();
      return;
    }

    final song = _queue[_currentIndex];
    _currentSong = song;

    // ⭐ 不重置任何 Notifier，完全依赖 stream 推送
    // position / duration / buffered 由播放器自然更新

    _startListening();
    notifyListeners();

    if (song.url == null || song.url!.isEmpty) {
      return;
    }

    PlaybackService().play(song.url!);

    // ⭐ 兜底：主动同步一次播放器状态（解决首次加载时 stream 未推送的问题）
    _syncPlayerStateDelayed();

    _loadMetadataForCurrentSong();
  }

  // ============================================================
  // Metadata 加载
  // ============================================================
  Future<void> _loadMetadataForCurrentSong() async {
    if (_currentIndex < 0 || _currentIndex >= _queue.length) return;
    final song = _queue[_currentIndex];
    if (song.url == null || song.url!.isEmpty) return;

    try {
      final metadata = await MetadataService().getMetadata(
        url: song.url!,
        fileName: song.title,
        fileId: song.id,
      );

      if (metadata.isNotEmpty) {
        final updatedSong = Song(
          id: song.id,
          title: metadata.title.isNotEmpty ? metadata.title : song.title,
          artist: metadata.artist.isNotEmpty ? metadata.artist : song.artist,
          url: song.url,
        );
        _queue[_currentIndex] = updatedSong;
        _currentSong = updatedSong;
        notifyListeners();
        _onSongChanged?.call(updatedSong);
      }
    } catch (e) {
      debugPrint('⚠️ [AudioService] metadata load failed: $e');
    }
  }

  // ============================================================
  // 播放控制
  // ============================================================
  void next() {
    if (_queue.isEmpty) return;

    if (_playMode == PlayMode.shuffle) {
      if (_shuffledIndices.isEmpty) return;
      final nextIdx = (_shuffledIndex + 1) % _shuffledIndices.length;
      _shuffledIndex = nextIdx;
      _currentIndex = _shuffledIndices[nextIdx];
      _playCurrent();
      return;
    }

    final nextIdx = (_currentIndex + 1) % _queue.length;
    _currentIndex = nextIdx;
    _playCurrent();
  }

  void previous() {
    if (_queue.isEmpty) return;

    if (_playMode == PlayMode.shuffle) {
      if (_shuffledIndices.isEmpty) return;
      final prevIdx = (_shuffledIndex - 1) % _shuffledIndices.length;
      if (prevIdx < 0) {
        _shuffledIndex = _shuffledIndices.length - 1;
      } else {
        _shuffledIndex = prevIdx;
      }
      _currentIndex = _shuffledIndices[_shuffledIndex];
      _playCurrent();
      return;
    }

    final prevIdx = (_currentIndex - 1) % _queue.length;
    if (prevIdx < 0) {
      _currentIndex = _queue.length - 1;
    } else {
      _currentIndex = prevIdx;
    }
    _playCurrent();
  }

  void togglePlay() {
    if (_currentSong == null) return;

    if (_isPlaying) {
      PlaybackService().pause();
    } else {
      PlaybackService().resume();
    }
  }

  void stopPlay() {
    _currentSong = null;
    _isPlaying = false;
    positionNotifier.value = Duration.zero;
    durationNotifier.value = Duration.zero;
    bufferedNotifier.value = Duration.zero;
    _stopListening();
    notifyListeners();
  }

  void seekTo(Duration position) {
    PlaybackService().seek(position);
    positionNotifier.value = position;
  }

  void clearQueue() {
    _queue.clear();
    _currentIndex = -1;
    _shuffledIndices.clear();
    _shuffledIndex = -1;
    stopPlay();
    notifyListeners();
  }

  // ============================================================
  // 播放器状态同步（兜底机制）
  // ============================================================
  void _syncPlayerStateDelayed() {
    _syncPlayerStateNow();
    Future.delayed(const Duration(milliseconds: 200), () {
      _syncPlayerStateNow();
    });
    Future.delayed(const Duration(milliseconds: 500), () {
      _syncPlayerStateNow();
    });
  }

  void _syncPlayerStateNow() {
    final player = PlaybackService().player;
    final dur = player.state.duration;
    final buf = player.state.buffer;

    if (dur.inMilliseconds > 0 && durationNotifier.value.inMilliseconds == 0) {
      durationNotifier.value = dur;
      debugPrint('🎯 [AudioService] sync duration: $dur');
    }

    if (buf.inMilliseconds > 0 && bufferedNotifier.value.inMilliseconds == 0) {
      bufferedNotifier.value = buf;
      debugPrint('🎯 [AudioService] sync buffer: $buf');
    }
  }

  // ============================================================
  // media_kit 状态监听
  // ============================================================
  void _startListening() {
    if (_listening) return;
    _listening = true;

    final player = PlaybackService().player;

    _subscriptions.add(
      player.stream.playing.listen((playing) {
        if (_isPlaying != playing) {
          _isPlaying = playing;
          notifyListeners();
        }
      }),
    );

    _subscriptions.add(
      player.stream.position.listen((position) {
        positionNotifier.value = position;
      }),
    );

    _subscriptions.add(
      player.stream.duration.listen((duration) {
        debugPrint('🎯 [AudioService] durationStream: $duration');
        // 只接受 > 0 的值，避免 0 覆盖正确值
        if (duration.inMilliseconds > 0) {
          durationNotifier.value = duration;
        }
      }),
    );

    _subscriptions.add(
      player.stream.buffer.listen((buffer) {
        bufferedNotifier.value = buffer;
      }),
    );

    _subscriptions.add(
      player.stream.completed.listen((_) {
        _onPlaybackCompleted();
      }),
    );
  }

  void _stopListening() {
    _listening = false;
    for (final subscription in _subscriptions) {
      subscription.cancel();
    }
    _subscriptions.clear();
  }

  // ============================================================
  // 播放完成处理
  // ============================================================
  void _onPlaybackCompleted() {
    if (_handlingCompletion) {
      debugPrint('⚠️ [service] completed ignored: already handling');
      return;
    }
    _handlingCompletion = true;
    try {
      if (_queue.isEmpty) return;
      if (_playMode == PlayMode.repeatOne) {
        _playCurrent();
        return;
      }
      next();
    } finally {
      _handlingCompletion = false;
    }
  }

  @override
  void dispose() {
    _stopListening();
    positionNotifier.dispose();
    durationNotifier.dispose();
    bufferedNotifier.dispose();
    PlaybackService().dispose();
    super.dispose();
  }
}