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/api/deezer_audio_source.dart';
import 'package:freezer/api/offline_audio_source.dart';
import 'package:freezer/api/url_audio_source.dart';
import 'package:freezer/ui/android_auto.dart';
import 'package:hive_flutter/hive_flutter.dart';
import 'package:just_audio/just_audio.dart';
import 'package:connectivity_plus/connectivity_plus.dart';
import 'package:logging/logging.dart';
import 'package:path/path.dart' as p;
import 'package:path_provider/path_provider.dart';
import 'package:freezer/translations.i18n.dart';
import 'package:collection/collection.dart';
import 'package:scrobblenaut/scrobblenaut.dart';
import 'package:rxdart/rxdart.dart';

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

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

PlayerHelper playerHelper = PlayerHelper();
late AudioHandler audioHandler;

class PlayerHelper {
  late StreamSubscription _customEventSubscription;
  late StreamSubscription _mediaItemSubscription;
  late StreamSubscription _playbackStateStreamSubscription;
  QueueSource? queueSource;
  AudioServiceRepeatMode repeatType = AudioServiceRepeatMode.none;
  Timer? _timer;
  int? audioSession;
  int? _prevAudioSession;
  bool equalizerOpen = false;
  bool _shuffleEnabled = false;
  int _queueIndex = 0;
  bool _started = false;

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

  final _streamInfoSubject = BehaviorSubject<StreamQualityInfo>();
  ValueStream<StreamQualityInfo> get streamInfo => _streamInfoSubject.stream;

  /// Find queue index by id
  ///
  /// The function gets more expensive the longer the queue is and the further the element is from the beginning.
  int getQueueIndexFromId() => audioHandler.mediaItem.value == null
      ? -1
      : audioHandler.queue.value
          .indexWhere((mi) => mi.id == audioHandler.mediaItem.value!.id);

  int getQueueIndex() =>
      audioHandler.playbackState.value.queueIndex ?? getQueueIndexFromId();

  int get queueIndex => _queueIndex;

  Future<void> initAudioHandler() async {
    // initialize our audiohandler instance
    audioHandler = await AudioService.init(
      builder: () => AudioPlayerTask(
          ignoreInterruptions: settings.ignoreInterruptions,
          deezerAPI: deezerAPI),
      config: AudioServiceConfig(
        notificationColor: settings.primaryColor,
        androidStopForegroundOnPause: false,
        androidNotificationOngoing: false,
        androidNotificationClickStartsActivity: true,
        androidNotificationChannelDescription: 'Freezer',
        androidNotificationChannelName: 'Freezer',
        androidNotificationIcon: 'drawable/ic_logo',
        preloadArtwork: false,
      ),
    );
  }

  Future<void> start() async {
    if (_started) return;
    _started = true;
    //Subscribe to custom events
    _customEventSubscription = audioHandler.customEvent.listen((event) async {
      if (!(event is Map)) return;
      Logger('PlayerHelper').fine("event received: " + event['action']);
      switch (event['action']) {
        case 'onLoad':
          //After audio_service is loaded, load queue, set quality
          await settings.updateAudioServiceQuality();
          await audioHandler.customAction('load');
          await authorizeLastFM();
          break;
        case 'onRestore':
          //Load queueSource from isolate
          queueSource = event['queueSource'] as QueueSource;
          repeatType = event['repeatMode'] as AudioServiceRepeatMode;
          _queueIndex = getQueueIndex();
          break;
        case 'screenAndroidAuto':
          List<MediaItem> data = await androidAuto.getScreen(event['id']);
          await audioHandler.customAction('screenAndroidAuto', {'value': data});
          break;
        case 'tracksAndroidAuto':
          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;
        case 'streamInfo':
          Logger('PlayerHelper').fine("streamInfo received");
          _streamInfoSubject.add(event['data'] as StreamQualityInfo);
          break;
      }
    });
    _mediaItemSubscription = audioHandler.mediaItem.listen((mediaItem) async {
      if (mediaItem == null) return;
      _queueIndex = getQueueIndex();
      //Load more flow if last song (not using .last since it iterates through previous elements first)

      //Save queue
      await audioHandler.customAction('saveQueue', {});
      //Add to history
      if (cache.history.length > 0 && cache.history.last.id == mediaItem.id)
        return;
      cache.history.add(Track.fromMediaItem(mediaItem));
      cache.save();
    });

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

        //Log to Deezer
        if (settings.logListen) {
          deezerAPI.logListen(audioHandler.mediaItem.value!.id);
        }
      }
    });

    //Start audio_service
    // await startService(); it is already ready, there is no need to start it
  }

  Future authorizeLastFM() async {
    if (settings.lastFMUsername == null || settings.lastFMPassword == null)
      return;
    await audioHandler.customAction('authorizeLastFM', {
      'username': settings.lastFMUsername,
      'password': settings.lastFMPassword
    });
  }

  Future<bool> toggleShuffle() async {
    await audioHandler.setShuffleMode((_shuffleEnabled = !_shuffleEnabled)
        ? AudioServiceShuffleMode.all
        : AudioServiceShuffleMode.none);
    return _shuffleEnabled;
  }

  bool get shuffleEnabled => _shuffleEnabled;

  //Repeat toggle
  Future changeRepeat() async {
    //Change to next repeat type
    repeatType = repeatType == AudioServiceRepeatMode.all
        ? AudioServiceRepeatMode.none
        : repeatType == AudioServiceRepeatMode.none
            ? AudioServiceRepeatMode.one
            : AudioServiceRepeatMode.all;
    //Set repeat type
    await audioHandler.setRepeatMode(repeatType);
  }

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

  //Replace queue, play specified track id
  Future<void> _loadQueuePlay(List<MediaItem> queue, String? trackId) async {
    await settings.updateAudioServiceQuality();

    await audioHandler.customAction('setIndex', {
      'index': trackId == null ? 0 : queue.indexWhere((m) => m.id == trackId)
    });
    await audioHandler.updateQueue(queue);
//    if (queue[0].id != trackId)
//      await AudioService.skipToQueueItem(trackId);
    if (!audioHandler.playbackState.value.playing) audioHandler.play();
  }

  //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 {
    print('starting playback from playlist');
    await playFromTrackList(playlist.tracks!, trackId,
        QueueSource(id: playlist.id, text: playlist.title, source: 'playlist'));
  }

  //Play episode from show, load whole show as queue
  Future<void> 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(); // audioservice is ready
    await settings.updateAudioServiceQuality();
    await setQueueSource(queueSource);
    await audioHandler.customAction('setIndex', {'index': index});
    await audioHandler.updateQueue(queue);
    if (!audioHandler.playbackState.value.playing) audioHandler.play();
  }

  //Load tracks as queue, play track id, set queue source
  Future playFromTrackList(
      List<Track?> tracks, String? trackId, QueueSource queueSource) async {
    final queue = await Future.wait(tracks
        .map<Future<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!.isEmpty) {
      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(stl.flowConfig);
      } else {
        stl = await deezerAPI.smartTrackList(stl.id);
      }
    }
    QueueSource queueSource = QueueSource(
        id: stl.flowConfig ?? 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 {
    this.queueSource = queueSource;
    await audioHandler.customAction('queueSource', queueSource.toJson());
  }

  //Reorder tracks in queue
  Future reorder(int oldIndex, int newIndex) => audioHandler
      .customAction('reorder', {'oldIndex': oldIndex, 'newIndex': newIndex});

  //Start visualizer
  // Future startVisualizer() async {
  //   await audioHandler.customAction('startVisualizer');
  // }

  //Stop visualizer
  // Future stopVisualizer() async {
  //   await audioHandler.customAction('stopVisualizer');
  // }
}

class AudioPlayerTask extends BaseAudioHandler {
  late AudioPlayer _player;
  late DeezerAPI _deezerAPI;

  //Queue
  List<MediaItem>? _originalQueue;
  int _queueIndex = 0;
  bool _isInitialized = false;
  late ConcatenatingAudioSource _audioSource;

  Seeker? _seeker;

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

  //Loaded from file/frontendjust
  int? mobileQuality;
  int? wifiQuality;
  QueueSource? queueSource;
  Duration? _lastPosition;
  AudioServiceRepeatMode _repeatMode = AudioServiceRepeatMode.none;

  Completer<List<MediaItem>>? _androidAutoCallback;
  Scrobblenaut? _scrobblenaut;
  // Last logged track id
  String? _loggedTrackId;

  MediaItem get currentMediaItem => queue.value[_queueIndex];
  late final LazyBox _box;

  AudioPlayerTask(
      {bool ignoreInterruptions = false, required DeezerAPI deezerAPI}) {
    _deezerAPI = deezerAPI;
    unawaited(_init(ignoreInterruptions));
  }

  Future<void> _init(bool ignoreInterruptions) async {
    final session = await AudioSession.instance;
    session.configure(AudioSessionConfiguration.music());

    _box = await Hive.openLazyBox('playback',
        path: (await getExternalCacheDirectories())?[0].path ??
            (await getExternalStorageDirectory())?.path);

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

    //Update track index
    _player.currentIndexStream.listen((index) {
      if (index != null && queue.value.isNotEmpty) {
        _queueIndex = index;
        mediaItem.add(currentMediaItem);
      }

      if (index == queue.value.length - 1) {
        unawaited(_onQueueEnd());
      }
    });
    //Update state on all clients on change
    _eventSub = _player.playbackEventStream.listen((event) {
      //Quality string
      if (_queueIndex != -1 && _queueIndex < queue.value.length) {
        Map extras = currentMediaItem.extras!;
        extras['qualityString'] = '';
        queue.value[_queueIndex] =
            currentMediaItem.copyWith(extras: extras as Map<String, dynamic>?);
      }
      //Update
      _broadcastState();
    });
    _player.processingStateStream.listen((state) {
      switch (state) {
        case ProcessingState.completed:
          //Player ended, get more songs
          if (_queueIndex == queue.value.length - 1)
            customEvent.add({
              'action': 'queueEnd',
              'queueSource': (queueSource ?? QueueSource()).toJson()
            });
          break;
        default:
          break;
      }
    });

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

    //Load queue
    // queue.add(_queue);
    customEvent.add({'action': 'onLoad'});
  }

  @override
  Future skipToQueueItem(int index) async {
    _lastPosition = null;

    //Skip in player
    await _player.seek(Duration.zero, index: index);
    _queueIndex = index;
    play();
  }

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

    //LastFM
    if (_queueIndex >= queue.value.length) return;
    if (_scrobblenaut != null && currentMediaItem.id != _loggedTrackId) {
      _loggedTrackId = currentMediaItem.id;
      await _scrobblenaut!.track.scrobble(
        track: currentMediaItem.title,
        artist: currentMediaItem.artist!,
        album: currentMediaItem.album,
      );
    }
  }

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

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

  @override
  Future<void> fastForward() =>
      _seekRelative(AudioService.config.fastForwardInterval);

  @override
  Future<void> rewind() => _seekRelative(-AudioService.config.rewindInterval);

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

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

  //Remove item from queue
  @override
  Future<void> removeQueueItem(MediaItem mediaItem) async {
    int index = queue.value.indexWhere((m) => m.id == mediaItem.id);
    removeQueueItemAt(index);
  }

  @override
  Future<void> removeQueueItemAt(int index) async {
    if (index <= _queueIndex) {
      _queueIndex--;
    }

    await _audioSource.removeAt(index);

    queue.add(queue.value..removeAt(index));
  }

  @override
  Future<void> skipToNext() async {
    _lastPosition = null;
    if (_queueIndex == queue.value.length - 1) return;
    //Update buffering state
    _queueIndex++;
    await _player.seekToNext();
    _broadcastState();
  }

  @override
  Future<void> skipToPrevious() 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>> getChildren(String parentMediaId,
      [Map<String, dynamic>? options]) async {
    customEvent.add({'action': 'screenAndroidAuto', 'id': parentMediaId});

    //Wait for data from main thread
    _androidAutoCallback = Completer<List<MediaItem>>();
    final data = await _androidAutoCallback!.future;
    _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), currentMediaItem)
        ..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 > currentMediaItem.duration!)
      newPos = currentMediaItem.duration!;

    await _player.seek(newPos);
  }

  //Update state on all clients
  void _broadcastState() {
    playbackState.add(PlaybackState(
      controls: queueSource?.source != 'show'
          ? [
              /*if (_queueIndex != 0)*/ MediaControl.skipToPrevious,
              _player.playing ? MediaControl.pause : MediaControl.play,
              /*if (_queueIndex != _queue!.length - 1)*/ MediaControl
                  .skipToNext,
              //Stop
              MediaControl(
                  androidIcon: 'drawable/ic_action_stop',
                  label: 'stop',
                  action: MediaAction.stop),
              // i mean, the user can just swipe the notification away to stop
            ]
          : [
              _player.playing ? MediaControl.pause : MediaControl.play,
              MediaControl.fastForward,
              MediaControl.rewind,
              MediaControl(
                  androidIcon: 'drawable/ic_action_stop',
                  label: 'stop',
                  action: MediaAction.stop),
            ],
      systemActions: queueSource?.source != 'show'
          ? const {
              MediaAction.seek,
              MediaAction.seekForward,
              MediaAction.seekBackward,
              MediaAction.stop
            }
          : const {
              MediaAction.seek,
              MediaAction.fastForward,
              MediaAction.rewind,
              MediaAction.stop,
            },
      processingState: _convertProcessingState(_player.processingState),
      playing: _player.playing,
      updatePosition: _player.position,
      bufferedPosition: _player.bufferedPosition,
      speed: _player.speed,
      queueIndex: _queueIndex,
    ));
  }

  //just_audio state -> audio_service state. If skipping, use _skipState
  AudioProcessingState _convertProcessingState(
      ProcessingState processingState) {
    return const <ProcessingState, AudioProcessingState>{
      ProcessingState.idle: AudioProcessingState.idle,
      ProcessingState.loading: AudioProcessingState.loading,
      ProcessingState.buffering: AudioProcessingState.buffering,
      ProcessingState.ready: AudioProcessingState.ready,
      ProcessingState.completed: AudioProcessingState.completed,
    }[processingState]!;
  }

  //Replace current queue
  @override
  Future updateQueue(List<MediaItem> q) async {
    _lastPosition = null;
    //just_audio
    _originalQueue = null;
    _player.stop();
    if (_isInitialized) _audioSource.clear();

    // broadcast to ui
    queue.add(q);
    //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
    if (!queue.hasValue || queue.value.isEmpty) {
      return;
    }
    final sources = await Future.wait(queue.value.map(_mediaItemToAudioSource));

    _audioSource = ConcatenatingAudioSource(children: sources);

    //Load in just_audio
    try {
      await _player.setAudioSource(_audioSource,
          initialIndex: _queueIndex, initialPosition: Duration.zero);
    } catch (e) {
      //Error loading tracks
    }
    if (_queueIndex != -1) {
      mediaItem.add(currentMediaItem);
    }
  }

  Future<AudioSource> _mediaItemToAudioSource(MediaItem mediaItem) async {
    //Check if offline
    if (Platform.isAndroid) {
      String _offlinePath =
          p.join((await getExternalStorageDirectory())!.path, 'offline/');
      File file = File(p.join(_offlinePath, mediaItem.id));
      if (await file.exists()) {
        // return Uri.file(f.path);
        //return f.path;
        //Stream server URL
        // return 'http://localhost:36958/?id=${mediaItem.id}';

        // maybe still use [AudioSource.file], but find another way to broadcast stream info so to have less overhead
        return OfflineAudioSource(file,
            onStreamObtained: (streamInfo) =>
                customEvent.add({'action': 'streamInfo', 'data': streamInfo}));
        // return AudioSource.uri(
        //     Uri.http('localhost:36958', '/', {'id': mediaItem.id}));
      }
    }

    //Show episode direct link
    if (mediaItem.extras!['showUrl'] != null)
      return UrlAudioSource(
        Uri.parse(mediaItem.extras!['showUrl']),
        onStreamObtained: (qualityInfo) =>
            customEvent.add({'action': 'streamInfo', 'data': qualityInfo}),
      );

    //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();
    int? quality = mobileQuality;
    if (conn == ConnectivityResult.wifi) quality = wifiQuality;

    if ((playbackDetails ?? []).length < 2)
      throw Exception('not enough playback details');

    //String url = 'https://dzcdn.net/?md5=${playbackDetails[0]}&mv=${playbackDetails[1]}&q=${quality.toString()}#${mediaItem.id}';
    // final uri = Uri.http('localhost:36958', '', {
    //   if (quality != null) 'q': quality.toString(),
    //   'mv': playbackDetails![1],
    //   'md5origin': playbackDetails[0],
    //   'id': mediaItem.id,
    // });
    // print("url for " + mediaItem.title + ": " + uri.toString());
    // return AudioSource.uri(uri);

    // DON'T use the java backend anymore, useless.
    return DeezerAudioSource(
      quality: quality!,
      trackId: mediaItem.id,
      md5origin: playbackDetails![0],
      mediaVersion: playbackDetails[1],
      onStreamObtained: (qualityInfo) =>
          customEvent.add({'action': 'streamInfo', 'data': qualityInfo}),
    );
  }

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

      //Android audio callback
      case 'screenAndroidAuto':
        _androidAutoCallback?.complete((args!['value'] as List<MediaItem>?));
        break;
      //Reorder tracks, args = [old, new]
      case 'reorder':
        final oldIndex = args!['oldIndex']! as int;
        final newIndex = args['newIndex']! as int;
        await _audioSource.move(
            oldIndex, oldIndex > newIndex ? newIndex : newIndex - 1);
        queue.add(List.from(queue.value)..reorder(oldIndex, newIndex));
        _broadcastState();
        break;
      //Set index without affecting playback for loading
      case 'setIndex':
        _queueIndex = args!['index'];
        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;
      //Authorize lastfm
      case 'authorizeLastFM':
        final username = args!['username']! as String;
        final password = args['password']! as String;
        try {
          final lastFM = await LastFM.authenticateWithPasswordHash(
              apiKey: 'b6ab5ae967bcd8b10b23f68f42493829',
              apiSecret: '861b0dff9a8a574bec747f9dab8b82bf',
              username: username,
              passwordHash: password);
          _scrobblenaut = Scrobblenaut(lastFM: lastFM);
        } catch (e) {
          print(e);
        }
        break;
      case 'disableLastFM':
        _scrobblenaut = null;
        break;
    }

    return true;
  }

  @override
  Future onTaskRemoved() => stop();

  @override
  Future onNotificationDeleted() => stop();

  @override
  Future<void> stop() async {
    await _saveQueue();
    _player.stop();
    _eventSub?.cancel();
    _audioSessionSub?.cancel();
    _visualizerSubscription?.cancel();
    await super.stop();
  }

  //Export queue to -JSON- hive box
  Future<void> _saveQueue() async {
    if (_queueIndex == 0 && queue.value.isEmpty) return;
    await _box.clear();
    await _box.putAll(<String, dynamic>{
      'index': _queueIndex,
      'queue': queue.value,
      'position': _player.position,
      'queueSource': queueSource,
      'repeatMode': _repeatMode,
    });
  }

  //Restore queue & playback info from path
  Future<void> _loadQueueFile() async {
    if (_box.isEmpty) {
      await _loadQueue();
      return;
    }

    final _queue = ((await _box.get('queue')) as List?)?.cast<MediaItem>();
    _queueIndex = await _box.get('index', defaultValue: 0);
    _lastPosition = await _box.get('position', defaultValue: Duration.zero);
    queueSource =
        await _box.get('queueSource', defaultValue: const QueueSource());
    _repeatMode =
        await _box.get('repeatMode', defaultValue: AudioServiceRepeatMode.none);
    //Restore queue
    if (_queue != null) {
      queue.add(_queue);
      await _loadQueue();
      mediaItem.add(currentMediaItem);
    } else {
      await _loadQueue();
    }
    //Send restored queue source to ui
    customEvent.add({
      'action': 'onRestore',
      'queueSource': queueSource!,
      'repeatMode': _repeatMode
    });
  }

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

    queue.add(List.from(queue.value)..insert(index, mi));
    AudioSource? _newSource = await _mediaItemToAudioSource(mi);
    await _audioSource.insert(index, _newSource);

    _saveQueue();
  }

  //Add at end of queue
  @override
  Future<void> addQueueItem(MediaItem mediaItem,
      {bool shouldSaveQueue = true}) async {
    if (queue.value.indexWhere((m) => m.id == mediaItem.id) != -1) return;

    queue.add(List.from(queue.value)..add(mediaItem));
    AudioSource _newSource = await _mediaItemToAudioSource(mediaItem);
    await _audioSource.add(_newSource);
    if (shouldSaveQueue) _saveQueue();
  }

  @override
  Future<void> addQueueItems(List<MediaItem> mediaItems) async {
    for (final mediaItem in mediaItems) {
      await addQueueItem(mediaItem, shouldSaveQueue: false);
    }
    _saveQueue();
  }

  @override
  Future<void> playFromMediaId(String mediaId,
      [Map<String, dynamic>? args]) async {
    //Android auto load tracks
    if (mediaId.startsWith(AndroidAuto.prefix)) {
      customEvent.add({
        'action': 'tracksAndroidAuto',
        'id': mediaId.replaceFirst(AndroidAuto.prefix, '')
      });
      return;
    }

    //Does the same thing
    await this
        .skipToQueueItem(queue.value.indexWhere((item) => item.id == mediaId));
  }

  @override
  Future<MediaItem?> getMediaItem(String mediaId) async =>
      queue.value.firstWhereOrNull((mediaItem) => mediaItem.id == mediaId);

  @override
  Future<void> playMediaItem(MediaItem mediaItem) =>
      playFromMediaId(mediaItem.id);

  @override
  Future<void> setRepeatMode(AudioServiceRepeatMode repeatMode) =>
      _player.setLoopMode(repeatMode.toLoopMode());

  @override
  Future<void> setShuffleMode(AudioServiceShuffleMode shuffleMode) async {
    switch (shuffleMode) {
      case AudioServiceShuffleMode.none:
        queue.add(_originalQueue!);
        _originalQueue = null;
        break;
      case AudioServiceShuffleMode.group:
      case AudioServiceShuffleMode.all:
        _originalQueue = List.from(queue.value, growable: false);
        queue.add(queue.value..shuffle());
        break;
    }

    _queueIndex = 0;
    await _player.stop();
    await _loadQueue();
    await _player.play();
  }

  //Called when queue ends to load more tracks
  Future<void> _onQueueEnd() async {
    print('ON QUEUE END CALLED!');

    print('getting track list ${queueSource?.source}');
    if (queueSource == null) return;

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

    if (tracks == null) {
      throw Exception(
          'Failed to fetch more queue songs (queueSource: ${queueSource!.toJson()})');
    }

    final mi = await Future.wait(
        tracks.map<Future<MediaItem>>((t) => t.toMediaItem()));
    await addQueueItems(mi);
  }
}

//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;
  }
}