// Author: fruit.com.cn

import 'dart:async';

import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:provider/provider.dart';

import '../../core/data/models/drama.dart';
import '../../core/data/models/play_ticket.dart';
import '../../core/data/models/watch_progress.dart';
import '../../core/data/models/player_port.dart';
import '../../core/data/remote/api_client.dart';
import '../../core/data/repositories/playback_repository.dart';
import '../../core/data/repositories/watch_history_repository.dart';
import '../../core/data/services/android_picture_in_picture.dart';
import '../../core/data/services/catalog_controller.dart';
import '../../core/data/services/platform_share_service.dart';
import '../../core/data/services/playback_queue.dart';
import '../../core/data/services/playback_session.dart';
import '../../core/data/services/video_player_port.dart';
import '../../core/formatting/localized_content.dart';
import '../../core/theme/app_colors.dart';
import '../../l10n/app_localizations.dart';
import '../discover/discover_logic.dart';
import '../discover/discover_view.dart';
import '../drama_detail/drama_detail_view.dart';
import '../mine/mine_logic.dart';
import '../mine/mine_view.dart';
import 'player_view.dart';
import 'widgets/drama_comments_sheet.dart';

class PlayerLogic extends ChangeNotifier {
  PlayerLogic({
    required this.history,
    required this.playback,
    required this.pictureInPicture,
  });

  final WatchHistoryRepository history;
  final PlaybackRepository playback;
  final AndroidPictureInPicture pictureInPicture;

  late PageController pages;
  late PlaybackQueue queue;
  late List<int> visibleIndices;
  late PlaybackSession session;
  VideoPlayerPort? trackedPlayer;
  Episode? trackedEpisode;
  Drama? trackedDrama;
  DateTime lastProgressWrite = DateTime.fromMillisecondsSinceEpoch(0);

  /// 进度上报节流：契约建议每 10 秒一次
  Duration progressInterval = const Duration(seconds: 10);
  Future<void> pendingWrite = Future<void>.value();

  /// 服务端续看点：进入播放页时定位到"那一集的哪一秒"
  ResumePoint? resumePoint;
  bool resumeLoaded = false;

  /// 票据三态：加载中 / 失败（可重试）/ 被后端判定为不可播放
  bool ticketLoading = false;
  String? ticketError;
  PlayTicket? blockedTicket;
  String? blockedEpisodeId;
  List<Episode> sessionEpisodes = const [];
  int pageRequest = 0;
  bool muted = false;
  bool stoppedAtFeedEnd = false;
  VideoPlayerPort? scrubbingPlayer;
  bool fullscreen = false;
  bool pip = false;
  bool pipPreparing = false;
  bool screenCleared = false;
  final Map<String, int> pickedEpisode = {};

  bool Function() isMounted = () => false;
  bool homeMode = false;
  bool embedded = false;
  bool active = true;
  int resumeRequest = 0;
  int backRequest = 0;
  int initialIndex = 0;
  late Drama pageDrama;
  List<Drama>? feedDramas;
  VoidCallback? onDiscover;
  VoidCallback? onMy;
  VoidCallback? onSearch;
  VoidCallback? onMenu;
  ValueChanged<Drama>? onDramaChanged;
  ValueChanged<bool>? onImmersiveChanged;
  bool _disposed = false;

  /// [start] 是否已经跑过：没跑过时 session/pages 还是 late 未初始化，
  /// dispose 不能直接碰它们（例如页面构建失败或纯逻辑测试）。
  bool _started = false;

  bool get immersive => fullscreen || pip || pipPreparing;

  bool get chromeHidden => immersive || screenCleared;

  Episode displayEpisode(Drama drama, Episode fallback) {
    final number = pickedEpisode[drama.id];
    if (number == null) return fallback;
    for (final episode in drama.episodes) {
      if (episode.number == number) return episode;
    }
    return fallback;
  }

  void setScreenCleared(bool value) {
    if (screenCleared == value) return;
    screenCleared = value;
    notify();
    notifyImmersive();
  }

  void notify() {
    if (!_disposed) notifyListeners();
  }

  void attach(PlayerPage page, {required bool Function() isMounted}) {
    this.isMounted = isMounted;
    homeMode = page.homeMode;
    embedded = page.embedded;
    active = page.active;
    resumeRequest = page.resumeRequest;
    backRequest = page.backRequest;
    initialIndex = page.initialIndex;
    pageDrama = page.drama;
    feedDramas = page.feedDramas;
    onDiscover = page.onDiscover;
    onMy = page.onMy;
    onSearch = page.onSearch;
    onMenu = page.onMenu;
    onDramaChanged = page.onDramaChanged;
    onImmersiveChanged = page.onImmersiveChanged;
  }

  void start({
    required PlayerFactory factory,
    required PlaybackCoordinator coordinator,
  }) {
    _started = true;
    pictureInPicture.setStateListener(onPipChanged);
    queue = feedDramas == null
        ? PlaybackQueue.series(pageDrama)
        : PlaybackQueue.home(feedDramas!);
    visibleIndices = List<int>.generate(queue.length, (index) => index);
    pages = PageController(initialPage: initialIndex);
    // 票据解析后要把新地址写回这个列表（PlaybackSession 的 canPlay 读的就是它）
    sessionEpisodes = [for (final entry in queue.entries) entry.episode];
    session = PlaybackSession(
      episodes: sessionEpisodes,
      factory: factory,
      // 地址只由后端下发（票据或详情里的免费集签名地址），拿不到地址即视为锁定
      canPlay: (episode) => episode.videoUrl.isNotEmpty,
      prepare: preparePlayer,
      activate: activatePlayer,
      coordinator: coordinator,
    );
    if (!active || visibleIndices.isEmpty) {
      session.setRouteVisible(false);
    }
    unawaited(loadResumePoint());
    unawaited(selectEpisode(initialIndex));
  }

  /// 服务端续看位置：进播放页时取一次，用于"定位到上次那一集的那一秒"。
  Future<void> loadResumePoint() async {
    final dramaId = queue.entryAt(initialIndex).drama.id;
    try {
      resumePoint = await history.resumePointFor(dramaId);
    } catch (_) {
      // 拿不到续看位置不影响播放：从当前集开头看
      resumePoint = null;
    } finally {
      resumeLoaded = true;
      if (isMounted()) notify();
    }
  }

  /// 票据门：起播前先拿票（命中未过期缓存就不会重复请求），
  /// 该集是否该定位到服务端记录的位置：只有"记录里的那一集"才定位，其它集从头播。
  Duration? resumePositionFor(String episodeId) {
    final point = resumePoint;
    if (point == null || point.episodeId != episodeId) return null;
    if (point.position <= Duration.zero) return null;
    return point.position;
  }

  /// 进度上报节流：距上次上报不足 [progressInterval] 就不报。
  ///
  /// 切集/退出/切后台走 [saveCurrentProgress]，那条路径**不受节流限制**。
  bool shouldReportProgress(DateTime now) {
    if (now.difference(lastProgressWrite) < progressInterval) return false;
    lastProgressWrite = now;
    return true;
  }

  /// 票据门：起播前先拿票（命中未过期缓存就不会重复请求），
  /// 拿不到地址就交给 [blockedTicket] 让 UI 提示解锁/暂无片源。
  Future<bool> ensureTicket(int index) async {
    if (index < 0 || index >= sessionEpisodes.length) return false;
    final episode = sessionEpisodes[index];
    final request = pageRequest;
    ticketLoading = true;
    ticketError = null;
    notify();
    try {
      final ticket = await playback.ticketFor(episode.id);
      if (request != pageRequest) return false;
      blockedTicket = null;
      blockedEpisodeId = null;
      if (ticket.accessible && ticket.playUrl.isNotEmpty) {
        // 签名地址原样写回，不做任何拼接/改写（AppConfig.mediaUrl 只补 host）
        sessionEpisodes[index] = episode.withVideoUrl(ticket.playUrl);
        return true;
      }
      blockedTicket = ticket;
      blockedEpisodeId = episode.id;
      return false;
    } catch (exception) {
      if (request != pageRequest) return false;
      // 详情里已有可用地址（免费集）时降级继续，避免票据服务抖动就完全看不了
      if (episode.videoUrl.isNotEmpty) {
        ticketError = null;
        return true;
      }
      ticketError = exception is ApiException
          ? exception.message
          : 'ticketError';
      return false;
    } finally {
      ticketLoading = false;
      if (isMounted()) notify();
    }
  }

  /// 重试当前集的票据（失败态的"重试"按钮）。
  Future<void> retryTicket() async {
    ticketError = null;
    notify();
    unawaited(selectEpisode(session.currentIndex));
  }

  void onPageUpdated(PlayerPage previous) {
    if (previous.active != active) {
      session.setRouteVisible(active && visibleIndices.isNotEmpty);
      if (!active) {
        cancelScrub();
        unawaited(saveCurrentProgress());
      }
    }
    if (previous.resumeRequest != resumeRequest) {
      session.setUserWantsPlay(true);
    }
    if (previous.backRequest != backRequest) {
      final request = backRequest;
      WidgetsBinding.instance.addPostFrameCallback((_) {
        if (isMounted() && backRequest == request) {
          if (fullscreen) {
            unawaited(setFullscreen(false));
          } else if (screenCleared) {
            setScreenCleared(false);
          } else {
            onMenu?.call();
          }
        }
      });
    }
  }

  void onLifecycle(AppLifecycleState state) {
    if (state != AppLifecycleState.resumed) unawaited(saveCurrentProgress());
    if (state == AppLifecycleState.resumed) {
      // 签名地址有有效期：回前台时若票据已过期，重新取一张再起播，
      // 否则会撞上 403（契约 §1.4）
      final episode = trackedEpisode;
      if (episode != null && !playback.isFresh(episode.id)) {
        unawaited(selectEpisode(session.currentIndex));
      }
    }
    session.setAppResumed(
      state == AppLifecycleState.resumed || pip || pipPreparing,
    );
    if (state != AppLifecycleState.resumed) cancelScrub();
  }

  @override
  void dispose() {
    if (_disposed) return;
    _disposed = true;
    pictureInPicture.setStateListener(null);
    if (fullscreen) {
      unawaited(
        SystemChrome.setPreferredOrientations([DeviceOrientation.portraitUp]),
      );
      unawaited(SystemChrome.setEnabledSystemUIMode(SystemUiMode.edgeToEdge));
    }
    unawaited(saveCurrentProgress());
    if (_started) {
      session.setRouteVisible(false);
      cancelScrub();
      unawaited(session.close());
      pages.dispose();
    }
    super.dispose();
  }

  void notifyImmersive() => onImmersiveChanged?.call(chromeHidden);

  Future<void> setFullscreen(bool value) async {
    if (fullscreen == value || !isMounted()) return;
    fullscreen = value;
    notify();
    notifyImmersive();
    try {
      await SystemChrome.setPreferredOrientations(
        value
            ? [
                DeviceOrientation.landscapeLeft,
                DeviceOrientation.landscapeRight,
              ]
            : [DeviceOrientation.portraitUp],
      );
      await SystemChrome.setEnabledSystemUIMode(
        value ? SystemUiMode.immersiveSticky : SystemUiMode.edgeToEdge,
      );
    } catch (_) {
      if (value && isMounted()) {
        fullscreen = false;
        notify();
        notifyImmersive();
      }
    }
  }

  Future<void> enterPip(BuildContext context) async {
    if (pip || pipPreparing) return;
    if (session.active is! VideoPlayerPort) {
      ScaffoldMessenger.of(context).showSnackBar(
        SnackBar(content: Text(AppLocalizations.of(context)!.pipUnavailable)),
      );
      return;
    }
    if (fullscreen) await setFullscreen(false);
    pipPreparing = true;
    notify();
    notifyImmersive();
    await WidgetsBinding.instance.endOfFrame;
    bool entered = false;
    try {
      entered = await pictureInPicture.enter();
    } catch (_) {
      // Android reports unavailable for devices without PiP support.
    }
    if (!context.mounted) return;
    if (entered) {
      pip = true;
      pipPreparing = false;
      notify();
      notifyImmersive();
      session.setAppResumed(true);
    } else {
      pipPreparing = false;
      notify();
      notifyImmersive();
      ScaffoldMessenger.of(context).showSnackBar(
        SnackBar(content: Text(AppLocalizations.of(context)!.pipUnavailable)),
      );
    }
  }

  void onPipChanged(bool enabled) {
    if (!isMounted()) return;
    pip = enabled;
    pipPreparing = false;
    notify();
    notifyImmersive();
    session.setAppResumed(
      enabled ||
          WidgetsBinding.instance.lifecycleState == AppLifecycleState.resumed,
    );
  }

  Future<void> preparePlayer(Episode episode, PlayerPort player) async {
    if (player is! VideoPlayerPort) return;
    try {
      await pendingWrite;
      // 服务端每剧只记一条：只有"记录里的那一集"才定位，其它集从头播
      if (resumePoint == null) await loadResumePoint();
      final saved = resumePositionFor(episode.id);
      if (saved != null) {
        await player.controller.seekTo(
          clampResumePosition(saved, player.controller.value.duration),
        );
      }
    } catch (_) {
      // 续看位置取不到不影响播放：从头播。
    }
  }

  Future<void> activatePlayer(Episode episode, PlayerPort player) async {
    if (player is! VideoPlayerPort) return;
    final index = session.currentIndex;
    final drama = queue.entryAt(index).drama;
    await player.controller.setVolume(muted ? 0 : 1);
    if (session.active != player) return;
    trackedPlayer = player;
    trackedEpisode = episode;
    trackedDrama = drama;
    lastProgressWrite = DateTime.now();
    var completionHandled = false;
    var completionProgressSaved = false;
    player.controller.addListener(() {
      if (session.active != player || !player.controller.value.isInitialized) {
        return;
      }
      if (player.controller.value.isCompleted && !completionProgressSaved) {
        completionProgressSaved = true;
        unawaited(
          queueProgress(
            drama,
            episode,
            player.controller.value.duration,
            duration: player.controller.value.duration,
            finished: true,
          ),
        );
      }
      if (!completionHandled &&
          player.controller.value.isCompleted &&
          session.canAutoAdvance &&
          session.currentIndex == index) {
        completionHandled = true;
        unawaited(advanceAfterEnd(player, index));
      }
      if (!shouldReportProgress(DateTime.now())) return;
      unawaited(
        queueProgress(drama, episode, player.controller.value.position),
      );
    });
  }

  Future<void> advanceAfterEnd(VideoPlayerPort player, int index) async {
    if (!isMounted() || session.active != player || !session.canAutoAdvance) {
      return;
    }
    final next = visibleIndices.indexOf(index) + 1;
    if (next <= 0 || next >= visibleIndices.length) {
      stoppedAtFeedEnd = true;
      session.setUserWantsPlay(false);
      return;
    }
    final controller = pages;
    try {
      if (!controller.hasClients) return;
      await controller.animateToPage(
        next,
        duration: const Duration(milliseconds: 250),
        curve: Curves.easeOutCubic,
      );
    } catch (_) {
      // The page can leave the tree before the animation finishes.
    }
  }

  /// 进度上报：节流由调用方控制（10 秒），切集/退出/切后台都会补一次。
  Future<void> queueProgress(
    Drama drama,
    Episode episode,
    Duration position, {
    Duration? duration,
    bool finished = false,
  }) {
    pendingWrite = pendingWrite
        .then(
          (_) => history.save(
            episodeId: episode.id,
            position: position,
            duration: duration,
            finished: finished,
          ),
        )
        .catchError((Object _) {
          // 进度上报失败不影响播放（下次节流点会再报一次）。
          return null;
        });
    return pendingWrite;
  }

  Future<void> saveCurrentProgress() {
    final player = trackedPlayer;
    final episode = trackedEpisode;
    final drama = trackedDrama;
    if (player == null ||
        episode == null ||
        drama == null ||
        !player.controller.value.isInitialized) {
      return pendingWrite;
    }
    return queueProgress(
      drama,
      episode,
      player.controller.value.position,
      duration: player.controller.value.duration,
    );
  }

  Future<void> selectEpisode(int index) async {
    final request = ++pageRequest;
    cancelScrub();
    // Capture the old position synchronously, persist without blocking a swipe.
    unawaited(saveCurrentProgress());
    if (request != pageRequest || !isMounted()) return;
    // 起播前先要票据：拿不到就不起播，交给三态 UI 提示（失败可重试）
    final ready = await ensureTicket(index);
    if (request != pageRequest || !isMounted()) return;
    if (!ready && ticketError != null) return;
    await session.select(index, preloadIndex: nextVisibleIndex(index));
  }

  int? nextVisibleIndex(int index) {
    final position = visibleIndices.indexOf(index);
    return position >= 0 && position + 1 < visibleIndices.length
        ? visibleIndices[position + 1]
        : null;
  }

  void beginScrub(VideoPlayerPort player) {
    if (session.active != player) return;
    scrubbingPlayer = player;
    session.setOverlayOpen(true);
  }

  void cancelScrub() {
    if (scrubbingPlayer == null) return;
    scrubbingPlayer = null;
    session.setOverlayOpen(false);
  }

  Future<void> seekTo(
    BuildContext context,
    VideoPlayerPort player,
    Duration position,
  ) async {
    if (scrubbingPlayer != player || session.active != player) return;
    try {
      await session.playbackSettled;
      if (scrubbingPlayer != player || session.active != player) return;
      await player.controller.seekTo(position);
      if (session.active == player) await saveCurrentProgress();
    } catch (_) {
      if (context.mounted && session.active == player) {
        final l10n = AppLocalizations.of(context)!;
        ScaffoldMessenger.of(
          context,
        ).showSnackBar(SnackBar(content: Text(l10n.seekFailed)));
      }
    } finally {
      if (scrubbingPlayer == player) cancelScrub();
    }
  }

  Future<void> leave(BuildContext context) async {
    await saveCurrentProgress();
    if (context.mounted) Navigator.of(context).pop();
  }

  Future<void> openDetail(BuildContext context) async {
    session.setRouteVisible(false);
    await session.playbackSettled;
    await saveCurrentProgress();
    if (!context.mounted) return;
    await Navigator.of(context).push(
      MaterialPageRoute<void>(
        builder: (_) =>
            DramaDetailPage(drama: queue.entryAt(session.currentIndex).drama),
      ),
    );
    if (isMounted()) session.setRouteVisible(active);
  }

  Future<void> openSeriesAt(
    BuildContext context,
    Drama drama,
    int index,
  ) async {
    session.setRouteVisible(false);
    await session.playbackSettled;
    await saveCurrentProgress();
    if (!context.mounted) return;
    await Navigator.of(context).push(
      MaterialPageRoute<void>(
        builder: (_) => PlayerPage(drama: drama, initialIndex: index),
      ),
    );
    if (isMounted()) session.setRouteVisible(active);
  }

  Future<void> showEpisodes(BuildContext context) async {
    final l10n = AppLocalizations.of(context)!;
    final entry = queue.entryAt(session.currentIndex);
    final drama = await _withFullEpisodes(context, entry.drama);
    if (!context.mounted) return;
    final homeFeed = feedDramas != null;
    final episodes = drama.episodes;
    final currentNumber = entry.episode.number;
    session.setOverlayOpen(true);
    await session.playbackSettled;
    if (!context.mounted) {
      session.setOverlayOpen(false);
      return;
    }
    try {
      await showModalBottomSheet<void>(
        context: context,
        backgroundColor: const Color(0xFF16171C),
        showDragHandle: true,
        builder: (sheetContext) => SafeArea(
          child: SizedBox(
            height: MediaQuery.sizeOf(sheetContext).height * 0.46,
            child: Column(
              crossAxisAlignment: CrossAxisAlignment.start,
              children: [
                Padding(
                  padding: const EdgeInsets.fromLTRB(20, 0, 20, 4),
                  child: Text(
                    l10n.episodes,
                    style: const TextStyle(
                      fontSize: 18,
                      fontWeight: FontWeight.w600,
                    ),
                  ),
                ),
                Padding(
                  padding: const EdgeInsets.fromLTRB(20, 0, 20, 16),
                  child: Text(
                    localizedDramaTitle(l10n, drama),
                    maxLines: 1,
                    overflow: TextOverflow.ellipsis,
                    style: const TextStyle(
                      color: Color(0xFFB7B3B8),
                      fontSize: 14,
                      fontWeight: FontWeight.w400,
                    ),
                  ),
                ),
                Expanded(
                  child: GridView.builder(
                    padding: const EdgeInsets.fromLTRB(16, 0, 16, 16),
                    gridDelegate:
                        const SliverGridDelegateWithFixedCrossAxisCount(
                          crossAxisCount: 6,
                          mainAxisSpacing: 10,
                          crossAxisSpacing: 10,
                          childAspectRatio: 1.45,
                        ),
                    itemCount: episodes.length,
                    itemBuilder: (_, index) => _episodeCell(
                      context,
                      sheetContext,
                      drama,
                      episodes[index],
                      index,
                      homeFeed,
                      currentNumber,
                    ),
                  ),
                ),
              ],
            ),
          ),
        ),
      );
    } finally {
      session.setOverlayOpen(false);
    }
  }

  /// 列表卡片只带一集可播预览，需要完整剧集时补一次详情；
  /// 取不到（或页面外没有目录来源）就退回卡片本身。
  Future<Drama> _withFullEpisodes(BuildContext context, Drama drama) async {
    if (drama.detailLoaded) return drama;
    final CatalogController catalog;
    try {
      catalog = context.read<CatalogController>();
    } catch (_) {
      return drama;
    }
    try {
      return await catalog.requireDetail(drama);
    } catch (_) {
      return drama;
    }
  }

  Widget _episodeCell(
    BuildContext pageContext,
    BuildContext sheetContext,
    Drama drama,
    Episode episode,
    int index,
    bool homeFeed,
    int currentNumber,
  ) {
    final selected = episode.number == currentNumber;
    return Material(
      color: selected ? AppColors.bluePressed : const Color(0xFF2A2C33),
      borderRadius: BorderRadius.circular(8),
      child: InkWell(
        borderRadius: BorderRadius.circular(8),
        onTap: () {
          Navigator.of(sheetContext).pop();
          if (homeFeed) {
            if (episode.number == currentNumber) return;
            unawaited(openSeriesAt(pageContext, drama, index));
            return;
          }
          if (index == session.currentIndex) return;
          unawaited(
            pages.animateToPage(
              index,
              duration: const Duration(milliseconds: 260),
              curve: Curves.easeOutCubic,
            ),
          );
        },
        child: Center(
          child: Text(
            '${episode.number}',
            style: const TextStyle(
              color: Colors.white,
              fontSize: 15,
              fontWeight: FontWeight.w600,
            ),
          ),
        ),
      ),
    );
  }

  Future<void> showMy(BuildContext context, {int initialSection = 0}) async {
    if (embedded) {
      onMy?.call();
      return;
    }
    session.setRouteVisible(false);
    await session.playbackSettled;
    await saveCurrentProgress();
    if (!context.mounted) return;
    final port = session.active;
    final drama = queue.entryAt(session.currentIndex).drama;
    final duration = port is VideoPlayerPort
        ? port.controller.value.duration
        : Duration.zero;
    final action = await Navigator.of(context).push<MyPageAction>(
      MaterialPageRoute(
        builder: (_) => MyPage(
          drama: drama,
          duration: duration,
          initialSection: initialSection,
        ),
      ),
    );
    if (!context.mounted) return;
    if (action == MyPageAction.discover) {
      await showDiscover(context);
    } else {
      session.setRouteVisible(true);
    }
    if (action == MyPageAction.resume) session.setUserWantsPlay(true);
  }

  Future<void> showSearch(BuildContext context) async {
    if (embedded) {
      onSearch?.call();
      return;
    }
    await showDiscover(context, focusSearch: true);
  }

  Future<void> showDiscover(
    BuildContext context, {
    bool focusSearch = false,
  }) async {
    if (embedded) {
      onDiscover?.call();
      return;
    }
    session.setRouteVisible(false);
    await session.playbackSettled;
    await saveCurrentProgress();
    if (!context.mounted) return;
    final port = session.active;
    final duration = port is VideoPlayerPort
        ? port.controller.value.duration
        : Duration.zero;
    final action = await Navigator.of(context).push<DiscoverPageAction>(
      MaterialPageRoute(
        builder: (_) => DiscoverPage(
          drama: pageDrama,
          duration: duration,
          focusSearch: focusSearch,
        ),
      ),
    );
    if (!context.mounted) return;
    if (action == DiscoverPageAction.detail) {
      await openDetail(context);
    } else if (action == DiscoverPageAction.my ||
        action == DiscoverPageAction.watchlist) {
      await showMy(
        context,
        initialSection: action == DiscoverPageAction.watchlist ? 1 : 0,
      );
    } else {
      session.setRouteVisible(true);
      if (action == DiscoverPageAction.resume) {
        session.setUserWantsPlay(true);
      }
    }
  }

  Future<void> toggleMute() async {
    final port = session.active;
    if (port is! VideoPlayerPort) return;
    final next = !muted;
    await port.controller.setVolume(next ? 0 : 1);
    if (isMounted()) muted = next;
    notify();
  }

  Future<void> showComments(BuildContext context, Drama drama) async {
    session.setOverlayOpen(true);
    await session.playbackSettled;
    if (!context.mounted) {
      session.setOverlayOpen(false);
      return;
    }
    try {
      await showModalBottomSheet<void>(
        context: context,
        isScrollControlled: true,
        backgroundColor: const Color(0xFF232328),
        showDragHandle: true,
        builder: (_) => DramaCommentsSheet(drama: drama),
      );
    } finally {
      session.setOverlayOpen(false);
    }
  }

  Future<void> shareDrama(BuildContext context, Drama drama) async {
    final l10n = AppLocalizations.of(context)!;
    session.setOverlayOpen(true);
    await session.playbackSettled;
    try {
      await const PlatformShareService().shareDrama(
        title: localizedDramaTitle(l10n, drama),
        synopsis: localizedDramaSynopsis(l10n, drama),
        footer: l10n.shareFooter,
      );
    } catch (_) {
      if (context.mounted) {
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(content: Text(AppLocalizations.of(context)!.shareFailed)),
        );
      }
    } finally {
      session.setOverlayOpen(false);
    }
  }
}