import 'package:audio_service/audio_service.dart';
import 'package:audio_session/audio_session.dart';
import 'package:equalizer/equalizer.dart';
import 'package:fluttertoast/fluttertoast.dart';
import 'package:freezer/api/cache.dart';
import 'package:freezer/api/deezer.dart';
import 'package:freezer/ui/android_auto.dart';
import 'package:just_audio/just_audio.dart';
import 'package:connectivity/connectivity.dart';
import 'package:path/path.dart' as p;
import 'package:path_provider/path_provider.dart';
import 'package:freezer/translations.i18n.dart';
import 'package:scrobblenaut/scrobblenaut.dart';
import 'package:extended_math/extended_math.dart';

import 'definitions.dart';
import '../settings.dart';

import 'dart:io';
import 'dart:async';
import 'dart:convert';
import 'dart:math';


PlayerHelper playerHelper = PlayerHelper();

class PlayerHelper {

  StreamSubscription _customEventSubscription;
  StreamSubscription _mediaItemSubscription;
  StreamSubscription _playbackStateStreamSubscription;
  QueueSource queueSource;
  LoopMode repeatType = LoopMode.off;
  Timer _timer;
  Scrobblenaut scrobblenaut;
  int audioSession;
  int _prevAudioSession;
  bool equalizerOpen = false;

  //Visualizer
  StreamController _visualizerController = StreamController.broadcast();
  Stream get visualizerStream => _visualizerController.stream;

  //Find queue index by id
  int get queueIndex => AudioService.queue == null ? 0 : AudioService.queue.indexWhere((mi) => mi.id == AudioService.currentMediaItem?.id??'Random string so it returns -1');

  Future start() async {
     //Subscribe to custom events
    _customEventSubscription = AudioService.customEventStream.listen((event) async {
      if (!(event is Map)) return;
      switch (event['action']) {
        case 'onLoad':
          //After audio_service is loaded, load queue, set quality
          await settings.updateAudioServiceQuality();
          await AudioService.customAction('load');
          break;
        case 'onRestore':
          //Load queueSource from isolate
          this.queueSource = QueueSource.fromJson(event['queueSource']);
          repeatType = LoopMode.values[event['loopMode']];
          break;
        case 'queueEnd':
          //If last song is played, load more queue
          this.queueSource = QueueSource.fromJson(event['queueSource']);
//          onQueueEnd();
          break;
        case 'screenAndroidAuto':
          AndroidAuto androidAuto = AndroidAuto();
          List<MediaItem> data = await androidAuto.getScreen(event['id']);
          await AudioService.customAction('screenAndroidAuto', jsonEncode(data));
          break;
        case 'tracksAndroidAuto':
          AndroidAuto androidAuto = AndroidAuto();
          await androidAuto.playItem(event['id']);
          break;
        case 'audioSession':
          if (!settings.enableEqualizer) break;
          //Save
          _prevAudioSession = audioSession;
          audioSession = event['id'];
          if (audioSession == null)
            break;
          //Open EQ
          if (!equalizerOpen) {
            Equalizer.open(event['id']);
            equalizerOpen = true;
            break;
          }
          //Change session id
          if (_prevAudioSession != audioSession) {
            if (_prevAudioSession != null) Equalizer.removeAudioSessionId(_prevAudioSession);
            Equalizer.setAudioSessionId(audioSession);
          }
          break;
        //Visualizer data
        case 'visualizer':
          _visualizerController.add(event['data']);
          break;
      }

    });
    _mediaItemSubscription = AudioService.currentMediaItemStream.listen((event) {
      if (event == null) return;
      //Load more flow if index-1 song
      if (queueIndex == AudioService.queue.length-1)
        onQueueEnd();

      //Save queue
      AudioService.customAction('saveQueue');
      //Add to history
      if (cache.history == null) cache.history = [];
      if (cache.history.length > 0 && cache.history.last.id == event.id) return;
      cache.history.add(Track.fromMediaItem(event));
      cache.save();
    });

    //Logging listen timer
    _timer = Timer.periodic(Duration(seconds: 2), (timer) async {
      if (AudioService.currentMediaItem == null || !AudioService.playbackState.playing) return;
      if (AudioService.playbackState.currentPosition.inSeconds > (AudioService.currentMediaItem.duration.inSeconds * 0.75)) {
        if (cache.loggedTrackId == AudioService.currentMediaItem.id) return;
        cache.loggedTrackId = AudioService.currentMediaItem.id;
        await cache.save();

        //Log to Deezer
        if (settings.logListen) {
          deezerAPI.logListen(AudioService.currentMediaItem.id);
        }

        //LastFM
        if (scrobblenaut != null) {
          await scrobblenaut.track.scrobble(
            track: AudioService.currentMediaItem.title,
            artist: AudioService.currentMediaItem.artist,
            album: AudioService.currentMediaItem.album,
          );
        }
      }

    });

    //Start audio_service
    await startService();
  }

  Future startService() async {
    if (AudioService.running && AudioService.connected) return;
    if (!AudioService.connected)
      await AudioService.connect();
    if (!AudioService.running)
      await AudioService.start(
        backgroundTaskEntrypoint: backgroundTaskEntrypoint,
        androidEnableQueue: true,
        androidStopForegroundOnPause: false,
        androidNotificationOngoing: false,
        androidNotificationClickStartsActivity: true,
        androidNotificationChannelDescription: 'Freezer',
        androidNotificationChannelName: 'Freezer',
        androidNotificationIcon: 'drawable/ic_logo',
        params: {'ignoreInterruptions': settings.ignoreInterruptions}
      );
  }

  Future authorizeLastFM() async {
    if (settings.lastFMUsername == null || settings.lastFMPassword == null) return;
    try {
      LastFM lastFM = await LastFM.authenticateWithPasswordHash(
        apiKey: 'b6ab5ae967bcd8b10b23f68f42493829',
        apiSecret: '861b0dff9a8a574bec747f9dab8b82bf',
        username: settings.lastFMUsername,
        passwordHash: settings.lastFMPassword
      );
      scrobblenaut = Scrobblenaut(lastFM: lastFM);
    } catch (e) {}
  }

  Future toggleShuffle() async {
    await AudioService.customAction('shuffle');
  }
  
  //Repeat toggle
  Future changeRepeat() async {
    //Change to next repeat type
    switch (repeatType) {
      case LoopMode.one:
        repeatType = LoopMode.off; break;
      case LoopMode.all:
        repeatType = LoopMode.one; break;
      default:
        repeatType = LoopMode.all; break;
    }
    //Set repeat type
    await AudioService.customAction("repeatType", LoopMode.values.indexOf(repeatType));
  }

  //Executed before exit
  Future onExit() async {
    _customEventSubscription.cancel();
    _playbackStateStreamSubscription.cancel();
    _mediaItemSubscription.cancel();
  }

  //Replace queue, play specified track id
  Future _loadQueuePlay(List<MediaItem> queue, String trackId) async {
    await startService();
    await settings.updateAudioServiceQuality();
    await AudioService.customAction('setIndex', queue.indexWhere((m) => m.id == trackId));
    await AudioService.updateQueue(queue);
//    if (queue[0].id != trackId)
//      await AudioService.skipToQueueItem(trackId);
    if (!AudioService.playbackState.playing)
      AudioService.play();
  }

  //Called when queue ends to load more tracks
  Future onQueueEnd() async {
    //Flow
    if (queueSource == null) return;

    List<Track> tracks = [];
    switch(queueSource.source) {
      case 'flow':
        tracks = await deezerAPI.flow();
        break;
      //SmartRadio/Artist radio
      case 'smartradio':
        tracks = await deezerAPI.smartRadio(queueSource.id);
        break;
      //Library shuffle
      case 'libraryshuffle':
        tracks = await deezerAPI.libraryShuffle(start: AudioService.queue.length);
        break;
      case 'mix':
        tracks = await deezerAPI.playMix(queueSource.id);
        // Deduplicate tracks with the same id
        List<String> queueIds = AudioService.queue.map((e) => e.id).toList();
        tracks.removeWhere((track) => queueIds.contains(track.id));
        break;
      default:
        // print(queueSource.toJson());
        break;
    }

    List<MediaItem> mi = tracks.map<MediaItem>((t) => t.toMediaItem()).toList();
    await AudioService.addQueueItems(mi);
//    AudioService.skipToNext();
  }

  //Play track from album
  Future playFromAlbum(Album album, String trackId) async {
    await playFromTrackList(album.tracks, trackId, QueueSource(
      id: album.id,
      text: album.title,
      source: 'album'
    ));
  }

  //Play mix by track
  Future playMix(String trackId, String trackTitle) async {
    List<Track> tracks = await deezerAPI.playMix(trackId);
    playFromTrackList(tracks, tracks[0].id, QueueSource(
        id: trackId,
        text: 'Mix based on'.i18n + ' $trackTitle',
        source: 'mix'
    ));
  }
  //Play from artist top tracks
  Future playFromTopTracks(List<Track> tracks, String trackId, Artist artist) async {
    await playFromTrackList(tracks, trackId, QueueSource(
      id: artist.id,
      text: 'Top ${artist.name}',
      source: 'topTracks'
    ));
  }
  Future playFromPlaylist(Playlist playlist, String trackId) async {
    await playFromTrackList(playlist.tracks, trackId, QueueSource(
      id: playlist.id,
      text: playlist.title,
      source: 'playlist'
    ));
  }

  //Play episode from show, load whole show as queue
  Future playShowEpisode(Show show, List<ShowEpisode> episodes, {int index = 0}) async {
    QueueSource queueSource = QueueSource(
      id: show.id,
      text: show.name,
      source: 'show'
    );
    //Generate media items
    List<MediaItem> queue = episodes.map<MediaItem>((e) => e.toMediaItem(show)).toList();

    //Load and play
    await startService();
    await settings.updateAudioServiceQuality();
    await setQueueSource(queueSource);
    await AudioService.customAction('setIndex', index);
    await AudioService.updateQueue(queue);
    if (!AudioService.playbackState.playing)
      AudioService.play();
  }

  //Load tracks as queue, play track id, set queue source
  Future playFromTrackList(List<Track> tracks, String trackId, QueueSource queueSource) async {
    await startService();

    List<MediaItem> queue = tracks.map<MediaItem>((track) => track.toMediaItem()).toList();
    await setQueueSource(queueSource);
    await _loadQueuePlay(queue, trackId);
  }

  //Load smart track list as queue, start from beginning
  Future playFromSmartTrackList(SmartTrackList stl) async {
    //Load from API if no tracks
    if (stl.tracks == null || stl.tracks.length == 0) {
      if (settings.offlineMode) {
        Fluttertoast.showToast(
          msg: "Offline mode, can't play flow or smart track lists.".i18n,
          gravity: ToastGravity.BOTTOM,
          toastLength: Toast.LENGTH_SHORT
        );
        return;
      }

      //Flow songs cannot be accessed by smart track list call
      if (stl.id == 'flow') {
        stl.tracks = await deezerAPI.flow();
      } else {
        stl = await deezerAPI.smartTrackList(stl.id);
      }
    }
    QueueSource queueSource = QueueSource(
      id: stl.id,
      source: (stl.id == 'flow')?'flow':'smarttracklist',
      text: stl.title??((stl.id == 'flow') ? 'Flow'.i18n : 'Smart track list'.i18n)
    );
    await playFromTrackList(stl.tracks, stl.tracks[0].id, queueSource);
  }
  
  Future setQueueSource(QueueSource queueSource) async {
    await startService();

    this.queueSource = queueSource;
    await AudioService.customAction('queueSource', queueSource.toJson());
  }

  //Reorder tracks in queue
  Future reorder(int oldIndex, int newIndex) async {
    await AudioService.customAction('reorder', [oldIndex, newIndex]);
  }

  //Start visualizer
  Future startVisualizer() async {
    await AudioService.customAction('startVisualizer');
  }
  //Stop visualizer
  Future stopVisualizer() async {
    await AudioService.customAction('stopVisualizer');
  }

}

void backgroundTaskEntrypoint() async {
  AudioServiceBackground.run(() => AudioPlayerTask());
}

class AudioPlayerTask extends BackgroundAudioTask {
  AudioPlayer _player;

  //Queue
  List<MediaItem> _queue = <MediaItem>[];
  List<MediaItem> _originalQueue;
  bool _shuffle = false;
  int _queueIndex = 0;
  ConcatenatingAudioSource _audioSource;

  AudioProcessingState _skipState;
  Seeker _seeker;

  //Stream subscriptions
  StreamSubscription _eventSub;
  StreamSubscription _audioSessionSub;
  StreamSubscription _visualizerSubscription;

  //Loaded from file/frontend
  int mobileQuality;
  int wifiQuality;
  QueueSource queueSource;
  Duration _lastPosition;
  LoopMode _loopMode = LoopMode.off;

  Completer _androidAutoCallback;

  MediaItem get mediaItem => _queue[_queueIndex];

  @override
  Future onStart(Map<String, dynamic> params) async {

    final session = await AudioSession.instance;
    session.configure(AudioSessionConfiguration.music());

    if (params['ignoreInterruptions'] == true) {
      _player = AudioPlayer(handleInterruptions: false);
      session.interruptionEventStream.listen((_) {});
      session.becomingNoisyEventStream.listen((_) {});
    } else
      _player = AudioPlayer();

    //Update track index
    _player.currentIndexStream.listen((index) {
      if (index != null) {
        _queueIndex = index;
        AudioServiceBackground.setMediaItem(mediaItem);
      }
    });
    //Update state on all clients on change
    _eventSub = _player.playbackEventStream.listen((event) {
      //Quality string
      if (_queueIndex != -1 && _queueIndex < _queue.length) {
        Map extras = mediaItem.extras;
        extras['qualityString'] = '';
        _queue[_queueIndex] = mediaItem.copyWith(extras: extras);
      }
      //Update
      _broadcastState();
    });
    _player.processingStateStream.listen((state) {
        switch(state) {
          case ProcessingState.completed:
            //Player ended, get more songs
            if (_queueIndex == _queue.length - 1)
              AudioServiceBackground.sendCustomEvent({
                'action': 'queueEnd',
                'queueSource': (queueSource??QueueSource()).toJson()
              });
            break;
          case ProcessingState.ready:
            //Ready to play
            _skipState = null;
            break;
          default:
            break;
        }
    });

    //Audio session
    _audioSessionSub = _player.androidAudioSessionIdStream.listen((event) {
      AudioServiceBackground.sendCustomEvent({"action": 'audioSession', "id": event});
    });

    //Load queue
    AudioServiceBackground.setQueue(_queue);
    AudioServiceBackground.sendCustomEvent({'action': 'onLoad'});
  }

  @override
  Future onSkipToQueueItem(String mediaId) async {
    _lastPosition = null;

    //Calculate new index
    final newIndex = _queue.indexWhere((i) => i.id == mediaId);
    if (newIndex == -1) return;
    //Update buffering state
    _skipState = newIndex > _queueIndex
      ? AudioProcessingState.skippingToNext
      : AudioProcessingState.skippingToPrevious;

    //Skip in player
    await _player.seek(Duration.zero, index: newIndex);
    _queueIndex = newIndex;
    _skipState = null;
    onPlay();
  }

  @override
  Future onPlay() {
    _player.play();
    //Restore position on play
    if (_lastPosition != null) {
      onSeekTo(_lastPosition);
      _lastPosition = null;
    }
  }

  @override
  Future onPause() => _player.pause();

  @override
  Future onSeekTo(Duration pos) => _player.seek(pos);

  @override
  Future<void> onFastForward() => _seekRelative(fastForwardInterval);

  @override
  Future<void> onRewind() => _seekRelative(-rewindInterval);

  @override
  Future<void> onSeekForward(bool begin) async => _seekContinuously(begin, 1);

  @override
  Future<void> onSeekBackward(bool begin) async => _seekContinuously(begin, -1);

  //Remove item from queue
  @override
  Future<void> onRemoveQueueItem(MediaItem mediaItem) async {
    int index = _queue.indexWhere((m) => m.id == mediaItem.id);
    _queue.removeAt(index);
    if (index <= _queueIndex) {
      _queueIndex--;
    }
    _audioSource.removeAt(index);

    AudioServiceBackground.setQueue(_queue);
  }

  @override
  Future<void> onSkipToNext() async {
    if (_queueIndex == _queue.length-1) return;
    //Update buffering state
    _skipState = AudioProcessingState.skippingToNext;
    _queueIndex++;
    await _player.seekToNext();
    _skipState = null;
    await _broadcastState();
  }

  @override
  Future<void> onSkipToPrevious() async {
    if (_queueIndex == 0) return;
    //Update buffering state
    _skipState = AudioProcessingState.skippingToPrevious;
    //Normal skip to previous
    _queueIndex--;
    await _player.seekToPrevious();
    _skipState = null;
  }

  @override
  Future<List<MediaItem>> onLoadChildren(String parentMediaId) async {
    AudioServiceBackground.sendCustomEvent({
      'action': 'screenAndroidAuto',
      'id': parentMediaId
    });

    //Wait for data from main thread
    _androidAutoCallback = Completer();
    List<MediaItem> data = (await _androidAutoCallback.future) as List<MediaItem>;
    _androidAutoCallback = null;
    return data;
  }

  //While seeking, jump 10s every 1s
  void _seekContinuously(bool begin, int direction) {
    _seeker?.stop();
    if (begin) {
      _seeker = Seeker(_player, Duration(seconds: 10 * direction), Duration(seconds: 1), mediaItem)..start();
    }
  }

  //Relative seek
  Future _seekRelative(Duration offset) async {
    Duration newPos = _player.position + offset;
    //Out of bounds check
    if (newPos < Duration.zero) newPos = Duration.zero;
    if (newPos > mediaItem.duration) newPos = mediaItem.duration;

    await _player.seek(newPos);
  }

  //Update state on all clients
  Future _broadcastState() async {
    await AudioServiceBackground.setState(
      controls: [
        MediaControl.skipToPrevious,
        if (_player.playing) MediaControl.pause else MediaControl.play,
        MediaControl.skipToNext,
        //Stop
        MediaControl(
            androidIcon: 'drawable/ic_action_stop',
            label: 'stop',
            action: MediaAction.stop
        ),
      ],
      systemActions: [
        MediaAction.seekTo,
        MediaAction.seekForward,
        MediaAction.seekBackward,
        MediaAction.stop
      ],
      processingState: _getProcessingState(),
      playing: _player.playing,
      position: _player.position,
      bufferedPosition: _player.bufferedPosition,
      speed: _player.speed
    );
  }

  //just_audio state -> audio_service state. If skipping, use _skipState
  AudioProcessingState _getProcessingState() {
    if (_skipState != null) return _skipState;
    //SRC: audio_service example
    switch (_player.processingState) {
      case ProcessingState.idle:
        return AudioProcessingState.stopped;
      case ProcessingState.loading:
        return AudioProcessingState.connecting;
      case ProcessingState.buffering:
        return AudioProcessingState.buffering;
      case ProcessingState.ready:
        return AudioProcessingState.ready;
      case ProcessingState.completed:
        return AudioProcessingState.completed;
      default:
        throw Exception("Invalid state: ${_player.processingState}");
    }
  }

  //Replace current queue
  @override
  Future onUpdateQueue(List<MediaItem> q) async {
    //just_audio
    _player.stop();
    if (_audioSource != null) _audioSource.clear();
    //Filter duplicate IDs
    List<MediaItem> queue = [];
    for (MediaItem mi in q) {
      if (queue.indexWhere((m) => mi.id == m.id) == -1)
        queue.add(mi);
    }
    this._queue = queue;
    AudioServiceBackground.setQueue(queue);
    //Load
    await _loadQueue();
    //await _player.seek(Duration.zero, index: 0);
  }

  //Load queue to just_audio
  Future _loadQueue() async {
    //Don't reset queue index by starting player
    int qi = _queueIndex;

    List<AudioSource> sources = [];
    for(int i=0; i<_queue.length; i++) {
      AudioSource s = await _mediaItemToAudioSource(_queue[i]);
      if (s != null)
        sources.add(s);
    }

    _audioSource = ConcatenatingAudioSource(children: sources);
    //Load in just_audio
    try {
      await _player.setAudioSource(_audioSource, initialIndex: qi, initialPosition: Duration.zero);
    } catch (e) {
      //Error loading tracks
    }
    _queueIndex = qi;
    AudioServiceBackground.setMediaItem(mediaItem);
  }

  Future<AudioSource> _mediaItemToAudioSource(MediaItem mi) async {
    String url = await _getTrackUrl(mi);
    if (url == null) return null;
    if (url.startsWith('http')) return ProgressiveAudioSource(Uri.parse(url));
    return AudioSource.uri(Uri.parse(url), tag: mi.id);
  }

  Future _getTrackUrl(MediaItem mediaItem, {int quality}) async {
    //Check if offline
    String _offlinePath = p.join((await getExternalStorageDirectory()).path, 'offline/');
    File f = File(p.join(_offlinePath, mediaItem.id));
    if (await f.exists()) {
      //return f.path;
      //Stream server URL
      return 'http://localhost:36958/?id=${mediaItem.id}';
    }

    //Show episode direct link
    if (mediaItem.extras['showUrl'] != null)
      return mediaItem.extras['showUrl'];

    //Due to current limitations of just_audio, quality fallback moved to DeezerDataSource in ExoPlayer
    //This just returns fake url that contains metadata
    List playbackDetails = jsonDecode(mediaItem.extras['playbackDetails']);
    //Quality
    ConnectivityResult conn = await Connectivity().checkConnectivity();
    quality = mobileQuality;
    if (conn == ConnectivityResult.wifi) quality = wifiQuality;

    if ((playbackDetails??[]).length < 2) return null;
    //String url = 'https://dzcdn.net/?md5=${playbackDetails[0]}&mv=${playbackDetails[1]}&q=${quality.toString()}#${mediaItem.id}';
    String url = 'http://localhost:36958/?q=$quality&mv=${playbackDetails[1]}&md5origin=${playbackDetails[0]}&id=${mediaItem.id}';
    return url;
  }

  //Custom actions
  @override
  Future onCustomAction(String name, dynamic args) async {
    switch (name) {
      case 'updateQuality':
        //Pass wifi & mobile quality by custom action
        //Isolate can't access globals
        this.wifiQuality = args['wifiQuality'];
        this.mobileQuality = args['mobileQuality'];
        break;
      //Update queue source
      case 'queueSource':
        this.queueSource = QueueSource.fromJson(Map<String, dynamic>.from(args));
        break;
      //Looping
      case 'repeatType':
        _loopMode = LoopMode.values[args];
        _player.setLoopMode(_loopMode);
        break;
      //Save queue
      case 'saveQueue':
        await this._saveQueue();
        break;
      //Load queue after some initialization in frontend
      case 'load':
        await this._loadQueueFile();
        break;
      case 'shuffle':
        String originalId = mediaItem.id;
        if (!_shuffle) {
          _shuffle = true;
          _originalQueue = List.from(_queue);
          _queue.shuffle();

        } else {
          _shuffle = false;
          _queue = _originalQueue;
          _originalQueue = null;
        }

        //Broken
//      _queueIndex = _queue.indexWhere((mi) => mi.id == originalId);
        _queueIndex = 0;
        AudioServiceBackground.setQueue(_queue);
        AudioServiceBackground.setMediaItem(mediaItem);
        await _player.stop();
        await _loadQueue();
        await _player.play();
        break;

      //Android audio callback
      case 'screenAndroidAuto':
        if (_androidAutoCallback != null)
          _androidAutoCallback.complete(jsonDecode(args).map<MediaItem>((m) => MediaItem.fromJson(m)).toList());
        break;
      //Reorder tracks, args = [old, new]
      case 'reorder':
        await _audioSource.move(args[0], args[1]);
        //Switch in queue
        List<MediaItem> newQueue = List.from(_queue);
        newQueue.removeAt(args[0]);
        newQueue.insert(args[1], _queue[args[0]]);
        _queue = newQueue;
        //Update UI
        AudioServiceBackground.setQueue(_queue);
        _broadcastState();
        break;
      //Set index without affecting playback for loading
      case 'setIndex':
        this._queueIndex = args;
        break;
      //Start visualizer
      case 'startVisualizer':
        if (_visualizerSubscription != null) break;

        _player.startVisualizer(
          enableWaveform: false,
          enableFft: true,
          captureRate: 15000,
          captureSize: 128
        );
        _visualizerSubscription = _player.visualizerFftStream.listen((event) {
          //Calculate actual values
          List<double> out = [];
          for (int i=0; i<event.length/2; i++) {
            int rfk = event[i*2].toSigned(8);
            int ifk = event[i*2+1].toSigned(8);
            out.add(log(hypot(rfk, ifk) + 1) / 5.2);
          }
          AudioServiceBackground.sendCustomEvent({"action": "visualizer", "data": out});
        });
        break;
      //Stop visualizer
      case 'stopVisualizer':
        if (_visualizerSubscription != null) {
          _visualizerSubscription.cancel();
          _visualizerSubscription = null;
        }
        break;
    }

    return true;
  }

  @override
  Future onTaskRemoved() async {
    await onStop();
  }

  @override
  Future onClose() async {
    print('onClose');
    await onStop();
  }

  Future onStop() async {
    await _saveQueue();
    _player.stop();
    if (_eventSub != null) _eventSub.cancel();
    if (_audioSessionSub != null) _audioSessionSub.cancel();

    await super.onStop();
  }

  //Get queue save file path
  Future<String> _getQueuePath() async {
    Directory dir = await getApplicationDocumentsDirectory();
    return p.join(dir.path, 'playback.json');
  }

  //Export queue to JSON
  Future _saveQueue() async {
    if (_queueIndex == 0 && _queue.length == 0) return;

    String path = await _getQueuePath();
    File f = File(path);
    //Create if doesn't exist
    if (! await File(path).exists()) {
      f = await f.create();
    }
    Map data = {
      'index': _queueIndex,
      'queue': _queue.map<Map<String, dynamic>>((mi) => mi.toJson()).toList(),
      'position': _player.position.inMilliseconds,
      'queueSource': (queueSource??QueueSource()).toJson(),
      'loopMode': LoopMode.values.indexOf(_loopMode??LoopMode.off)
    };
    await f.writeAsString(jsonEncode(data));
  }

  //Restore queue & playback info from path
  Future _loadQueueFile() async {
    File f = File(await _getQueuePath());
    if (await f.exists()) {
      Map<String, dynamic> json = jsonDecode(await f.readAsString());
      this._queue = (json['queue']??[]).map<MediaItem>((mi) => MediaItem.fromJson(mi)).toList();
      this._queueIndex = json['index'] ?? 0;
      this._lastPosition = Duration(milliseconds: json['position']??0);
      this.queueSource = QueueSource.fromJson(json['queueSource']??{});
      this._loopMode = LoopMode.values[(json['loopMode']??0)];
      //Restore queue
      if (_queue != null) {
        await AudioServiceBackground.setQueue(_queue);
        await _loadQueue();
        await AudioServiceBackground.setMediaItem(mediaItem);
      }
    }
    //Send restored queue source to ui
    AudioServiceBackground.sendCustomEvent({
      'action': 'onRestore',
      'queueSource': (queueSource??QueueSource()).toJson(),
      'loopMode': LoopMode.values.indexOf(_loopMode)
    });
    return true;
  }

  @override
  Future onAddQueueItemAt(MediaItem mi, int index) async {
    //-1 == play next
    if (index == -1) index = _queueIndex + 1;

    _queue.insert(index, mi);
    await AudioServiceBackground.setQueue(_queue);
    AudioSource _newSource =  await _mediaItemToAudioSource(mi);
    if (_newSource != null)
      await _audioSource.insert(index,_newSource);

    _saveQueue();
  }

  //Add at end of queue
  @override
  Future onAddQueueItem(MediaItem mi) async {
    if (_queue.indexWhere((m) => m.id == mi.id) != -1)
      return;

    _queue.add(mi);
    await AudioServiceBackground.setQueue(_queue);
    AudioSource _newSource =  await _mediaItemToAudioSource(mi);
    if (_newSource != null)
      await _audioSource.add(_newSource);
    _saveQueue();
  }

  @override
  Future onPlayFromMediaId(String mediaId) async {

    //Android auto load tracks
    if (mediaId.startsWith(AndroidAuto.prefix)) {
      AudioServiceBackground.sendCustomEvent({
        'action': 'tracksAndroidAuto',
        'id': mediaId.replaceFirst(AndroidAuto.prefix, '')
      });
      return;
    }

    //Does the same thing
    await this.onSkipToQueueItem(mediaId);
  }

}

//Seeker from audio_service example (why reinvent the wheel?)
//While holding seek button, will continuously seek
class Seeker {
  final AudioPlayer player;
  final Duration positionInterval;
  final Duration stepInterval;
  final MediaItem mediaItem;
  bool _running = false;

  Seeker(this.player, this.positionInterval, this.stepInterval, this.mediaItem);

  Future start() async {
    _running = true;
    while (_running) {
      Duration newPosition = player.position + positionInterval;
      if (newPosition < Duration.zero) newPosition = Duration.zero;
      if (newPosition > mediaItem.duration) newPosition = mediaItem.duration;
      player.seek(newPosition);
      await Future.delayed(stepInterval);
    }
  }

  void stop() {
    _running = false;
  }
}