using System.Collections;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.Video;

/// <summary>
/// 博物馆场景的视频控制器。
///
/// 播放过程：
/// 1. 视频平面初始隐藏，看起来完全透明。
/// 2. 点击播放后，平面从中间向左右展开。
/// 3. 完全展开后，视频才真正开始播放。
///
/// 停止过程：
/// 1. 先暂停视频。
/// 2. 平面像关闭窗帘一样向中间收拢。
/// 3. 完全关闭后停止视频并隐藏平面。
///
/// 这里使用 Transform 的横向缩放实现窗帘效果，
/// 不需要修改 Unlit 材质，也不需要编写自定义 Shader。
/// </summary>
[DisallowMultipleComponent]
public class VideoController : MonoBehaviour
{

    [Header("场景引用")]
    public VideoPlayer videoPlayer;
    public Button controlButton;
    public Sprite playIcon;
    public Sprite pauseIcon;

    [SerializeField, Tooltip("VideoPlayer 对象上的 Mesh Renderer；留空时自动查找。")]
    private Renderer videoScreenRenderer;

    [Header("窗帘动画")]
    [SerializeField, Range(0.1f, 2f), Tooltip("窗帘展开和关闭所需的时间。")]
    private float curtainDuration = 0.6f;

    [Header("手动缩放")]
    [SerializeField, Range(0.5f, 1f)]
    private float minZoom = 0.8f;

    [SerializeField, Range(1f, 2f)]
    private float maxZoom = 1.35f;

    [SerializeField, Range(0.05f, 0.5f)]
    private float zoomStep = 0.1f;

    // VideoPlayer.Prepare 是异步操作，因此需要记录准备状态。
    private bool isPreparing;
    private bool playAfterPrepare;

    private bool isPaused;
    private bool curtainIsOpen;
    private bool curtainIsMoving;

    private Image buttonImage;
    private Transform videoTransform;
    private Vector3 originalVideoScale;
    private float zoom = 1f;

    private Coroutine curtainCoroutine;

    public bool IsPlaying => videoPlayer != null && videoPlayer.isPlaying;
    public float CurrentZoom => zoom;

    private void Awake()
    {
        FindSceneObjects();

        if (videoPlayer == null || controlButton == null || videoScreenRenderer == null)
        {
            Debug.LogError("VideoController：场景引用不完整。", this);
            enabled = false;
            return;
        }

        buttonImage = controlButton.image;
        videoTransform = videoScreenRenderer.transform;
        originalVideoScale = videoTransform.localScale;

        ConfigureVideoPlayer();

        // 初始时关闭并隐藏视频平面。
        SetCurtainImmediately(false);
        SetButtonIcon(false);
    }

    private void OnEnable()
    {
        if (videoPlayer != null)
        {
            videoPlayer.prepareCompleted += OnVideoPrepared;
            videoPlayer.loopPointReached += OnVideoFinished;
            videoPlayer.errorReceived += OnVideoError;
        }

        if (controlButton != null)
        {
            controlButton.onClick.AddListener(TogglePlayPause);
        }
    }

    private void Start()
    {
        // 防止场景中误勾 Play On Awake 后自动播放。
        videoPlayer.Stop();
        SetCurtainImmediately(false);
        SetButtonIcon(false);

        // 提前准备第一帧，点击时可以立即展开窗帘。
        PrepareVideo();
    }

    private void OnDisable()
    {
        if (videoPlayer != null)
        {
            videoPlayer.prepareCompleted -= OnVideoPrepared;
            videoPlayer.loopPointReached -= OnVideoFinished;
            videoPlayer.errorReceived -= OnVideoError;
        }

        if (controlButton != null)
        {
            controlButton.onClick.RemoveListener(TogglePlayPause);
        }
    }

    private void OnApplicationPause(bool paused)
    {
        // 用户摘下头显或应用进入后台时暂停视频。
        if (paused && videoPlayer != null && videoPlayer.isPlaying)
        {
            PauseVideo();
        }
    }

    /// <summary>
    /// 中央按钮入口：播放或等待播放时执行停止，否则开始播放。
    /// </summary>
    public void TogglePlayPause()
    {
        if (videoPlayer.isPlaying || playAfterPrepare || curtainIsMoving)
        {
            StopVideo();
        }
        else
        {
            PlayVideo();
        }
    }

    /// <summary>展开窗帘，完全展开后开始播放。</summary>
    public void PlayVideo()
    {
        // 暂停后继续播放时，窗帘本来就是打开的，不需要重复展开。
        if (isPaused && curtainIsOpen)
        {
            isPaused = false;
            SetButtonIcon(true);
            videoPlayer.Play();
            return;
        }

        if (videoPlayer.isPrepared)
        {
            StartOpeningCurtain();
        }
        else
        {
            playAfterPrepare = true;
            SetButtonIcon(true);
            PrepareVideo();
        }
    }

    /// <summary>暂停视频，但保持窗帘打开。</summary>
    public void PauseVideo()
    {
        playAfterPrepare = false;
        isPaused = true;
        videoPlayer.Pause();
        SetButtonIcon(false);
    }

    /// <summary>暂停视频，关闭窗帘，最后停止并隐藏画面。</summary>
    public void StopVideo()
    {
        playAfterPrepare = false;
        isPreparing = false;
        isPaused = false;

        if (videoPlayer.isPlaying)
        {
            videoPlayer.Pause();
        }

        SetButtonIcon(false);

        // 准备期间取消播放时，画面还没有打开，可以直接停止。
        if (!curtainIsOpen && !curtainIsMoving)
        {
            videoPlayer.Stop();
            SetCurtainImmediately(false);
            return;
        }

        StartCurtainAnimation(false);
    }

    /// <summary>关闭后重新从头播放。</summary>
    public void RestartVideo()
    {
        if (videoPlayer.isPrepared && videoPlayer.canSetTime)
        {
            videoPlayer.time = 0d;
        }

        isPaused = false;
        PlayVideo();
    }

    private void PrepareVideo()
    {
        if (videoPlayer.isPrepared)
        {
            if (playAfterPrepare)
            {
                StartOpeningCurtain();
            }

            return;
        }

        if (!isPreparing)
        {
            isPreparing = true;
            videoPlayer.Prepare();
        }
    }

    private void OnVideoPrepared(VideoPlayer source)
    {
        isPreparing = false;

        if (playAfterPrepare)
        {
            StartOpeningCurtain();
        }
    }

    private void StartOpeningCurtain()
    {
        playAfterPrepare = false;

        // 视频播完后再次播放，需要先回到开头。
        if (!videoPlayer.isLooping &&
            videoPlayer.canSetTime &&
            videoPlayer.length > 0d &&
            videoPlayer.time >= videoPlayer.length - 0.05d)
        {
            videoPlayer.time = 0d;
        }

        SetButtonIcon(true);
        StartCurtainAnimation(true);
    }

    private void OnVideoFinished(VideoPlayer source)
    {
        if (!source.isLooping)
        {
            // 播放结束后自动关上窗帘。
            StopVideo();
        }
    }

    private void OnVideoError(VideoPlayer source, string message)
    {
        isPreparing = false;
        playAfterPrepare = false;
        isPaused = false;
        source.Stop();
        SetCurtainImmediately(false);
        SetButtonIcon(false);
        Debug.LogError("VideoController：视频播放失败：" + message, this);
    }

    #region 手动缩放

    public void ZoomIn()
    {
        SetZoom(zoom + zoomStep);
    }

    public void ZoomOut()
    {
        SetZoom(zoom - zoomStep);
    }

    public void ResetZoom()
    {
        SetZoom(1f);
    }

    public void SetZoom(float newZoom)
    {
        zoom = Mathf.Clamp(newZoom, minZoom, maxZoom);

        // 窗帘关闭时横向宽度必须保持为 0。
        videoTransform.localScale = GetCurtainScale(curtainIsOpen);
    }

    #endregion

    #region 窗帘动画

    private void StartCurtainAnimation(bool open)
    {
        if (curtainCoroutine != null)
        {
            StopCoroutine(curtainCoroutine);
        }

        curtainCoroutine = StartCoroutine(AnimateCurtain(open));
    }

    private IEnumerator AnimateCurtain(bool open)
    {
        curtainIsMoving = true;
        controlButton.interactable = false;

        // 展开前先显示 Renderer；关闭完成后再隐藏。
        if (open)
        {
            videoScreenRenderer.enabled = true;
        }

        Vector3 startScale = videoTransform.localScale;
        Vector3 targetScale = GetCurtainScale(open);
        float elapsed = 0f;

        while (elapsed < curtainDuration)
        {
            elapsed += Time.unscaledDeltaTime;
            float progress = Mathf.Clamp01(elapsed / curtainDuration);

            // SmoothStep 让窗帘起步和停止更加柔和。
            progress = Mathf.SmoothStep(0f, 1f, progress);
            videoTransform.localScale =
                Vector3.Lerp(startScale, targetScale, progress);

            yield return null;
        }

        videoTransform.localScale = targetScale;
        curtainIsOpen = open;
        curtainIsMoving = false;
        curtainCoroutine = null;
        controlButton.interactable = true;

        if (open)
        {
            // 关键点：窗帘完全展开后才开始播放。
            videoPlayer.Play();
        }
        else
        {
            // 完全关闭后停止并隐藏，画面看起来就是透明的。
            videoPlayer.Stop();
            videoScreenRenderer.enabled = false;
        }
    }

    private void SetCurtainImmediately(bool open)
    {
        if (curtainCoroutine != null)
        {
            StopCoroutine(curtainCoroutine);
            curtainCoroutine = null;
        }

        curtainIsOpen = open;
        curtainIsMoving = false;
        videoTransform.localScale = GetCurtainScale(open);
        videoScreenRenderer.enabled = open;

        if (controlButton != null)
        {
            controlButton.interactable = true;
        }
    }

    private Vector3 GetCurtainScale(bool open)
    {
        // 只把 X 轴压缩到 0，因此效果是从中间向左右展开或关闭。
        return new Vector3(
            open ? originalVideoScale.x * zoom : 0f,
            originalVideoScale.y * zoom,
            originalVideoScale.z * zoom);
    }

    #endregion

    #region 初始化

    private void FindSceneObjects()
    {
        // VideoControllerUI 和 VideoPlayer 是两个独立根对象。
        if (videoPlayer == null)
        {
            videoPlayer = FindObjectOfType<VideoPlayer>();
        }

        if (controlButton == null)
        {
            controlButton = GetComponentInChildren<Button>(true);
        }

        if (videoScreenRenderer == null && videoPlayer != null)
        {
            videoScreenRenderer = videoPlayer.targetMaterialRenderer;

            if (videoScreenRenderer == null)
            {
                videoScreenRenderer = videoPlayer.GetComponent<Renderer>();
            }
        }
    }

    private void ConfigureVideoPlayer()
    {
        videoPlayer.playOnAwake = false;
        videoPlayer.waitForFirstFrame = true;
        videoPlayer.skipOnDrop = true;

        // 把视频写入 Unlit 材质的主贴图。
        if (videoPlayer.renderMode == VideoRenderMode.MaterialOverride)
        {
            videoPlayer.targetMaterialRenderer = videoScreenRenderer;

            Material material = videoScreenRenderer.sharedMaterial;
            videoPlayer.targetMaterialProperty =
                material != null && material.HasProperty("_BaseMap")
                    ? "_BaseMap"
                    : "_MainTex";
        }
    }

    private void SetButtonIcon(bool playing)
    {
        if (buttonImage == null)
        {
            return;
        }

        Sprite icon = playing ? pauseIcon : playIcon;

        if (icon != null)
        {
            buttonImage.sprite = icon;
        }
    }

    #endregion
}

请直接完成 Unity 项目中的 Assets/_Scripts/VideoController.cs。

当前状态：
- 这是一个刚创建的 C# 脚本，可以删除默认模板后完整重写。
- 项目使用 Unity 2022.3、通用渲染管线和 UnityEngine.Video。
- 场景中已经存在 VideoPlayer、显示视频的 Quad、VideoControllerUI、控制按钮、播放图标和暂停图标。
- VideoPlayer 使用 Material Override，把视频输出到 Quad 的 Unlit 材质。

任务目标：
编写一个可直接挂到 VideoControllerUI 上的 VideoController 组件。单个按钮负责播放和停止；播放前让视频 Quad 从中间向左右展开，完全展开后才播放；停止时先暂停当前画面，再把 Quad 向中间收拢，完全关闭后停止并隐藏。

文件与依赖约束：
1. 文件名必须是 VideoController.cs，类名必须是 VideoController，并继承 MonoBehaviour。
2. 只修改这个文件，不创建其他脚本，不修改场景，不安装或调用第三方动画插件。
3. 使用 Unity 协程、Time.unscaledDeltaTime、Mathf.SmoothStep 和 Vector3.Lerp 完成动画。
4. 不编写自定义 Shader，不使用 Update 轮询。
5. 引入 System.Collections、UnityEngine、UnityEngine.UI 和 UnityEngine.Video。
6. 为类添加 DisallowMultipleComponent。

必须提供的场景引用与参数：
- public VideoPlayer videoPlayer
- public Button controlButton
- public Sprite playIcon
- public Sprite pauseIcon
- 可序列化私有 Renderer videoScreenRenderer；未指定时自动寻找
- curtainDuration，默认 0.6，范围 0.1 到 2
- minZoom，默认 0.8，范围 0.5 到 1
- maxZoom，默认 1.35，范围 1 到 2
- zoomStep，默认 0.1，范围 0.05 到 0.5

必须维护的状态：
- isPreparing：是否正在异步准备视频
- playAfterPrepare：准备完成后是否仍然需要播放
- isPaused：是否保留当前位置等待继续
- curtainIsOpen：幕布是否完全展开
- curtainIsMoving：幕布是否正在运动
- 缓存 Button 的 Image、视频 Transform、原始 localScale、当前 zoom 和正在运行的 Coroutine
- 提供只读属性 IsPlaying 和 CurrentZoom

生命周期与事件要求：
1. Awake 中自动补全引用；引用不完整时输出清楚的错误并禁用组件。
2. Awake 中缓存组件与原始缩放，配置播放器，关闭并隐藏初始幕布，显示播放图标。
3. OnEnable 中监听 prepareCompleted、loopPointReached、errorReceived 和按钮 onClick。
4. OnDisable 中移除完全相同的事件与按钮监听，避免重复响应。
5. Start 中停止误开启的自动播放、恢复关闭状态，并提前调用 Prepare 准备第一帧。
6. 应用进入后台或使用者摘下头显时，如果视频正在播放，就暂停视频。

必须实现的公开方法：
- TogglePlayPause()
- PlayVideo()
- PauseVideo()
- StopVideo()
- RestartVideo()
- ZoomIn()
- ZoomOut()
- ResetZoom()
- SetZoom(float newZoom)

播放控制要求：
1. 第一次点击时，如果视频尚未准备好，记录播放意图并调用 Prepare；准备完成事件到达后再次读取最新意图。
2. 准备期间再次点击停止时，必须清除播放意图，不能在稍后突然播放。
3. 暂停后继续播放时保留当前位置；完全停止后再次播放时从头开始。
4. 非循环视频播放到结尾后自动关闭幕布。
5. 播放失败时清理准备、播放和暂停状态，停止播放器，关闭并隐藏幕布，恢复播放图标，并输出包含错误信息的日志。

幕布动画要求：
1. 只改变 Quad 的 localScale.x；y 和 z 保持原始比例并乘以当前 zoom。
2. 展开前先启用 Renderer，完全展开后才调用 videoPlayer.Play()。
3. 关闭前先暂停视频；完全关闭后调用 Stop() 并禁用 Renderer。
4. 动画期间禁用控制按钮，完成后恢复。
5. 新动画开始前停止尚未结束的旧协程，避免两个协程同时修改缩放。
6. 提供立即打开或关闭幕布的方法，用于初始化和错误恢复。
7. 必须先保存 Quad 的原始缩放，再把横向缩放设为 0。

自动配置要求：
1. videoPlayer 未指定时，在场景中寻找 VideoPlayer。
2. controlButton 未指定时，在当前对象及子对象中寻找 Button，包括未激活对象。
3. videoScreenRenderer 未指定时，优先使用 targetMaterialRenderer，再尝试 VideoPlayer 同对象上的 Renderer。
4. 关闭 playOnAwake，开启 waitForFirstFrame 和 skipOnDrop。
5. Material Override 模式下指定目标 Renderer；材质具有 _BaseMap 时使用 _BaseMap，否则使用 _MainTex。
6. 根据播放状态把按钮图标切换为 pauseIcon 或 playIcon；图标为空时不能报错。

代码质量要求：
- 输出完整、可编译的 VideoController.cs，不能只给方法片段或伪代码。
- 所有大括号、事件签名、协程返回类型和命名空间必须完整。
- 对异步准备、最新播放意图、动画开始与结束、错误恢复等关键位置添加简洁中文注释。
- 不保留空的 Update 方法。

请直接把完整实现写入 Assets/_Scripts/VideoController.cs。完成后只需简要说明已经实现的功能，并提醒我返回 Unity 查看 Console 是否成功编译。