liangchengyou / wow_english

import 'dart:async';

import 'package:chewie/chewie.dart';
import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:video_player/video_player.dart';
import 'package:wow_english/common/request/dao/video_dao.dart';
import 'package:wow_english/common/utils/video_playback_diagnostics.dart';
import 'package:wow_english/common/utils/video_progress_cache.dart';
import 'package:wow_english/common/utils/video_rendering_preference.dart';
import 'package:wow_english/utils/toast_util.dart';

import 'video_zone_item.dart';

class VideoZonePlayerPage extends StatefulWidget {
  const VideoZonePlayerPage({
    super.key,
    required this.items,
    this.initialVideoId,
  }) : assert(items.length > 0, '视频播放列表不能为空');

  final List<VideoZoneItem> items;
  final int? initialVideoId;

  @override
  State<VideoZonePlayerPage> createState() => _VideoZonePlayerPageState();
}

class _VideoZonePlayerPageState extends State<VideoZonePlayerPage>
    with WidgetsBindingObserver {
  static const _initializeTimeout = Duration(seconds: 10);
  static const _playerCommandTimeout = Duration(seconds: 5);
  static const _progressReadTimeout = Duration(seconds: 2);
  static const _bufferingWarningDelay = Duration(seconds: 10);

  VideoPlayerController? _controller;
  ChewieController? _chewieController;
  Timer? _cacheTimer;
  Timer? _bufferingTimer;
  late int _currentIndex;
  double _playbackSpeed = 1;
  bool _switchingVideo = false;
  bool _handlingCompletion = false;
  bool _bufferingWarningShown = false;
  bool? _lastIsPlaying;
  int? _completedReportedVideoId;
  Object? _loadError;

  VideoZoneItem get _currentItem => widget.items[_currentIndex];

  @override
  void initState() {
    super.initState();
    WidgetsBinding.instance.addObserver(this);
    unawaited(
      SystemChrome.setEnabledSystemUIMode(SystemUiMode.immersiveSticky),
    );
    final index = widget.initialVideoId == null
        ? 0
        : widget.items.indexWhere((item) => item.id == widget.initialVideoId);
    _currentIndex = index < 0 ? 0 : index;
    _loadCurrentVideo();
  }

  Future<void> _loadCurrentVideo() async {
    final useCupertinoControls = defaultTargetPlatform == TargetPlatform.iOS;
    _cacheTimer?.cancel();
    _bufferingTimer?.cancel();
    _bufferingWarningShown = false;
    final oldController = _controller;
    final oldChewieController = _chewieController;
    if (oldController?.value.isInitialized == true) {
      _playbackSpeed = oldController!.value.playbackSpeed;
    }
    oldController?.removeListener(_onVideoChanged);
    _lastIsPlaying = null;
    final controller = VideoPlayerController.networkUrl(
      Uri.parse(_currentItem.videoUrl),
      viewType: VideoRenderingPreference.viewType,
    );
    _controller = controller;
    _chewieController = null;
    _loadError = null;
    if (mounted) {
      setState(() {});
    }
    var stage = '释放旧播放器';
    try {
      oldChewieController?.dispose();
      await oldController?.dispose().timeout(_playerCommandTimeout);
      stage = '初始化视频流';
      await controller.initialize().timeout(_initializeTimeout);
      if (!mounted || controller != _controller) {
        await controller.dispose();
        return;
      }
      stage = '配置播放器';
      await controller.setLooping(false).timeout(_playerCommandTimeout);
      await controller
          .setPlaybackSpeed(_playbackSpeed)
          .timeout(_playerCommandTimeout);
      stage = '读取本地播放进度';
      final savedProgress = await _resumeProgressFor(_currentItem.id);
      if (!mounted || controller != _controller) {
        await controller.dispose();
        return;
      }
      if (savedProgress > 0 &&
          savedProgress < controller.value.duration.inSeconds) {
        stage = '恢复播放进度';
        try {
          await controller
              .seekTo(Duration(seconds: savedProgress))
              .timeout(_playerCommandTimeout);
        } on TimeoutException catch (error) {
          debugPrint(
            '恢复本地视频进度超时(videoId=${_currentItem.id}): $error',
          );
          _showVideoToast('恢复进度超时，已尝试从头播放');
        } catch (error) {
          debugPrint('恢复本地视频进度失败(videoId=${_currentItem.id}): $error');
          _showVideoToast('恢复进度失败，已尝试从头播放');
        }
      }
      stage = '创建播放界面';
      _lastIsPlaying = controller.value.isPlaying;
      controller.addListener(_onVideoChanged);
      _updateBufferingWatch(controller);
      _chewieController = ChewieController(
        videoPlayerController: controller,
        autoPlay: true,
        looping: false,
        allowFullScreen: false,
        allowPlaybackSpeedChanging: true,
        draggableProgressBar: true,
        allowedScreenSleep: false,
        playbackSpeeds: const [0.5, 0.75, 1, 1.25, 1.5, 2],
        customControls:
            useCupertinoControls ? null : const _VideoMaterialControls(),
        optionsTranslation: OptionsTranslation(
          playbackSpeedButtonText: '播放速度',
          cancelButtonText: '取消',
        ),
        materialProgressColors: ChewieProgressColors(
          playedColor: const Color(0xFF00B6F1),
          handleColor: const Color(0xFF00B6F1),
          bufferedColor: Colors.white54,
          backgroundColor: Colors.white24,
        ),
        cupertinoProgressColors: ChewieProgressColors(
          playedColor: const Color(0xFF00B6F1),
          handleColor: const Color(0xFF00B6F1),
          bufferedColor: Colors.white54,
          backgroundColor: Colors.white24,
        ),
        placeholder: const ColoredBox(color: Colors.black),
        errorBuilder: (_, __) => const Center(
          child: Text(
            '视频播放失败',
            style: TextStyle(color: Colors.white, fontSize: 18),
          ),
        ),
      );
      _handlingCompletion = false;
      _cacheTimer = Timer.periodic(
        const Duration(seconds: 30),
        (_) {
          if (_controller?.value.isPlaying == true) {
            unawaited(_cacheCurrentProgress());
          }
        },
      );
      setState(() {});
    } catch (error) {
      final failedCurrentController = controller == _controller;
      if (failedCurrentController) {
        controller.removeListener(_onVideoChanged);
        _bufferingTimer?.cancel();
        _bufferingTimer = null;
        _cacheTimer?.cancel();
        _cacheTimer = null;
        _chewieController?.dispose();
        _chewieController = null;
      }
      await VideoPlaybackDiagnostics.disposeController(
        controller,
        context: '视频专区初始化失败($stage)',
      );
      if (!mounted || !failedCurrentController) return;
      _controller = null;
      final message = _diagnosticMessage(stage, error);
      debugPrint('$message (videoId=${_currentItem.id}): $error');
      _showVideoToast('$message（视频ID: ${_currentItem.id}）');
      setState(() => _loadError = error);
    }
  }

  void _onVideoChanged() {
    final controller = _controller;
    if (!mounted || controller == null) return;
    _updateBufferingWatch(controller);
    if (controller.value.hasError && _loadError == null) {
      final error = controller.value.errorDescription ?? '未知播放器错误';
      debugPrint('视频播放失败(videoId=${_currentItem.id}): $error');
      _showVideoToast(
        '${_diagnosticMessage('播放/解码', error)}（视频ID: ${_currentItem.id}）',
      );
      setState(() => _loadError = error);
      return;
    }
    final isPlaying = controller.value.isPlaying;
    if (_lastIsPlaying != null && _lastIsPlaying != isPlaying) {
      unawaited(_cacheCurrentProgress());
    }
    _lastIsPlaying = isPlaying;
    if (controller.value.isCompleted &&
        !_switchingVideo &&
        !_handlingCompletion &&
        _completedReportedVideoId != _currentItem.id) {
      _handlingCompletion = true;
      unawaited(_handleVideoCompleted());
    }
  }

  void _updateBufferingWatch(VideoPlayerController controller) {
    if (!controller.value.isBuffering) {
      _bufferingTimer?.cancel();
      _bufferingTimer = null;
      _bufferingWarningShown = false;
      return;
    }
    if (_bufferingTimer != null || _bufferingWarningShown) return;
    _bufferingTimer = Timer(_bufferingWarningDelay, () {
      _bufferingTimer = null;
      if (!mounted ||
          controller != _controller ||
          !controller.value.isBuffering) {
        return;
      }
      _bufferingWarningShown = true;
      final error = controller.value.errorDescription;
      final reason =
          error == null ? '网络缓冲或设备解码可能异常' : _diagnosticMessage('播放/解码', error);
      debugPrint('视频持续缓冲(videoId=${_currentItem.id}): $reason ${error ?? ''}');
      _showVideoToast('视频持续缓冲超过10秒：$reason（视频ID: ${_currentItem.id}）');
    });
  }

  Future<void> _playNext({bool currentCompleted = false}) async {
    if (_switchingVideo || _currentIndex >= widget.items.length - 1) return;
    _switchingVideo = true;
    await _reportCurrentProgress(completed: currentCompleted);
    setState(() => _currentIndex++);
    await _loadCurrentVideo();
    _switchingVideo = false;
  }

  Future<void> _handleVideoCompleted() async {
    if (_currentIndex < widget.items.length - 1) {
      await _playNext(currentCompleted: true);
    } else {
      await _reportCurrentProgress(completed: true);
    }
    _handlingCompletion = false;
  }

  @override
  void dispose() {
    WidgetsBinding.instance.removeObserver(this);
    unawaited(
      SystemChrome.setEnabledSystemUIMode(SystemUiMode.immersiveSticky),
    );
    _cacheTimer?.cancel();
    _bufferingTimer?.cancel();
    _controller?.removeListener(_onVideoChanged);
    unawaited(_reportCurrentProgress());
    _chewieController?.dispose();
    _controller?.dispose();
    super.dispose();
  }

  @override
  void didChangeAppLifecycleState(AppLifecycleState state) {
    if (state == AppLifecycleState.resumed) {
      unawaited(
        SystemChrome.setEnabledSystemUIMode(SystemUiMode.immersiveSticky),
      );
    } else if (state == AppLifecycleState.inactive ||
        state == AppLifecycleState.paused ||
        state == AppLifecycleState.detached) {
      unawaited(_cacheCurrentProgress());
    }
  }

  Future<void> _reportCurrentProgress({bool? completed}) async {
    final controller = _controller;
    if (controller == null || !controller.value.isInitialized) return;
    final currentItem = _currentItem;
    final durationSeconds = controller.value.duration.inSeconds;
    final progressSeconds = controller.value.position.inSeconds
        .clamp(0, durationSeconds > 0 ? durationSeconds : 0);
    final isCompleted = completed ?? controller.value.isCompleted;
    await _persistCachedProgress(
      videoId: currentItem.id,
      progressSeconds: progressSeconds,
      durationSeconds: durationSeconds,
      completed: isCompleted,
    );
    if (isCompleted && _completedReportedVideoId == currentItem.id) return;
    try {
      await VideoDao.savePlayRecord(
        videoId: currentItem.id,
        progressSeconds: progressSeconds,
        durationSeconds: durationSeconds,
        completed: isCompleted,
      );
      if (isCompleted) _completedReportedVideoId = currentItem.id;
    } catch (error) {
      debugPrint('保存视频播放记录失败: $error');
    }
  }

  Future<int> _resumeProgressFor(int videoId) async {
    try {
      final cached =
          await VideoProgressCache.get(videoId).timeout(_progressReadTimeout);
      if (cached != null) return cached.progressSeconds;
    } on TimeoutException catch (error) {
      debugPrint('读取本地视频进度超时(videoId=$videoId): $error');
      _showVideoToast('本地进度读取超时，已从头播放');
    } catch (error) {
      debugPrint('读取本地视频播放进度失败: $error');
      _showVideoToast('本地进度读取失败，已从头播放');
    }
    return 0;
  }

  String _diagnosticMessage(String stage, Object error) {
    final detail = error.toString().toLowerCase();
    if (error is TimeoutException) {
      if (stage == '初始化视频流') return '视频初始化超时，请检查网络或设备解码能力';
      if (stage == '释放旧播放器') return '播放器释放超时，请退出后重试';
      if (stage == '配置播放器') return '播放器配置超时，设备可能不支持当前播放参数';
      if (stage == '恢复播放进度') return '恢复播放进度超时';
      return '$stage超时';
    }
    if (detail.contains('decoder') ||
        detail.contains('codec') ||
        detail.contains('mediacodec') ||
        detail.contains('acodec')) {
      return '视频解码器启动失败，可能是设备兼容性问题';
    }
    if (detail.contains('http') ||
        detail.contains('socket') ||
        detail.contains('network') ||
        detail.contains('connection') ||
        detail.contains('source error') ||
        detail.contains('sourceerror')) {
      return '视频网络请求失败，请检查网络或视频地址';
    }
    if (stage == '初始化视频流') return '视频流初始化失败';
    if (stage == '配置播放器') return '播放器配置失败';
    if (stage == '播放/解码') return '视频播放/解码失败，请检查网络或设备兼容性';
    return '$stage失败';
  }

  void _showVideoToast(String message) {
    showToast(message, duration: const Duration(seconds: 4));
  }

  Future<void> _cacheCurrentProgress() async {
    final controller = _controller;
    if (controller == null || !controller.value.isInitialized) return;
    final currentItem = _currentItem;
    final durationSeconds = controller.value.duration.inSeconds;
    final progressSeconds = controller.value.position.inSeconds
        .clamp(0, durationSeconds > 0 ? durationSeconds : 0);
    await _persistCachedProgress(
      videoId: currentItem.id,
      progressSeconds: progressSeconds,
      durationSeconds: durationSeconds,
      completed: controller.value.isCompleted,
    );
  }

  Future<void> _persistCachedProgress({
    required int videoId,
    required int progressSeconds,
    required int durationSeconds,
    required bool completed,
  }) async {
    try {
      if (completed) {
        await VideoProgressCache.remove(videoId);
      } else {
        await VideoProgressCache.save(
          videoId: videoId,
          progressSeconds: progressSeconds,
          durationSeconds: durationSeconds,
        );
      }
    } catch (error) {
      debugPrint('保存本地视频播放进度失败: $error');
    }
  }

  @override
  Widget build(BuildContext context) {
    final controller = _controller;
    final chewieController = _chewieController;
    return MediaQuery.removePadding(
      context: context,
      removeTop: true,
      child: Scaffold(
        backgroundColor: Colors.black,
        body: Stack(
          fit: StackFit.expand,
          children: [
            if (controller?.value.isInitialized == true &&
                chewieController != null)
              Chewie(controller: chewieController)
            else if (_loadError != null)
              Center(
                child: Column(
                  mainAxisSize: MainAxisSize.min,
                  children: [
                    const Text('视频加载失败',
                        style: TextStyle(color: Colors.white, fontSize: 18)),
                    const SizedBox(height: 12),
                    FilledButton(
                        onPressed: _loadCurrentVideo, child: const Text('重试')),
                  ],
                ),
              )
            else
              const Center(child: CircularProgressIndicator()),
            SafeArea(
              top: false,
              child: Align(
                alignment: Alignment.topLeft,
                child: Row(
                  children: [
                    IconButton(
                      onPressed: () => Navigator.of(context).pop(),
                      icon: const Icon(Icons.arrow_back_ios_new,
                          color: Colors.white),
                    ),
                    Expanded(
                      child: Text(
                        _currentItem.title,
                        maxLines: 1,
                        overflow: TextOverflow.ellipsis,
                        style:
                            const TextStyle(color: Colors.white, fontSize: 20),
                      ),
                    ),
                  ],
                ),
              ),
            ),
          ],
        ),
      ),
    );
  }
}

class _VideoMaterialControls extends StatelessWidget {
  const _VideoMaterialControls();

  @override
  Widget build(BuildContext context) {
    return Theme(
      data: Theme.of(context).copyWith(
        iconButtonTheme: IconButtonThemeData(
          style: IconButton.styleFrom(
            minimumSize: const Size.square(72),
            padding: const EdgeInsets.all(20),
          ),
        ),
      ),
      child: const MaterialControls(),
    );
  }
}