// ignore_for_file: unused_import

import 'dart:ui';
import 'dart:async';
import 'package:cached_network_image/cached_network_image.dart';
import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:audio_service/audio_service.dart';
import 'package:flutter/services.dart';
import 'package:flutter_screenutil/flutter_screenutil.dart';
import 'package:freezer/api/cache.dart';
import 'package:freezer/api/deezer.dart';
import 'package:freezer/api/definitions.dart';
import 'package:freezer/api/player/audio_handler.dart';
import 'package:freezer/main.dart';
import 'package:freezer/page_routes/fade.dart';
import 'package:freezer/settings.dart';
import 'package:freezer/translations.i18n.dart';
import 'package:freezer/ui/cached_image.dart';
import 'package:freezer/ui/fancy_scaffold.dart';
import 'package:freezer/ui/lyrics_screen.dart';
import 'package:freezer/ui/menu.dart';
import 'package:freezer/ui/player_bar.dart';
import 'package:freezer/ui/queue_screen.dart';
import 'package:freezer/ui/settings_screen.dart';
import 'package:logging/logging.dart';
import 'package:marquee/marquee.dart';
import 'package:palette_generator/palette_generator.dart';
import 'package:photo_view/photo_view.dart';
import 'package:provider/provider.dart';

const _blurStrength = 90.0;

/// A simple [ChangeNotifier] that listens to the [AudioHandler.mediaItem] stream and
/// notifies its listeners when background changes
class BackgroundProvider extends ChangeNotifier {
  PaletteGenerator? _palette;
  Color? _dominantColor;
  ImageProvider? _imageProvider;
  StreamSubscription? _mediaItemSub;
  bool _isDisposed = false;
  BackgroundProvider();

  /// Calculate background color from [mediaItem]
  ///
  /// Warning: this function is expensive to call, and should only be called when songs change!
  Future<void> _updateColor(MediaItem mediaItem) async {
    if (!settings.colorGradientBackground &&
        !settings.blurPlayerBackground &&
        !settings.enableFilledPlayButton &&
        !settings.playerAlbumArtDropShadow) return;
    final imageProvider = CachedNetworkImageProvider(
        mediaItem.extras!['thumb'] ?? mediaItem.artUri.toString(),
        cacheManager: cacheManager);
    //Run in isolate
    _palette = await PaletteGenerator.fromImageProvider(imageProvider);
    _dominantColor = _palette!.dominantColor!.color;
    _imageProvider = settings.blurPlayerBackground ? imageProvider : null;
    if (!_isDisposed) notifyListeners();
  }

  @override
  void addListener(VoidCallback listener) {
    print('[PROVIDER] listener added $hasListeners');
    _mediaItemSub ??= audioHandler.mediaItem.listen((mediaItem) {
      if (mediaItem == null) return;
      _updateColor(mediaItem);
    });
    super.addListener(listener);
  }

  @override
  void removeListener(VoidCallback listener) {
    super.removeListener(listener);
    print('[PROVIDER] listener removed! hasListeners? $hasListeners');
  }

  @override
  void dispose() {
    print('[PROVIDER] DISPOSED');
    _isDisposed = true;
    _mediaItemSub?.cancel();
    super.dispose();
  }

  Color? get dominantColor => _dominantColor;
  PaletteGenerator? get palette => _palette;
  ImageProvider<Object>? get imageProvider => _imageProvider;
}

class PlayerScreen extends StatelessWidget {
  const PlayerScreen({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return ChangeNotifierProvider(
      create: (context) => BackgroundProvider(),
      child: PlayerScreenBackground(
          child: MainScreen.of(context).isDesktop
              ? const PlayerScreenDesktop()
              : OrientationBuilder(
                  builder: (context, orientation) =>
                      orientation == Orientation.landscape
                          ? const PlayerScreenHorizontal()
                          : const PlayerScreenVertical())),
    );
  }
}

/// Will change the background based on [BackgroundProvider],
/// it will wrap the [child] in a [Scaffold] and [SafeArea] widget
class PlayerScreenBackground extends StatelessWidget {
  final Widget child;
  final bool enabled;
  final PreferredSizeWidget? appBar;
  const PlayerScreenBackground({
    super.key,
    required this.child,
    this.enabled = true,
    this.appBar,
  });

  Widget _buildChild(
      BuildContext context, BackgroundProvider provider, Widget child) {
    return Stack(children: [
      if (provider.imageProvider != null || settings.colorGradientBackground)
        Positioned.fill(
            child: provider.imageProvider != null
                ? DecoratedBox(
                    decoration: const BoxDecoration(color: Colors.black),
                    child: ImageFiltered(
                      imageFilter: ImageFilter.blur(
                        tileMode: TileMode.decal,
                        sigmaX: _blurStrength,
                        sigmaY: _blurStrength,
                      ),
                      child: DecoratedBox(
                        decoration: BoxDecoration(
                            image: DecorationImage(
                          image: provider.imageProvider!,
                          fit: BoxFit.cover,
                          colorFilter: ColorFilter.mode(
                              Colors.white
                                  .withOpacity(settings.isDark ? 0.55 : 0.75),
                              BlendMode.dstATop),
                        )),
                      ),
                    ),
                  )
                : DecoratedBox(
                    decoration: BoxDecoration(
                        gradient: LinearGradient(
                      begin: Alignment.topCenter,
                      end: Alignment.bottomCenter,
                      colors: [
                        if (provider.dominantColor != null)
                          provider.dominantColor!,
                        Theme.of(context).scaffoldBackgroundColor,
                      ],
                      stops: const [0.0, 0.6],
                    )),
                  )),
      child,
    ]);
  }

  static SystemUiOverlayStyle? getSystemUiOverlayStyle(BuildContext context,
      {bool enabled = true}) {
    final hasBackground = enabled &&
        (settings.blurPlayerBackground || settings.colorGradientBackground);
    if (!hasBackground) return null;
    const color = Colors.transparent;
    final brightness = hasBackground
        ? Brightness.light
        : (ThemeData.estimateBrightnessForColor(color) == Brightness.light
            ? Brightness.dark
            : Brightness.light);
    return SystemUiOverlayStyle(
      statusBarColor: color,
      statusBarBrightness: brightness,
      statusBarIconBrightness: brightness,
      systemNavigationBarIconBrightness: brightness,
      systemNavigationBarColor: color,
      systemNavigationBarDividerColor: color,
    );
  }

  @override
  Widget build(BuildContext context) {
    final hasBackground = enabled &&
        (settings.blurPlayerBackground || settings.colorGradientBackground);
    final color = hasBackground
        ? Colors.transparent
        : Theme.of(context).scaffoldBackgroundColor;
    Widget widgetChild = Scaffold(
      appBar: appBar,
      backgroundColor: color,
      body: SafeArea(child: child),
    );
    if (enabled) {
      widgetChild = Consumer<BackgroundProvider>(
        builder: (context, provider, child) {
          return _buildChild(context, provider, child!);
        },
        child: widgetChild,
      );
    }
    final suios = getSystemUiOverlayStyle(context, enabled: enabled);
    if (appBar == null && suios != null) {
      widgetChild = AnnotatedRegion<SystemUiOverlayStyle>(
        value: suios,
        child: widgetChild,
      );
    }
    return widgetChild;
  }
}

//Landscape
class PlayerScreenHorizontal extends StatelessWidget {
  const PlayerScreenHorizontal({super.key});

  @override
  Widget build(BuildContext context) {
    return Row(
      mainAxisSize: MainAxisSize.max,
      mainAxisAlignment: MainAxisAlignment.spaceEvenly,
      children: <Widget>[
        const Expanded(
          flex: 4,
          child: Padding(
            padding: EdgeInsets.all(8.0),
            child: BigAlbumArt(),
          ),
        ),
        const SizedBox(width: 56.0),
        //Right side
        Expanded(
          flex: 5,
          child: Column(
            mainAxisSize: MainAxisSize.max,
            mainAxisAlignment: MainAxisAlignment.spaceEvenly,
            children: <Widget>[
              Padding(
                padding: const EdgeInsets.fromLTRB(0, 0, 8, 0),
                child: PlayerScreenTopRow(
                    textSize: 24.sp,
                    iconSize: 36.sp,
                    textWidth: 350.w,
                    short: true),
              ),
              Padding(
                padding: const EdgeInsets.symmetric(horizontal: 24.0),
                child: PlayerTextSubtext(textSize: 35.sp),
              ),
              Padding(
                padding: const EdgeInsets.symmetric(horizontal: 8.0),
                child: SeekBar(textSize: 24.sp),
              ),
              Padding(
                padding: const EdgeInsets.symmetric(horizontal: 24.0),
                child: PlaybackControls(46.sp),
              ),
              Padding(
                padding: const EdgeInsets.symmetric(horizontal: 24.0),
                child: BottomBarControls(size: 30.sp),
              )
            ],
          ),
        )
      ],
    );
  }
}

//Portrait
class PlayerScreenVertical extends StatelessWidget {
  const PlayerScreenVertical({super.key});

  @override
  Widget build(BuildContext context) {
    return Padding(
        padding: const EdgeInsets.fromLTRB(16, 8, 16, 8),
        child: Column(
          mainAxisSize: MainAxisSize.max,
          mainAxisAlignment: MainAxisAlignment.spaceBetween,
          children: <Widget>[
            Padding(
              padding: const EdgeInsets.symmetric(horizontal: 4.0),
              child: PlayerScreenTopRow(
                textSize: 14.spMax,
                iconSize: 20.spMax,
              ),
            ),
            const Flexible(child: BigAlbumArt()),
            Padding(
              padding: const EdgeInsets.symmetric(horizontal: 24.0),
              child: PlayerTextSubtext(textSize: 24.spMax),
            ),
            SeekBar(textSize: 14.spMax),
            Padding(
              padding: const EdgeInsets.symmetric(horizontal: 8.0),
              child: PlaybackControls(32.spMax),
            ),
            Padding(
              padding:
                  const EdgeInsets.symmetric(vertical: 0, horizontal: 16.0),
              child: BottomBarControls(size: 22.spMax),
            )
          ],
        ));
  }
}

class PlayerScreenDesktop extends StatelessWidget {
  const PlayerScreenDesktop({super.key});

  @override
  Widget build(BuildContext context) {
    return Row(children: [
      AspectRatio(
        aspectRatio: 9 / 16,
        child: Padding(
          padding: const EdgeInsets.symmetric(horizontal: 16.0),
          child: Column(
              mainAxisAlignment: MainAxisAlignment.spaceEvenly,
              children: [
                Padding(
                  padding: const EdgeInsets.symmetric(horizontal: 4.0),
                  child: PlayerScreenTopRow(
                    textSize: 12.h,
                    iconSize: 21.h,
                    showQueueButton: false,
                  ),
                ),
                Flexible(
                  child: ConstrainedBox(
                      constraints: BoxConstraints.loose(const Size.square(500)),
                      child: const BigAlbumArt()),
                ),
                Padding(
                  padding: const EdgeInsets.symmetric(horizontal: 24.0),
                  child: PlayerTextSubtext(textSize: 22.h),
                ),
                SeekBar(textSize: 16.h),
                Padding(
                  padding: const EdgeInsets.symmetric(horizontal: 16.0),
                  child: PlaybackControls(28.h),
                ),
                Padding(
                  padding:
                      const EdgeInsets.symmetric(vertical: 0, horizontal: 16.0),
                  child: BottomBarControls(
                    size: 20.h,
                    desktopMode: true,
                  ),
                )
              ]),
        ),
      ),
      const Expanded(
          flex: 2,
          child: Padding(
            padding: EdgeInsets.only(left: 16.0, right: 16.0, top: 16.0),
            child: _DesktopTabView(),
          )),
    ]);
  }
}

class _DesktopTabView extends StatelessWidget {
  const _DesktopTabView({super.key});

  @override
  Widget build(BuildContext context) {
    return DefaultTabController(
      length: 2,
      child: Column(children: [
        TabBar(
            tabs: [
              Tab(
                text: 'Queue'.i18n,
                height: 48.0,
              ),
              Tab(
                text: 'Lyrics'.i18n,
              ),
            ],
            labelStyle: Theme.of(context)
                .textTheme
                .labelLarge!
                .copyWith(fontSize: 18.0)),
        Expanded(
            child: SizedBox.expand(
          child: Material(
            type: MaterialType.transparency,
            child: TabBarView(children: [
              QueueListWidget(
                closePlayer: FancyScaffold.of(context)!.closePanel,
                isInsidePlayer: true,
              ),
              const LyricsWidget(),
            ]),
          ),
        )),
      ]),
    );
  }
}

class FitOrScrollText extends StatefulWidget {
  final String text;
  final TextStyle style;
  final TextAlign? textAlign;
  final TextDirection? textDirection;
  final int? maxLines;
  const FitOrScrollText({
    required this.text,
    required this.style,
    this.textAlign,
    this.textDirection,
    this.maxLines,
    super.key,
  });

  @override
  State<FitOrScrollText> createState() => _FitOrScrollTextState();
}

class _FitOrScrollTextState extends State<FitOrScrollText> {
  bool _checkTextFits(String text, BoxConstraints constraints) {
    final textPainter = TextPainter(
      text: TextSpan(text: text, style: widget.style),
      textAlign: widget.textAlign ?? TextAlign.left,
      textDirection: widget.textDirection ?? TextDirection.ltr,
      maxLines: widget.maxLines,
    );

    textPainter.layout(maxWidth: constraints.maxWidth);

    return !(textPainter.didExceedMaxLines ||
        textPainter.height > constraints.maxHeight ||
        textPainter.width > constraints.maxWidth);
  }

  @override
  Widget build(BuildContext context) {
    return LayoutBuilder(builder: (context, constraints) {
      return _checkTextFits(widget.text, constraints)
          ? Text(
              widget.text,
              maxLines: widget.maxLines,
              style: widget.style,
            )
          : Marquee(
              text: widget.text,
              style: widget.style,
              blankSpace: 32.0,
              startPadding: 0.0,
              numberOfRounds: 2,
              accelerationDuration: const Duration(seconds: 1),
              pauseAfterRound: const Duration(seconds: 2),
              crossAxisAlignment: CrossAxisAlignment.end,
              fadingEdgeEndFraction: 0.05,
              fadingEdgeStartFraction: 0.05,
            );
    });
  }
}

class PlayerTextSubtext extends StatelessWidget {
  final double textSize;
  const PlayerTextSubtext({Key? key, required this.textSize}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return StreamBuilder<MediaItem?>(
        stream: audioHandler.mediaItem,
        builder: (context, snapshot) {
          if (!snapshot.hasData) {
            return const SizedBox();
          }
          final currentMediaItem = snapshot.data!;
          return Column(
              mainAxisSize: MainAxisSize.min,
              crossAxisAlignment: CrossAxisAlignment.stretch,
              children: <Widget>[
                SizedBox(
                  height: 1.5 * textSize,
                  child: FitOrScrollText(
                      key: Key(currentMediaItem.displayTitle!),
                      text: currentMediaItem.displayTitle!,
                      maxLines: 1,
                      style: TextStyle(
                          fontSize: textSize,
                          fontWeight: FontWeight.bold,
                          overflow: TextOverflow.ellipsis)),
                ),
                // child: currentMediaItem.displayTitle!.length >= 26
                //     ? Marquee(
                //         key: Key(currentMediaItem.displayTitle!),
                //         text: currentMediaItem.displayTitle!,
                //         style: TextStyle(
                //             fontSize: textSize, fontWeight: FontWeight.bold),
                //         blankSpace: 32.0,
                //         startPadding: 0.0,
                //         accelerationDuration: const Duration(seconds: 1),
                //         pauseAfterRound: const Duration(seconds: 2),
                //         crossAxisAlignment: CrossAxisAlignment.start,
                //         fadingEdgeEndFraction: 0.05,
                //         fadingEdgeStartFraction: 0.05,
                //       )
                //     : Text(
                //         currentMediaItem.displayTitle!,
                //         maxLines: 1,
                //         overflow: TextOverflow.ellipsis,
                //         textAlign: TextAlign.start,
                //         style: TextStyle(
                //             fontSize: textSize, fontWeight: FontWeight.bold),
                //       )),
                Text(
                  currentMediaItem.displaySubtitle ?? '',
                  maxLines: 1,
                  textAlign: TextAlign.start,
                  overflow: TextOverflow.clip,
                  style: TextStyle(
                    fontSize: textSize * 0.8, // 20% smaller
                    color: Theme.of(context).colorScheme.primary,
                  ),
                ),
              ]);
        });
  }
}

class QualityInfoWidget extends StatelessWidget {
  final double? textSize;
  const QualityInfoWidget({Key? key, this.textSize}) : super(key: key);

  String _getQualityStringFromInfo(StreamQualityInfo info) {
    if (audioHandler.mediaItem.value == null) return '';

    int bitrate = info.quality == AudioQuality.MP3_128
        ? 128
        : info.quality == AudioQuality.MP3_320
            ? 320
            : info.calculateBitrate(audioHandler.mediaItem.value!.duration!);

    return '${info.format.name} ${bitrate}kbps';
  }

  @override
  Widget build(BuildContext context) {
    return StreamBuilder<String>(
        stream: playerHelper.streamInfo.map<String>(_getQualityStringFromInfo),
        builder: (context, snapshot) {
          return TextButton(
            // style: ButtonStyle(
            //     elevation: MaterialStatePropertyAll(0.5),
            //     padding: MaterialStatePropertyAll(
            //         EdgeInsets.symmetric(horizontal: 16, vertical: 4)),
            //     foregroundColor: MaterialStatePropertyAll(
            //         Theme.of(context).colorScheme.onSurface)),
            child: Text(snapshot.data ?? '',
                style: textSize == null ? null : TextStyle(fontSize: textSize)),
            onPressed: () => Navigator.of(context).push(MaterialPageRoute(
                builder: (context) => const QualitySettings())),
          );
        });
  }
}

void Function([TapUpDetails?]) _onMenuPressedCallback(BuildContext context) {
  return ([details]) {
    final currentMediaItem = audioHandler.mediaItem.value!;
    Track t = Track.fromMediaItem(currentMediaItem);
    MenuSheet m = MenuSheet(context, navigateCallback: () {
      // close player
      FancyScaffold.of(context)?.closePanel();
    });
    if (currentMediaItem.extras!['show'] == null) {
      m.defaultTrackMenu(t,
          options: [m.sleepTimer(), m.wakelock()], details: details);
    } else {
      m.defaultShowEpisodeMenu(Show.fromJson(currentMediaItem.extras!['show']),
          ShowEpisode.fromMediaItem(currentMediaItem),
          options: [m.sleepTimer(), m.wakelock()], details: details);
    }
  };
}

class PlayerMenuButtonDesktop extends StatelessWidget {
  final double size;

  const PlayerMenuButtonDesktop({super.key, required this.size});

  @override
  Widget build(BuildContext context) {
    return InkWell(
      customBorder: const CircleBorder(),
      onTapUp: _onMenuPressedCallback(context),
      child: Padding(
        padding: const EdgeInsets.all(8.0),
        child: Icon(
          Icons.more_vert,
          semanticLabel: "Options".i18n,
          size: size,
        ),
      ),
    );
  }
}

class PlayerMenuButton extends StatelessWidget {
  final double size;
  const PlayerMenuButton({super.key, required this.size});

  @override
  Widget build(BuildContext context) {
    return IconButton(
        iconSize: size,
        icon: Icon(
          Icons.more_vert,
          semanticLabel: "Options".i18n,
        ),
        onPressed: _onMenuPressedCallback(context));
  }
}

class RepeatButton extends StatefulWidget {
  final double iconSize;
  const RepeatButton(this.iconSize, {Key? key}) : super(key: key);

  @override
  State<RepeatButton> createState() => _RepeatButtonState();
}

class _RepeatButtonState extends State<RepeatButton> {
  // ignore: missing_return
  Icon get repeatIcon {
    switch (playerHelper.repeatType) {
      case AudioServiceRepeatMode.none:
        return Icon(
          Icons.repeat,
          semanticLabel: "Repeat off".i18n,
        );
      case AudioServiceRepeatMode.one:
        return Icon(
          Icons.repeat_one,
          semanticLabel: "Repeat one".i18n,
        );
      case AudioServiceRepeatMode.group:
      case AudioServiceRepeatMode.all:
        return Icon(
          Icons.repeat,
          semanticLabel: "Repeat".i18n,
        );
    }
  }

  @override
  Widget build(BuildContext context) {
    return IconButton(
      color: playerHelper.repeatType == AudioServiceRepeatMode.none
          ? null
          : Theme.of(context).colorScheme.primary,
      iconSize: widget.iconSize,
      icon: repeatIcon,
      onPressed: () async {
        await playerHelper.changeRepeat();
        setState(() {});
      },
    );
  }
}

class ShuffleButton extends StatefulWidget {
  final double iconSize;
  const ShuffleButton({Key? key, required this.iconSize}) : super(key: key);

  @override
  State<ShuffleButton> createState() => _ShuffleButtonState();
}

class _ShuffleButtonState extends State<ShuffleButton> {
  @override
  Widget build(BuildContext context) => IconButton(
        icon: const Icon(Icons.shuffle),
        iconSize: widget.iconSize,
        color: playerHelper.shuffleEnabled
            ? Theme.of(context).colorScheme.primary
            : null,
        onPressed: _toggleShuffle,
      );

  void _toggleShuffle() {
    playerHelper.toggleShuffle().then((_) => setState(() {}));
  }
}

class FavoriteButton extends StatefulWidget {
  final double size;
  const FavoriteButton({Key? key, required this.size}) : super(key: key);

  @override
  State<FavoriteButton> createState() => _FavoriteButtonState();
}

class _FavoriteButtonState extends State<FavoriteButton> {
  Icon get libraryIcon {
    if (cache.checkTrackFavorite(
        Track.fromMediaItem(audioHandler.mediaItem.value!))) {
      return Icon(
        Icons.favorite,
        semanticLabel: "Unlove".i18n,
      );
    }
    return Icon(
      Icons.favorite_border,
      semanticLabel: "Love".i18n,
    );
  }

  @override
  Widget build(BuildContext context) => StreamBuilder<MediaItem?>(
      stream: audioHandler.mediaItem,
      builder: (context, snapshot) {
        if (!snapshot.hasData || snapshot.data == null) {
          return IconButton(
              onPressed: () {}, icon: const Icon(Icons.favorite_border));
        }

        final mediaItem = snapshot.data!;

        return IconButton(
          icon: libraryIcon,
          iconSize: widget.size,
          onPressed: () async {
            if (cache.checkTrackFavorite(Track.fromMediaItem(mediaItem))) {
              //Remove from library
              setState(() => cache.libraryTracks.remove(mediaItem.id));
              await deezerAPI.removeFavorite(mediaItem.id);
              await cache.save();
            } else {
              //Add
              setState(() => cache.libraryTracks.add(mediaItem.id));
              await deezerAPI.addFavoriteTrack(mediaItem.id);
              await cache.save();
            }
          },
        );
      });
}

class ForwardReplay30Button extends StatelessWidget {
  final bool forward;
  const ForwardReplay30Button({super.key, required this.forward});

  void _seek(Duration position) {
    // validate position
    if (position.isNegative) return;
    if (position > audioHandler.mediaItem.value!.duration!) return;

    audioHandler.seek(position);
  }

  @override
  Widget build(BuildContext context) {
    if (forward) {
      return IconButton(
          onPressed: () => _seek(audioHandler.playbackState.value.position +
              const Duration(seconds: 30)),
          icon: const Icon(Icons.forward_30));
    }

    return IconButton(
        onPressed: () => _seek(audioHandler.playbackState.value.position -
            const Duration(seconds: 30)),
        icon: const Icon(Icons.replay_30));
  }
}

class PlaybackControls extends StatelessWidget {
  final double size;
  const PlaybackControls(this.size, {Key? key}) : super(key: key);
  @override
  Widget build(BuildContext context) {
    return Padding(
      padding: const EdgeInsets.symmetric(horizontal: 8.0),
      child: StreamBuilder<QueueSource>(
          stream: playerHelper.queueSource,
          builder: (context, snapshot) {
            final queueSource = snapshot.data;
            return Row(
              mainAxisAlignment: MainAxisAlignment.spaceBetween,
              mainAxisSize: MainAxisSize.max,
              children: [
                queueSource?.source != 'show'
                    ? ShuffleButton(iconSize: size * 0.75)
                    : const ForwardReplay30Button(forward: false),
                PrevNextButton(size, prev: true),
                if (settings.enableFilledPlayButton)
                  Consumer<BackgroundProvider>(builder: (context, provider, _) {
                    final color = provider.dominantColor == null
                        ? Colors.transparent
                        : Theme.of(context).brightness == Brightness.light
                            ? provider.dominantColor!
                            : darken(provider.dominantColor!);
                    return PlayPauseButton(size * 2.25,
                        filled: true,
                        material3: settings.enableMaterial3PlayButton,
                        color: color,
                        iconColor: Color.lerp(
                            (ThemeData.estimateBrightnessForColor(color) ==
                                    Brightness.light
                                ? Colors.black
                                : Colors.white),
                            color,
                            0.25));
                  })
                else
                  PlayPauseButton(size * 1.25),
                PrevNextButton(size),
                queueSource?.source != 'show'
                    ? RepeatButton(size * 0.75)
                    : const ForwardReplay30Button(forward: true),
              ],
            );
          }),
    );
  }
}

class BigAlbumArt extends StatefulWidget {
  const BigAlbumArt({super.key});

  @override
  State<BigAlbumArt> createState() => _BigAlbumArtState();
}

class _BigAlbumArtState extends State<BigAlbumArt> with WidgetsBindingObserver {
  final _pageController = PageController(
    initialPage: playerHelper.queueIndex,
    keepPage: false,
    viewportFraction: 1.0,
  );
  StreamSubscription? _currentItemSub;

  /// is true on pointer down event
  /// used to distinguish between [PageController.animateToPage] and user gesture
  bool _userScroll = true;

  /// whether the user has already scrolled the [PageView],
  /// so to avoid calling [PageController.animateToPage] again.
  bool _initiatedByUser = false;

  void _listenForMediaItemChanges() {
    if (_currentItemSub != null) return;

    _currentItemSub = audioHandler.mediaItem.listen((event) async {
      if (_initiatedByUser) {
        _initiatedByUser = false;
        return;
      }
      if (!_pageController.hasClients) return;
      if (_pageController.page?.toInt() == playerHelper.queueIndex) return;
      print('animating controller to page');

      _userScroll = false;
      await _pageController.animateToPage(playerHelper.queueIndex,
          duration: const Duration(milliseconds: 300), curve: Curves.easeInOut);
      _userScroll = true;
    });
  }

  @override
  void initState() {
    _listenForMediaItemChanges();
    super.initState();
  }

  @override
  void didChangeAppLifecycleState(AppLifecycleState state) {
    switch (state) {
      case AppLifecycleState.paused:
        _currentItemSub?.cancel();
      case AppLifecycleState.resumed:
        _listenForMediaItemChanges();
      default:
        break;
    }
    super.didChangeAppLifecycleState(state);
  }

  @override
  void dispose() {
    _currentItemSub?.cancel();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    final child = GestureDetector(
      onTap: () => Navigator.push(
          context,
          FadePageRoute(
            barrierDismissible: true,
            opaque: false,
            builder: (context) {
              final mediaItem = audioHandler.mediaItem.value!;
              return ZoomableImageRoute(
                  imageUrl: mediaItem.artUri.toString(), heroKey: mediaItem.id);
            },
          )),
      child: StreamBuilder<List<MediaItem>>(
          stream: audioHandler.queue,
          initialData: audioHandler.queue.valueOrNull,
          builder: (context, snapshot) {
            if (!snapshot.hasData) {
              return const Center(child: CircularProgressIndicator());
            }
            final queue = snapshot.data!;
            return PageView.builder(
                controller: _pageController,
                onPageChanged: (int index) {
                  // ignore if not initiated by user.
                  if (!_userScroll) return;
                  Logger('BigAlbumArt')
                      .fine('page changed, skipping to media item');
                  if (queue[index].id == audioHandler.mediaItem.value?.id) {
                    return;
                  }

                  audioHandler.skipToQueueItem(index);
                },
                itemCount: queue.length,
                itemBuilder: (context, i) => Padding(
                      padding: const EdgeInsets.all(8.0),
                      child: Hero(
                        tag: queue[i].id,
                        child: ClipRRect(
                          borderRadius: BorderRadius.circular(8.0),
                          child: CachedImage(
                            url: queue[i].artUri.toString(),
                            fullThumb: true,
                          ),
                        ),
                      ),
                    ));
          }),
    );

    return AspectRatio(
      aspectRatio: 1.0,
      child: settings.playerAlbumArtDropShadow
          ? Consumer<BackgroundProvider>(
              builder: (context, background, child) => AnimatedContainer(
                  duration: const Duration(seconds: 1),
                  decoration: BoxDecoration(boxShadow: [
                    BoxShadow(
                        color: background.dominantColor ?? Colors.transparent,
                        spreadRadius: 0.0,
                        blurRadius: 100.0)
                  ]),
                  child: child),
              child: child,
            )
          : child,
    );
  }
}

//Top row containing QueueSource, queue...
class PlayerScreenTopRow extends StatelessWidget {
  final double? textSize;
  final double? iconSize;
  final double? textWidth;
  final bool short;
  final bool showQueueButton; // not needed on desktop
  const PlayerScreenTopRow(
      {super.key,
      this.textSize,
      this.iconSize,
      this.textWidth,
      this.short = false,
      this.showQueueButton = true});

  @override
  Widget build(BuildContext context) {
    final size = iconSize ?? 52.sp;
    return Row(
      mainAxisSize: MainAxisSize.max,
      mainAxisAlignment: MainAxisAlignment.spaceBetween,
      crossAxisAlignment: CrossAxisAlignment.center,
      children: <Widget>[
        IconButton(
          onPressed: FancyScaffold.of(context)!.closePanel,
          icon: Icon(
            Icons.keyboard_arrow_down,
            semanticLabel: 'Close'.i18n,
          ),
          iconSize: size,
          splashRadius: size * 1.5,
        ),
        Expanded(
          child: StreamBuilder<QueueSource>(
              stream: playerHelper.queueSource,
              builder: (context, snapshot) {
                final queueSource = snapshot.data;
                if (queueSource == null) {
                  return const SizedBox.shrink();
                }
                return RichText(
                    textAlign: TextAlign.center,
                    maxLines: 2,
                    text: TextSpan(children: [
                      if (!short)
                        TextSpan(
                            text: '${'PLAYING FROM'.i18n}\n',
                            style: TextStyle(
                                fontWeight: FontWeight.bold,
                                letterSpacing: 1.5,
                                fontSize: (textSize ?? 38.sp) * 0.85)),
                      TextSpan(text: queueSource.text ?? '')
                    ], style: TextStyle(fontSize: textSize ?? 38.sp)));
              }),
        ),
        showQueueButton
            ? IconButton(
                icon: Icon(
                  Icons.menu,
                  semanticLabel: "Queue".i18n,
                ),
                iconSize: size,
                splashRadius: size * 1.5,
                onPressed: () => Navigator.of(context).pushRoute(
                    builder: (ctx) => QueueScreen(
                          closePlayer: FancyScaffold.of(context)!.closePanel,
                        )),
              )
            : SizedBox.square(dimension: size + 16.0),
      ],
    );
  }
}

class SeekBar extends StatefulWidget {
  final double textSize;

  const SeekBar({Key? key, this.textSize = 16.0}) : super(key: key);

  @override
  State<SeekBar> createState() => _SeekBarState();
}

class _SeekBarState extends State<SeekBar> {
  bool _seeking = false;
  late StreamSubscription _subscription;
  final position = ValueNotifier<Duration>(Duration.zero);

  @override
  void initState() {
    _subscription = AudioService.position.listen((position) {
      if (_seeking) return; // user is seeking
      this.position.value = position;
    });
    super.initState();
  }

  @override
  void dispose() {
    _subscription.cancel();
    super.dispose();
  }

  double parseDuration(Duration position) {
    if (position > duration) return duration.inMilliseconds.toDouble();
    return position.inMilliseconds.toDouble();
  }

  //Duration to mm:ss
  String _timeString(Duration d) {
    return "${d.inMinutes}:${d.inSeconds.remainder(60).toString().padLeft(2, '0')}";
  }

  Duration get duration {
    if (audioHandler.mediaItem.value == null) return Duration.zero;
    return audioHandler.mediaItem.value!.duration!;
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      mainAxisSize: MainAxisSize.min,
      children: <Widget>[
        ValueListenableBuilder<Duration>(
            valueListenable: position,
            builder: (context, value, _) => StreamBuilder<Duration>(
                stream: playerHelper.bufferPosition,
                builder: (context, snapshot) {
                  return Slider(
                    secondaryTrackValue:
                        parseDuration(snapshot.data ?? Duration.zero),
                    focusNode: FocusNode(
                        canRequestFocus: false,
                        skipTraversal:
                            true), // Don't focus on Slider - it doesn't work (and not needed)
                    value: parseDuration(value),
                    max: duration.inMilliseconds.toDouble(),
                    onChangeStart: (double d) {
                      _seeking = true;
                      position.value = Duration(milliseconds: d.toInt());
                    },
                    onChanged: (double d) {
                      position.value = Duration(milliseconds: d.toInt());
                    },
                    onChangeEnd: (double d) {
                      _seeking = false;
                      audioHandler.seek(Duration(milliseconds: d.toInt()));
                    },
                  );
                })),
        Padding(
          padding: const EdgeInsets.symmetric(horizontal: 24.0),
          child: Row(
            mainAxisAlignment: MainAxisAlignment.spaceBetween,
            children: <Widget>[
              ValueListenableBuilder<Duration>(
                  valueListenable: position,
                  builder: (context, value, _) => Text(
                        _timeString(value),
                        style: TextStyle(
                            fontSize: widget.textSize,
                            color: Theme.of(context)
                                .textTheme
                                .bodyMedium!
                                .color!
                                .withOpacity(.75)),
                      )),
              StreamBuilder<MediaItem?>(
                  stream: audioHandler.mediaItem,
                  builder: (context, snapshot) => Text(
                        _timeString(snapshot.data?.duration ?? Duration.zero),
                        style: TextStyle(
                            fontSize: widget.textSize,
                            color: Theme.of(context)
                                .textTheme
                                .bodyMedium!
                                .color!
                                .withOpacity(.75)),
                      )),
            ],
          ),
        ),
      ],
    );
  }
}

class BottomBarControls extends StatelessWidget {
  final double size;
  final bool
      desktopMode; // removed in desktop mode, because there's a tabbed view which includes it
  const BottomBarControls({
    super.key,
    required this.size,
    this.desktopMode = false,
  });

  @override
  Widget build(BuildContext context) {
    final iconSize = size * 0.9;
    if (playerHelper.queueSource.valueOrNull?.source == 'show') {
      return Row(
        crossAxisAlignment: CrossAxisAlignment.center,
        mainAxisAlignment: MainAxisAlignment.spaceEvenly,
        children: [
          QualityInfoWidget(
            textSize: size * 0.75,
          ),
          PlayerMenuButton(size: size),
        ],
      );
    }
    return Row(
      mainAxisSize: MainAxisSize.max,
      mainAxisAlignment: MainAxisAlignment.spaceEvenly,
      crossAxisAlignment: CrossAxisAlignment.center,
      children: <Widget>[
        QualityInfoWidget(textSize: size * 0.75),
        const Expanded(child: SizedBox()),
        if (!desktopMode)
          IconButton(
              iconSize: size,
              icon: Icon(
                Icons.subtitles,
                semanticLabel: "Lyrics".i18n,
              ),
              onPressed: () => _pushLyrics(context)),
        IconButton(
            icon: Icon(
              Icons.sentiment_very_dissatisfied,
              semanticLabel: "Dislike".i18n,
            ),
            iconSize: iconSize,
            onPressed: () async {
              unawaited(
                  deezerAPI.dislikeTrack(audioHandler.mediaItem.value!.id));
              if (playerHelper.queueIndex <
                  audioHandler.queue.value.length - 1) {
                audioHandler.skipToNext();
              }
            }),
        // IconButton(
        //   iconSize: size,
        //   icon: Icon(
        //     Icons.file_download,
        //     semanticLabel: "Download".i18n,
        //   ),
        //   onPressed: () async {
        //     Track t = Track.fromMediaItem(audioHandler.mediaItem.value!);
        //     if (await downloadManager.addOfflineTrack(t,
        //             private: false, context: context, isSingleton: true) !=
        //         false)
        //       Fluttertoast.showToast(
        //           msg: 'Downloads added!'.i18n,
        //           gravity: ToastGravity.BOTTOM,
        //           toastLength: Toast.LENGTH_SHORT);
        //   },
        // ),
        FavoriteButton(size: iconSize),
        desktopMode
            ? PlayerMenuButtonDesktop(size: iconSize)
            : PlayerMenuButton(size: iconSize)
      ],
    );
  }

  void _pushLyrics(BuildContext context) {
    builder(ctx) => ChangeNotifierProvider<BackgroundProvider>.value(
        value: Provider.of<BackgroundProvider>(context),
        child: const LyricsScreen());
    Navigator.of(context).pushRoute(builder: builder);
  }
}