// lib/services/audio_service.dart
import 'dart:async';
import 'dart:io';
import 'dart:typed_data';
import 'package:flutter/material.dart';
import 'package:media_kit/media_kit.dart' as media_kit;
import 'package:path_provider/path_provider.dart';
import 'playback_service.dart';
import '../metadata/metadata_service.dart';
import '../database/song_database.dart';
import '../utils/artwork_helper.dart';
import '../repositories/playlist_repository.dart';
import '../models/playlist.dart';
import 'webdav_service.dart';

enum PlayMode {
  sequential,
  repeatOne,
  shuffle,
}

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

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

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;

  // ---- 当前播放的歌单 ID ----
  String? _currentPlaylistId;

  // ---- 高频进度 ----
  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;
  bool _isChangingTrack = false;
  bool _hasStartedCurrentPlayback = false;
  bool _isUserSeeking = false;

  int _playbackGeneration = 0;

  void Function(Song)? _onSongChanged;

  // ---- Repository ----
  final SongDatabase _db = SongDatabase();
  final PlaylistRepository _playlistRepo = PlaylistRepository();

  // ---- 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;
  String? get currentPlaylistId => _currentPlaylistId;

  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();

    if (_currentPlaylistId != null) {
      _playlistRepo.updatePlaylistPlayMode(_currentPlaylistId!, _playMode);
    }
  }

  // ════════════════════════════════════════════════════════════
  // 队列管理
  // ════════════════════════════════════════════════════════════

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

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

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

    await _playCurrent();
  }

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

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

  // ════════════════════════════════════════════════════════════
  // 歌单
  // ════════════════════════════════════════════════════════════

  Future<void> playPlaylist(String playlistId, {int startIndex = 0}) async {
    _currentPlaylistId = playlistId;

    final playlist = await _playlistRepo.getPlaylist(playlistId);
    if (playlist != null) {
      _playMode = playlist.playMode;
    }

    final songIds = await _playlistRepo.getPlaylistSongIds(playlistId);
    if (songIds.isEmpty) return;

    final songs = <Song>[];
    for (final id in songIds) {
      final dbSong = await _db.getSongByPath(id);
      if (dbSong != null) {
        songs.add(Song(
          id: dbSong['remote_path'] as String,
          title: dbSong['title'] as String? ?? '',
          artist: dbSong['artist'] as String? ?? '未知艺术家',
          url: dbSong['remote_path'] as String,
        ));
      } else {
        songs.add(Song(
          id: id,
          title: id.split('/').last.replaceAll(RegExp(r'\.[^.]*$'), ''),
          artist: '未知艺术家',
          url: id,
        ));
      }
    }

    if (songs.isNotEmpty) {
      await setQueue(songs, startIndex: startIndex);
    }
  }

  Future<Playlist> saveQueueAsPlaylist(String name) async {
    final playlist = await _playlistRepo.createPlaylist(name);
    for (int i = 0; i < _queue.length; i++) {
      final song = _queue[i];
      await _playlistRepo.addSong(playlist.id, song.id);
    }
    return playlist;
  }

  // ════════════════════════════════════════════════════════════
  // ⭐ 播放核心
  // ════════════════════════════════════════════════════════════

  Future<void> _playCurrent() async {
    if (_isChangingTrack) {
      debugPrint('⚠️ [AudioService] track switch already running');
      return;
    }

    if (_currentIndex < 0 || _currentIndex >= _queue.length) {
      stopPlay();
      return;
    }

    _isChangingTrack = true;
    _handlingCompletion = false;
    _hasStartedCurrentPlayback = false;

    try {
      _playbackGeneration++;
      final generation = _playbackGeneration;

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

      _startListening();
      notifyListeners();

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

      await _playWithHeaders(song.url!);
      await _waitForPlaybackStarted();

      _syncPlayerStateDelayed();

      if (_hasStartedCurrentPlayback) {
        _onSongChanged?.call(song);
        _loadMetadataForCurrentSong(generation);
      }
    } finally {
      _isChangingTrack = false;
    }
  }

  Future<void> _waitForPlaybackStarted() async {
    final player = PlaybackService().player;

    if (player.state.playing) {
      _hasStartedCurrentPlayback = true;
      debugPrint('🎵 [AudioService] playback already started');
      return;
    }

    try {
      await player.stream.playing
          .where((playing) => playing == true)
          .first
          .timeout(const Duration(seconds: 3));
      _hasStartedCurrentPlayback = true;
      debugPrint('🎵 [AudioService] playback started');
    } catch (e) {
      debugPrint('⚠️ [AudioService] wait for playback timeout: $e');
      _hasStartedCurrentPlayback = true;
    }
  }

  Future<void> _playWithHeaders(String url) async {
    final headers = await _getAuthHeadersForUrl(url);
    await PlaybackService().play(url, headers: headers);
  }

  Future<Map<String, String>> _getAuthHeadersForUrl(String url) async {
    if (url.startsWith('http://') || url.startsWith('https://')) {
      try {
        final headers = await WebDAVService.instance.getAuthHeaders();
        if (headers.isNotEmpty) {
          debugPrint('🔑 [AudioService] 已添加认证头到播放请求');
          return headers;
        }
      } catch (e) {
        debugPrint('⚠️ [AudioService] 获取认证头失败: $e');
      }
    }
    return {};
  }

  String _generateSongKey(String url, int fileSize, int modifiedTime) {
    final raw = '$url|$fileSize|$modifiedTime';
    return raw.hashCode.toString();
  }

  // ════════════════════════════════════════════════════════════
  // ⭐ Metadata 加载（四层校验）
  // ════════════════════════════════════════════════════════════

  Future<void> _loadMetadataForCurrentSong(int generation) async {
    if (_currentIndex < 0 || _currentIndex >= _queue.length) return;

    final currentIndex = _currentIndex;
    final song = _queue[currentIndex];
    final songId = song.id;

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

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

      // 第一层：generation 校验
      if (_playbackGeneration != generation) {
        debugPrint('⚠️ [AudioService] metadata stale (generation)');
        return;
      }

      // 第二层：索引校验
      if (_currentIndex != currentIndex) {
        debugPrint('⚠️ [AudioService] metadata stale (index changed)');
        return;
      }

      // 第三层：歌曲 ID 校验
      if (_currentIndex >= _queue.length ||
          _queue[_currentIndex].id != songId) {
        debugPrint('⚠️ [AudioService] metadata stale (song changed)');
        return;
      }

      // ⭐ 第四层：_currentSong 校验（防止状态不同步）
      if (_currentSong == null || _currentSong!.id != songId) {
        debugPrint('⚠️ [AudioService] metadata stale: current song mismatch');
        return;
      }

      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,
          artwork: metadata.artwork,
        );
        _queue[_currentIndex] = updatedSong;
        _currentSong = updatedSong;
        notifyListeners();

        _onSongChanged?.call(updatedSong);
        debugPrint(
            '✅ [AudioService] metadata updated: ${updatedSong.title} - ${updatedSong.artist} (gen $generation)');
      }
    } catch (e) {
      debugPrint('⚠️ [AudioService] metadata load failed: $e');
      _onSongChanged?.call(song);
    }
  }

  Future<void> clearCurrentSongCache() async {
    if (_currentSong == null) return;
    final song = _currentSong!;
    final url = song.url ?? '';
    if (url.isEmpty) return;

    debugPrint('🗑️ [AudioService] clearing cache for: ${song.title}');

    final currentIndex = _currentIndex;

    String songKey;
    try {
      final provider = MetadataService().getProviderForUrl(url);
      final file = await provider.getFile(url);
      if (file != null && await file.exists()) {
        final stat = await file.stat();
        songKey = _generateSongKey(
            url, stat.size, stat.modified.millisecondsSinceEpoch);
      } else {
        songKey = url.hashCode.toString();
      }
    } catch (e) {
      songKey = url.hashCode.toString();
    }

    final db = SongDatabase();
    await db.deleteSong(songKey);
    await db.deleteCache(songKey);
    debugPrint('🗑️ [AudioService] SQLite records deleted: $songKey');

    await ArtworkHelper.deleteArtwork(songKey);
    debugPrint('🗑️ [AudioService] artwork deleted');

    try {
      final cacheDir = await getTemporaryDirectory();
      final cachePath = '${cacheDir.path}/metadata_${url.hashCode}.tmp';
      final cacheFile = File(cachePath);
      if (await cacheFile.exists()) {
        await cacheFile.delete();
        debugPrint('🗑️ [AudioService] temp cache file deleted');
      }
    } catch (e) {
      // 忽略
    }

    await MetadataService().clearCache(song.id);
    debugPrint('🗑️ [AudioService] memory cache cleared');

    if (currentIndex >= 0 && currentIndex < _queue.length) {
      stopPlay();
      await _playCurrent();
      debugPrint('🔄 [AudioService] song reloaded');
    }
  }

  // ════════════════════════════════════════════════════════════
  // ⭐ 上一首 / 下一首（带防并发）
  // ════════════════════════════════════════════════════════════

  Future<void> next() async {
    if (_queue.isEmpty) return;

    // ⭐ 如果正在切换歌曲，忽略本次请求
    if (_isChangingTrack) {
      debugPrint('⚠️ [AudioService] next() ignored: track switch in progress');
      return;
    }

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

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

  Future<void> previous() async {
    if (_queue.isEmpty) return;

    if (_isChangingTrack) {
      debugPrint(
          '⚠️ [AudioService] previous() ignored: track switch in progress');
      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];
      await _playCurrent();
      return;
    }

    final prevIdx = (_currentIndex - 1) % _queue.length;
    if (prevIdx < 0) {
      _currentIndex = _queue.length - 1;
    } else {
      _currentIndex = prevIdx;
    }
    await _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) {
    _isUserSeeking = true;
    PlaybackService().seek(position);
    positionNotifier.value = position;

    Future.delayed(const Duration(milliseconds: 800), () {
      _isUserSeeking = false;
    });
  }

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

  void syncPlayerStateNow() {
    final player = PlaybackService().player;
    final pos = player.state.position;
    final dur = player.state.duration;
    final buf = player.state.buffer;

    debugPrint(
        '🎯 [AudioService] syncPlayerStateNow: pos=$pos, dur=$dur, buf=$buf');

    if (pos.inMilliseconds >= 0) {
      positionNotifier.value = pos;
    }
    if (dur.inMilliseconds > 0) {
      durationNotifier.value = dur;
    }
    if (buf.inMilliseconds >= 0) {
      bufferedNotifier.value = buf;
    }
  }

  void _syncPlayerStateDelayed() {
    syncPlayerStateNow();
    Future.delayed(const Duration(milliseconds: 200), () {
      syncPlayerStateNow();
    });
    Future.delayed(const Duration(milliseconds: 500), () {
      syncPlayerStateNow();
    });
  }

  // ---- 监听 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) {
        if (_isUserSeeking) {
          debugPrint('🎯 [AudioService] positionStream ignored: user seeking');
          return;
        }
        positionNotifier.value = position;
      }),
    );

    _subscriptions.add(
      player.stream.duration.listen((duration) {
        debugPrint('🎯 [AudioService] durationStream: $duration');
        if (duration.inMilliseconds > 0) {
          durationNotifier.value = duration;
        }
      }),
    );

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

    // ⭐ 完整生命周期校验的 completed 监听
    _subscriptions.add(
      player.stream.completed.listen((_) {
        if (_isChangingTrack) {
          debugPrint('⚠️ [AudioService] completed ignored during track switch');
          return;
        }

        if (!_hasStartedCurrentPlayback) {
          debugPrint(
              '⚠️ [AudioService] completed ignored: playback never started');
          return;
        }

        if (_handlingCompletion) {
          debugPrint('⚠️ [service] completed ignored: already handling');
          return;
        }

        final pos = player.state.position;
        final dur = player.state.duration;
        if (dur.inMilliseconds <= 0) {
          debugPrint(
              '⚠️ [AudioService] completed ignored: invalid duration $dur');
          return;
        }

        if (pos.inMilliseconds < dur.inMilliseconds - 500) {
          debugPrint(
              '⚠️ [AudioService] completed ignored: position=$pos, duration=$dur');
          return;
        }

        debugPrint(
            '🎵 [AudioService] valid completed: index=$_currentIndex, pos=$pos, dur=$dur');
        _handlingCompletion = true;
        _onPlaybackCompleted();
      }),
    );
  }

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

  void _onPlaybackCompleted() {
    if (_queue.isEmpty || _currentIndex < 0 || _currentIndex >= _queue.length) {
      debugPrint('⚠️ [service] completed ignored: invalid queue');
      _handlingCompletion = false;
      return;
    }

    if (_currentIndex + 1 >= _queue.length && _playMode != PlayMode.repeatOne) {
      debugPrint('⚠️ [service] completed ignored: last song in queue');
      _handlingCompletion = false;
      return;
    }

    try {
      if (_playMode == PlayMode.repeatOne) {
        _playCurrent();
        return;
      }
      next();
    } finally {
      _handlingCompletion = false;
    }
  }

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