/*----------------------------------------------------------------
// Copyright (C) 2025 Beijing All rights reserved.
//
// Author: huachangmiao
// Create Date: 2025/04/11
// Module Describe: 视频解码器抽象基类
//----------------------------------------------------------------*/

using System.Threading;
using UnityEngine;
using Unity.Collections;
#if UNITY_WEBGL && !UNITY_EDITOR
using System.Runtime.InteropServices;
#endif

/// <summary>
/// 视频解码器抽象基类
/// 包含解码逻辑、播放控制、多线程解码等公共功能
/// 子类需要实现具体的渲染逻辑
/// </summary>
public abstract unsafe class LeviathanVideoDecoderBase : MonoBehaviour
{
    protected static readonly int ValidWidthRatioIdx = Shader.PropertyToID("_ValidWidthRatio");
    protected static readonly int UTexIdx = Shader.PropertyToID("_UTex");
    protected static readonly int VTexIdx = Shader.PropertyToID("_VTex");
    protected static readonly int AlphaYTexIdx = Shader.PropertyToID("_AYTex");
    protected static readonly int AlphaUTexIdx = Shader.PropertyToID("_AUTex");

#if UNITY_WEBGL && !UNITY_EDITOR
    [DllImport("__Internal")]
    private static extern bool IsWechatMiniGameEnvironment();
#endif

    // 日志辅助方法
    protected static void Log(string message)
    {
        LeviathanLogConfig.Log("VideoDecoderBase", message);
    }

    protected static void LogWarning(string message)
    {
        LeviathanLogConfig.LogWarning("VideoDecoderBase", message);
    }

    protected static void LogError(string message)
    {
        LeviathanLogConfig.LogError("VideoDecoderBase", message);
    }

    /// <summary>
    /// 静态构造函数 - 在类首次使用时执行平台检测
    /// </summary>
    static LeviathanVideoDecoderBase()
    {
#if UNITY_WEBGL && !UNITY_EDITOR
        try
        {
            IsWCGame = IsWechatMiniGameEnvironment();
            Log($"微信小游戏平台静态检测: {IsWCGame}");
        }
        catch (System.Exception e)
        {
            LogError($"微信小游戏平台静态检测异常: {e}");
            IsWCGame = false;
        }
#else
        IsWCGame = false;
#endif
    }

    // [LabelText("视频文件(.bytes)")]
    public TextAsset bytesFile;

#if UNITY_EDITOR
    [System.NonSerialized]
    protected TextAsset _lastBytesFile;
#endif

    private ILeviathanDecoder _decoder;
    
    /// <summary>
    /// 获取当前视频帧指针（子类使用）
    /// </summary>
    protected LeviathanVideo.Abstractions.AVFrame* VideoFrame => _decoder != null ? _decoder.VideoFrame : null;

#if !UNITY_2022_1_OR_NEWER
    // Unity 2020/2021 兼容：保存数据副本以供解码器使用
    protected NativeArray<byte> _videoDataBuffer;
    protected bool _hasVideoDataBuffer = false;
#endif

    // 平台检测
    public static bool IsWCGame = false;

    protected const int TextureCount = 3;
    protected Texture2D[] _textures;
    protected double _timeAccumulated;
    protected double _frameInterval;
    public double FrameInterval => _frameInterval;
    protected bool _needInitTexture = true;

    protected bool _needApplyTexture = false;

    // 是否为多线程解码
    protected bool _isMultithreadedDecode;
    // 多线程相关
    protected Thread _decodeThread;
    // 帧状态：0=允许解码下一帧, 1=帧已准备好等待显示
    protected long _hasFrameReady;

    protected volatile bool _isPlaying;
    public bool IsPlaying => _isPlaying;

    protected bool _isPause;
    public bool IsPause => _isPause;

    // 销毁状态标志（防止销毁期间的异步操作继续执行）
    protected bool _isDestroying = false;

    // 第一帧回调待执行标志（用于从子线程安全地在主线程执行回调）
    protected volatile bool _pendingFirstFrameCallback = false;

    // ==区间循环专用

    // 每次播放到End, 跳转到的frame
    protected long _loopBeginFrameIndex = -1;
    public long LoopBeginFrameIndex => _loopBeginFrameIndex;

    protected long _loopEndFrameIndex = -1;
    public long LoopEndFrameIndex => _loopEndFrameIndex;

    // 是否正在循环seek中（防止SeekToFrame被多次调用）
    protected volatile bool _isLoopSeeking = false;

    protected string _codecName = "";

    // 总时长 微秒
    protected long _duration;
    public long Duration => _duration;

    protected int _videoWidth;
    public int VideoWidth => _videoWidth;

    protected int _videoHeight;
    public int VideoHeight => _videoHeight;

    protected int _videoValidWidth;
    public int VideoValidWidth => _videoValidWidth;

    public long PlayFrameIndex => _playFrameIndex;
    protected long _playFrameIndex;

    // 总帧数
    protected long _frameCount;
    public long FrameCount => _frameCount;

    protected float _playSpeed = 1.0f;

    public enum PlayAlphaType
    {
        None = 0,
        RightSide = 1,
        BottomSide = 2,
        ChromaKey = 3,
    }

    public PlayAlphaType AlphaType
    {
        get => _alphaType;
        set
        {
            if (_alphaType != value)
            {
                SetAlphaType(value);
            }
        }
    }

    [SerializeField]
    protected bool disableAutoSize;
    [SerializeField]
    protected bool autoPlayOnStart;

    public bool DisableAutoSize
    {
        get => disableAutoSize;
        set => disableAutoSize = value;
    }

    [SerializeField]
    protected bool _isLooping = true;

    public bool IsLooping => _isLooping;

    /// <summary>
    /// 播放完成回调事件（非循环播放时触发）
    /// </summary>
    public System.Action OnPlayCompleted;

    /// <summary>
    /// 首帧渲染完毕回调事件
    /// 无论同步或异步解码首帧模式都会触发
    /// </summary>
    public System.Action OnFirstFrameRendered;

    [SerializeField]
    protected PlayAlphaType _alphaType = PlayAlphaType.None;

    // 上次应用的alphaType，用于检测是否需要更新材质
    protected PlayAlphaType _lastAppliedAlphaType = PlayAlphaType.None;

    protected virtual void Start()
    {
        if (autoPlayOnStart && bytesFile)
            Play();
    }

    /// <summary>
    /// 第一帧解码完成回调（由解码器触发，可能在子线程中调用）
    /// 设置标志位，实际处理在主线程的 Update 中执行
    /// </summary>
    protected virtual void OnFirstFrameDecodedCallback()
    {
        _pendingFirstFrameCallback = true;
    }

    /// <summary>
    /// 处理第一帧解码完成的实际逻辑（必须在主线程调用）
    /// 子类需要重写此方法来处理渲染目标的显示
    /// </summary>
    protected virtual void HandleFirstFrameDecoded()
    {
        // 先更新纹理，确保显示的是新视频的第一帧
        DisplayFrame();
        
        // 子类负责启用渲染目标
        OnEnableRenderTarget();
        
        // 触发首帧渲染完毕回调
        OnFirstFrameRendered?.Invoke();
    }

    /// <summary>
    /// 启用渲染目标（子类实现）
    /// </summary>
    protected abstract void OnEnableRenderTarget();

    /// <summary>
    /// 禁用渲染目标（子类实现）
    /// </summary>
    protected abstract void OnDisableRenderTarget();

    protected virtual void OnDestroy()
    {
        Log("开始销毁，清理所有资源");

        // 立即设置销毁标志，阻止任何新的操作
        _isDestroying = true;

        _isPlaying = false;

        // 强制同步停止，避免异步操作
        try
        {
            InternalStopSync();
        }
        catch (System.Exception e)
        {
            LogWarning($"同步停止时出现异常: {e.Message}");
        }

        // Release textures
        if (_textures != null && _textures.Length > 0)
        {
            foreach (var tex in _textures)
            {
                if (tex) Destroy(tex);
            }
        }
        _textures = null;
    }

    /// <summary>
    /// 播放视频
    /// </summary>
    /// <param name="fileData">视频文件</param>
    /// <param name="playAlpha">播放透明度</param>
    /// <param name="multithreadedDecode">是否多线程解码</param>
    /// <param name="beginFrameIndex">开始播放的帧索引</param>
    /// <param name="syncDecodeFirstFrame">是否同步解码第一帧, 区别在于是否当前帧就能立马看到视频, 会耗时10ms</param>
    /// <param name="fastDecode">是否启用快速解码（跳过环路滤波器），默认开启以提升性能</param>
    /// <returns>返回值: 0表示成功, 其他表示错误码</returns>
    public int PlayVideo(TextAsset fileData, PlayAlphaType playAlpha, bool multithreadedDecode, int beginFrameIndex = 1, bool syncDecodeFirstFrame = true, bool fastDecode = true)
    {
        // 如果正在销毁，立即返回
        if (_isDestroying)
        {
            LogWarning("PlayVideo: 组件正在销毁，取消播放");
            return -1;
        }

        if (fileData == null)
        {
            return -1;
        }
        var ret = 0;
        if (_isPlaying) return ret;
        
        _playFrameIndex = 0;
        _timeAccumulated = 0;
        _isLoopSeeking = false;
        
        _alphaType = playAlpha;

#if UNITY_WEBGL
        // webGL不支持c#多线程
        _isMultithreadedDecode = false;
#else
        _isMultithreadedDecode = multithreadedDecode;
#endif

        // 根据平台选择解码器
        if (IsWCGame)
        {
            OnDisableRenderTarget();
            // 创建新的decoder - 使用Worker版本
            var workerDecoder = new LeviathanWorkerDecoder();
            workerDecoder.IsLooping = _isLooping; // 设置循环播放状态
            _decoder = workerDecoder;
            Log($"[PlayWithData] 创建新的微信小游戏Worker解码器 (静态检测: {IsWCGame}, 循环播放: {_isLooping})");
        }
        else
        {
            // 只有同步解码第一帧时才立即启用，否则等待第一帧解码完成后再启用
            if (syncDecodeFirstFrame)
            {
                OnEnableRenderTarget();
            }
            else
            {
                OnDisableRenderTarget();
            }
            _decoder = new LeviathanSoftwareDecoder();
            Log($"[PlayWithData] 使用软件解码器 (静态检测: {IsWCGame})");
        }
        _needInitTexture = true;

        // 订阅第一帧回调事件
        _decoder.OnFirstFrameDecoded += OnFirstFrameDecodedCallback;

        // 初始化解码器
        bytesFile = fileData;
#if UNITY_EDITOR
        _lastBytesFile = bytesFile;
#endif
#if UNITY_2022_1_OR_NEWER
        ret = _decoder.Init(fileData.GetData<byte>(), beginFrameIndex, syncDecodeFirstFrame, fastDecode);
#else
        // Unity 2020/2021: 创建持久的数据副本供解码器使用
        if (_hasVideoDataBuffer)
        {
            _videoDataBuffer.Dispose();
        }
        _videoDataBuffer = new NativeArray<byte>(fileData.bytes, Allocator.Persistent);
        _hasVideoDataBuffer = true;
        ret = _decoder.Init(_videoDataBuffer, beginFrameIndex, syncDecodeFirstFrame, fastDecode);
#endif

        _frameCount = _decoder.FrameCount;
        _loopBeginFrameIndex = beginFrameIndex;
        _loopEndFrameIndex = _frameCount;
        _duration = _decoder.Duration;
        _frameInterval = _decoder.FrameInterval;
        _codecName = _decoder.CodecName;

        if (ret != 0)
        {
            LogError($"DecodeNextFrame ret: {ret}");
        }

        OnUpdateRenderTargetSize();

        // 只有同步解码第一帧时才立即显示，否则等待第一帧解码完成后在 HandleFirstFrameDecoded 中显示
        if (syncDecodeFirstFrame)
        {
            DisplayFrame();
            // 同步模式下立即触发首帧渲染完毕回调
            OnFirstFrameRendered?.Invoke();
        }

        if (_isMultithreadedDecode)
        {
            // 多线程模式
            Interlocked.Exchange(ref _hasFrameReady, 1); // 第一帧已准备好
            _isPlaying = true;
            _isPause = false;
            _decodeThread = new Thread(DecodeThreadFunction);
#if UNITY_EDITOR
            _decodeThread.Name = $"{nameof(LeviathanVideoDecoderBase)}.{nameof(DecodeThreadFunction)}";
#endif
            _decodeThread.Start();
        }
        else
        {
            // 单线程模式
            _isPlaying = true;
            _isPause = false;
        }
        return ret;
    }

    /// <summary>
    /// 更新渲染目标尺寸（子类实现）
    /// </summary>
    protected abstract void OnUpdateRenderTargetSize();

    protected void InternalStop()
    {
        if (!_isPlaying) return;

        // 立即设置状态，防止重复调用
        _isPlaying = false;

        // 其他平台的同步停止逻辑
        InternalStopSync();
    }

    // 同步停止方法（非微信平台）
    protected void InternalStopSync()
    {
        // 重置第一帧回调标志，避免旧视频的回调影响新视频
        _pendingFirstFrameCallback = false;
        _needApplyTexture = false;
        _isPause = false;

        if (_isMultithreadedDecode)
        {
            if (_decodeThread != null && _decodeThread.IsAlive)
            {
                _decodeThread.Join(1000); // 添加超时避免死锁
                if (_decodeThread.IsAlive)
                {
                    // 强制终止线程
                    _decodeThread.Abort();
                }
            }
            _decodeThread = null;
        }

        // 其他平台正常销毁decoder
        if (_decoder != null)
        {
            _decoder.OnFirstFrameDecoded -= OnFirstFrameDecodedCallback;
            _decoder.InternalStop();
            _decoder.Dispose();
            _decoder = null;
        }

#if !UNITY_2022_1_OR_NEWER
        // Unity 2020/2021: 释放数据缓冲区
        if (_hasVideoDataBuffer)
        {
            _videoDataBuffer.Dispose();
            _hasVideoDataBuffer = false;
        }
#endif

        OnDisableRenderTarget();
    }

    // 主线程
    protected virtual void Update()
    {
        // 如果正在销毁，立即返回
        if (_isDestroying) return;

        // 处理第一帧回调（从子线程安全地在主线程执行）
        if (_pendingFirstFrameCallback)
        {
            _pendingFirstFrameCallback = false;
            HandleFirstFrameDecoded();
        }

        if (_isPause) return;
        if (!_isPlaying) return;

#if UNITY_WEBGL && !UNITY_EDITOR
        _timeAccumulated += 1.0 / Application.targetFrameRate * _playSpeed;
#else
        _timeAccumulated += Time.deltaTime * _playSpeed;
#endif
        if (_isMultithreadedDecode)
        {
            // 多线程模式
            if (_timeAccumulated >= _frameInterval)
            {
                // 检查是否有新帧准备好
                if (Interlocked.Read(ref _hasFrameReady) > 0)
                {
                    // 复制帧数据到纹理（不立即Apply）
                    DisplayFrame(applyImmediately: false);
                    
                    _timeAccumulated -= _frameInterval;
                    
                    // DisplayFrame 完成后，通知解码线程可以解码下一帧
                    Interlocked.Exchange(ref _hasFrameReady, 0);
                }
                
                if (_timeAccumulated > _frameInterval * 3)
                {
                    _timeAccumulated = _frameInterval;
                }
            }
        }
        else
        {
            // 单线程模式
            if (IsWCGame)
            {
                // Worker解码器：每次Update解码一帧
                if (_decoder.DecodeNextFrame() == 0)
                {
                    DisplayFrame(applyImmediately: false);
                }
            }
            else
            {
                // 每次Update最多解码一帧，不追帧
                if (_timeAccumulated >= _frameInterval)
                {
                    if (_decoder.DecodeNextFrame() == 0)
                    {
                        _timeAccumulated -= _frameInterval;

                        long currentFrame = _decoder.DecodedFrameIndex;
                        if (currentFrame >= _loopEndFrameIndex)
                        {
                            if (_isLooping)
                            {
                                SeekToFrame(_loopBeginFrameIndex);
                            }
                        }
                        
                        DisplayFrame(applyImmediately: false);
                    }
                    
                    if (_timeAccumulated > _frameInterval * 3)
                    {
                        _timeAccumulated = _frameInterval;
                    }
                }
            }
            if (_playFrameIndex >= _loopEndFrameIndex && !_isLooping)
            {
                Pause();
                OnPlayCompleted?.Invoke();
            }
        }
    }

    protected virtual void LateUpdate()
    {
        if (_needApplyTexture) {
            _needApplyTexture = false;
            if (_decoder != null && _textures != null)
            {
                DisplayFrameApply();
            }
        }
    }


    // 解码线程（仅多线程模式）
    protected void DecodeThreadFunction()
    {
        try
        {
            while (_isPlaying)
            {
                if (!_isPause)
                {
                    // 等待主线程显示完当前帧（_hasFrameReady == 0 表示允许解码下一帧）
                    while (Interlocked.Read(ref _hasFrameReady) != 0 && _isPlaying)
                    {
                        Thread.Sleep(1);
                    }
                    if (!_isPlaying) break;
                    
                    // 解码下一帧
                    if (_decoder.DecodeNextFrame() == 0)
                    {
                        // 解码成功，通知主线程帧已准备好
                        Interlocked.Exchange(ref _hasFrameReady, 1);
                    }
                    
                    if (_playFrameIndex >= _loopEndFrameIndex && !_isLoopSeeking)
                    {
                        if (_isLooping)
                        {
                            _isLoopSeeking = true;
                            SeekToFrame(_loopBeginFrameIndex);
                            // Seek后继续解码，_hasFrameReady 保持为 1，等待主线程显示
                        }
                        else
                        {
                            _isPause = true;
                            Interlocked.Exchange(ref _hasFrameReady, 1);
                            // 触发播放完成回调
                            OnPlayCompleted?.Invoke();
                        }
                    }
                }
                else
                {
                    Thread.Sleep(5);
                }
            }
        }
        catch (ThreadAbortException)
        {
            Thread.ResetAbort();
        }
    }

    // 初始化纹理
    protected virtual void InitTextures()
    {
        if (_textures != null && _textures.Length > 0)
        {
            Destroy(_textures[0]);
            Destroy(_textures[1]);
            Destroy(_textures[2]);
        }
        var videoFrame = _decoder.VideoFrame;
        // 软件解码器使用YUV格式
        _textures = new Texture2D[TextureCount];
        _textures[0] = new Texture2D(videoFrame->linesize[0], videoFrame->height, TextureFormat.Alpha8, false);
        _textures[1] = new Texture2D(videoFrame->linesize[1], videoFrame->height / 2, TextureFormat.Alpha8, false);
        _textures[2] = new Texture2D(videoFrame->linesize[2], videoFrame->height / 2, TextureFormat.Alpha8, false);
        _textures[0].wrapMode = TextureWrapMode.Clamp;
        _textures[1].wrapMode = TextureWrapMode.Clamp;
        _textures[2].wrapMode = TextureWrapMode.Clamp;

        _videoValidWidth = videoFrame->width;
        _videoWidth = videoFrame->linesize[0];
        _videoHeight = videoFrame->height;

        OnInitMaterial();
        OnUpdateRenderTargetSize();
    }

    /// <summary>
    /// 初始化材质（子类实现）
    /// </summary>
    protected abstract void OnInitMaterial();

    /// <summary>
    /// 更新纹理
    /// </summary>
    /// <param name="applyImmediately">是否立即Apply上传到GPU。false时只复制数据，可以稍后调用DisplayFrameApply</param>
    protected virtual void DisplayFrame(bool applyImmediately = true)
    {
        var videoFrame = _decoder.VideoFrame;
        if (videoFrame->linesize[0] <= 0) return;

        // 检查纹理是否需要重新创建
        if (_textures == null || _textures[0].width != videoFrame->linesize[0] || _textures[0].height != videoFrame->height)
        {
            InitTextures();
            _lastAppliedAlphaType = _alphaType;
            _needInitTexture = false;
            
            if (_decoder is LeviathanWorkerDecoder workerDecoder)
            {
                workerDecoder.SetTextureIds(_textures);
            }
        }
        else if (_needInitTexture)
        {
            // 只在alphaType变化时才更新材质
            if (_alphaType != _lastAppliedAlphaType)
            {
                OnInitMaterial();
                _lastAppliedAlphaType = _alphaType;
            }
            // 如果是Worker版本，将纹理ID传递给JSLIB
            if (_decoder is LeviathanWorkerDecoder workerDecoder)
            {
                workerDecoder.SetTextureIds(_textures);
            }
            _needInitTexture = false;
        }

        // 复制帧数据到纹理（需要保护_videoFrame）
        _decoder.CopyFrameDataToTextures(_textures);

        // 根据参数决定是否立即Apply
        if (applyImmediately)
        {
            _decoder.ApplyTextures(_textures);
            _needApplyTexture = false;  // 立即Apply后，清除延迟标志
        }
        else
        {
            _needApplyTexture = true;   // 延迟Apply，设置标志在LateUpdate中执行
        }

        // 更新播放帧索引
        if (_isMultithreadedDecode)
        {
            _playFrameIndex = Interlocked.Read(ref _decoder.GetDecodedFrameIndexRef());
        }
        else
        {
            _playFrameIndex = _decoder.DecodedFrameIndex;
        }

        // 重置循环seek标志
        _isLoopSeeking = false;
    }
    
    /// <summary>
    /// 将纹理数据上传到GPU（可与下一帧解码并行）
    /// 配合 DisplayFrame(false) 使用，实现分步显示优化
    /// </summary>
    protected virtual void DisplayFrameApply()
    {
        _decoder.ApplyTextures(_textures);
    }

    // 跳转到指定时间点
    public void Seek(double ms)
    {
        _decoder.Seek(ms);
    }

    // 跳转到指定帧
    public void SeekToFrame(long frame)
    {
        _decoder.SeekToFrame(frame);
    }

    public void SetPlaySpeed(float speed)
    {
        _playSpeed = speed;
    }

    public virtual void SetAlphaType(PlayAlphaType alphaTypeValue)
    {
        _alphaType = alphaTypeValue;
        if (_textures == null || _textures.Length <= 0) return;
        OnUpdateMaterial();
        _lastAppliedAlphaType = _alphaType;
        OnUpdateRenderTargetSize();
    }

    /// <summary>
    /// 更新材质（子类实现）
    /// </summary>
    protected abstract void OnUpdateMaterial();

    public void SetLooping(bool isLooping)
    {
        _isLooping = isLooping;

        // 如果是微信小游戏平台，设置解码器的循环播放状态
        if (IsWCGame)
        {
            _decoder.IsLooping = isLooping;
        }

        if (_isLooping && _isPause)
        {
            Resume();
        }
    }

    /// <summary>
    /// 设置循环播放区间, 帧数范围为 1 ~ FrameCount
    /// </summary>
    /// <param name="beginFrame">开始帧索引</param>
    /// <param name="endFrame">结束帧索引</param>
    public void SetLoopingFrame(long beginFrame, long endFrame)
    {
        _loopBeginFrameIndex = beginFrame;
        _loopEndFrameIndex = endFrame;
    }

    /// <summary>
    /// 切换视频
    /// </summary>
    /// <param name="fileData">视频文件</param>
    /// <param name="playAlpha">播放透明度</param>
    /// <param name="multithreadedDecode">是否多线程解码</param>
    /// <param name="beginFrameIndex">开始播放的帧索引</param>
    /// <param name="syncDecodeFirstFrame">是否同步解码第一帧, 区别在于是否当前帧就能立马看到视频, 会耗时10ms</param>
    /// <param name="fastDecode">是否启用快速解码（跳过环路滤波器），默认开启以提升性能</param>
    /// <returns>返回值: true表示成功, false表示失败</returns>
    public bool ChangeVideo(TextAsset fileData, PlayAlphaType playAlpha, bool multithreadedDecode, int beginFrameIndex = 1, bool syncDecodeFirstFrame = true, bool fastDecode = true)
    {
        // 如果不同步解码第一帧，先隐藏渲染目标避免显示旧帧
        if (!syncDecodeFirstFrame)
        {
            OnDisableRenderTarget();
        }
        return ChangeVideoSync(fileData, playAlpha, multithreadedDecode, beginFrameIndex, syncDecodeFirstFrame, fastDecode);
    }

    protected bool ChangeVideoSync(TextAsset fileData, PlayAlphaType playAlpha, bool multithreadedDecode, int beginFrameIndex = 1, bool syncDecodeFirstFrame = true, bool fastDecode = true)
    {
        Log("开始同步切换视频");

        try
        {
            // 同步停止当前视频
            StopVideoSync();

            // 同步播放新视频
            int result = PlayVideoSync(fileData, playAlpha, multithreadedDecode, beginFrameIndex, syncDecodeFirstFrame, fastDecode);

            if (result != 0)
            {
                LogError($"同步播放视频失败，错误码: {result}");
                return false;
            }

            Log("同步切换视频完成");
            return true;
        }
        catch (System.Exception e)
        {
            LogError($"同步切换视频异常: {e.Message}");
            return false;
        }
    }

    protected void StopVideoSync()
    {
        // 立即禁用渲染目标显示，避免显示旧帧
        OnDisableRenderTarget();

        if (_isPlaying)
        {
            if (_isPlaying)
            {
                InternalStop();
            }

            // 同步等待停止操作完成
            int maxWaitCount = 1000; // 最多等待1000次循环
            int waitCount = 0;

            while ((_isPlaying) && waitCount < maxWaitCount)
            {
                // 在同步模式下，我们不能使用yield，所以使用Thread.Sleep进行短暂等待
                Thread.Sleep(1);
                waitCount++;
            }

            if (waitCount >= maxWaitCount)
            {
                LogWarning("同步停止视频超时，继续执行后续操作");
            }
            else
            {
                Log($"视频同步停止完成，等待了 {waitCount} 次循环");
            }
        }
    }

    protected int PlayVideoSync(TextAsset fileData, PlayAlphaType playAlpha, bool multithreadedDecode, int beginFrameIndex = 1, bool syncDecodeFirstFrame = true, bool fastDecode = true)
    {
        // 播放新视频
        int result;
        if (fileData != null)
        {
            // 使用文件数据播放
            result = PlayVideo(fileData, playAlpha, multithreadedDecode, beginFrameIndex, syncDecodeFirstFrame, fastDecode);
            Log($"同步切换到视频资源: {fileData.name}");
        }
        else
        {
            LogError("没有提供有效的视频源");
            return -1;
        }

        if (result != 0)
        {
            LogError($"同步播放视频失败，错误码: {result}");
            return result;
        }

        return result;
    }

    internal void Play()
    {
        if (!Application.isPlaying) return;
        if (bytesFile == null) return;
        PlayVideo(bytesFile, _alphaType, true);
    }

    public void Stop()
    {
        if (!Application.isPlaying) return;
        InternalStop();
    }

    public void Pause()
    {
        if (!Application.isPlaying) return;
        _isPause = true;

        // 调用解码器的暂停方法
        _decoder?.Pause(true);
    }

    public void Resume()
    {
        if (!Application.isPlaying) return;
        _isPause = false;

        // 调用解码器的恢复方法
        _decoder?.Pause(false);
    }
}