#if ULOOPMCP_HAS_INPUT_SYSTEM
#nullable enable
using System;
using System.Collections.Generic;
using System.Globalization;
using UnityEditor;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.InputSystem.LowLevel;
using UnityEngine.InputSystem.UI;

namespace io.github.hatayama.uLoopMCP
{
    [InitializeOnLoad]
    internal static class InputReplayer
    {
        private static readonly Dictionary<string, Key> _keyLookup = BuildKeyLookup();
        private static readonly Key[] _allKeys = BuildAllKeys();
        private static readonly Dictionary<string, MouseButton> _buttonLookup = new(StringComparer.OrdinalIgnoreCase)
        {
            { "Left", MouseButton.Left },
            { "Right", MouseButton.Right },
            { "Middle", MouseButton.Middle }
        };
        private static readonly Key[] _emptyKeys = Array.Empty<Key>();
        private static readonly MouseButton[] _emptyButtons = Array.Empty<MouseButton>();

        private static bool _isReplaying;
        private static InputRecordingData? _data;
        private static int _eventIndex;
        private static int _currentFrame;
        private static bool _loop;
        private static bool _showOverlay;
        private static readonly HashSet<Key> _replayHeldKeys = new();
        private static readonly HashSet<MouseButton> _replayHeldButtons = new();
        private static Vector2? _replayMousePosition;

        // Some UI modules do not consume injected Mouse.current state, so replay keeps
        // manual ExecuteEvents support for those modules.
        private static bool _hasMousePosition;
        private static bool _prevLeftButtonHeld;
        private static Vector2? _previousReplayMousePosition;
        private static bool _suppressIdleUiOverlay;
        private static PointerEventData? _pointerData;
        private static GameObject? _currentPressTarget;
        private static GameObject? _currentDragTarget;
        private static bool _isDragging;
        private static Vector2 _pressScreenPosition;
        private static float _pressTime;
        private static bool _delayCompletionForUiModule;
        private static bool _hasActivePressDispatchMode;
        private static bool _activePressDispatchesUiEventsManually;

        public static event Action? ReplayStarted;
        public static event Action? ReplayCompleted;

        public static bool IsReplaying => _isReplaying;
        public static int CurrentFrame => _currentFrame;
        public static int TotalFrames => _data?.Metadata.TotalFrames ?? 0;

        public static float Progress
        {
            get
            {
                int total = TotalFrames;
                return total > 0 ? (float)_currentFrame / total : 0f;
            }
        }

        static InputReplayer()
        {
            EditorApplication.playModeStateChanged -= OnPlayModeStateChanged;
            EditorApplication.playModeStateChanged += OnPlayModeStateChanged;
        }

        public static void StartReplay(InputRecordingData data, bool loop, bool showOverlay)
        {
            Debug.Assert(!_isReplaying, "Cannot start replay while already replaying");
            Debug.Assert(EditorApplication.isPlaying, "PlayMode must be active to start replay");
            Debug.Assert(data != null, "Recording data must not be null");

            _data = data;
            _eventIndex = 0;
            _currentFrame = 0;
            _loop = loop;
            _showOverlay = showOverlay;
            _replayHeldKeys.Clear();
            _replayHeldButtons.Clear();
            _hasMousePosition = DetectMousePositionEvents(data!);
            ResetUiReplayState();
            EnsureOverlayForReplay(showOverlay);
            ClearOverlayState();
            _isReplaying = true;

            InputSystem.onAfterUpdate -= OnAfterUpdate;
            InputSystem.onAfterUpdate += OnAfterUpdate;

            ReplayStarted?.Invoke();
        }

        public static void StopReplay()
        {
            if (!_isReplaying)
            {
                return;
            }

            InputSystem.onAfterUpdate -= OnAfterUpdate;
            _isReplaying = false;

            ReleaseAllHeldInputs();

            _data = null;
            _eventIndex = 0;
            _currentFrame = 0;
            _replayHeldKeys.Clear();
            _replayHeldButtons.Clear();
            ResetUiReplayState();

            ClearOverlayState();
        }

        private static void OnAfterUpdate()
        {
            if (!_isReplaying || _data == null)
            {
                return;
            }

            InputUpdateType currentUpdateType = InputState.currentUpdateType;
            InputUpdateType targetUpdateType = InputUpdateTypeResolver.Resolve();
            if (!InputUpdateTypeResolver.IsMatch(currentUpdateType, targetUpdateType))
            {
                return;
            }

            Vector2 frameDelta = Vector2.zero;
            Vector2 frameScroll = Vector2.zero;

            CollectFrameState(ref frameDelta, ref frameScroll);
            ApplyCurrentFrameSnapshot(Keyboard.current, Mouse.current, frameDelta, frameScroll);

            if (_hasMousePosition)
            {
                ApplyUiEvents();
            }

            if (_showOverlay)
            {
                ReplayInputOverlayState.Update(_currentFrame, _data.Metadata.TotalFrames, _loop);
            }

            _currentFrame++;

            if (_eventIndex >= _data.Frames.Count && _currentFrame > _data.Metadata.TotalFrames)
            {
                if (_delayCompletionForUiModule)
                {
                    _delayCompletionForUiModule = false;
                    return;
                }

                if (_loop)
                {
                    ReleaseAllHeldInputs();
                    _eventIndex = 0;
                    _currentFrame = 0;
                    ResetUiReplayState();
                }
                else
                {
                    StopReplay();
                    ReplayCompleted?.Invoke();
                }
            }
        }

        private static void CollectFrameState(ref Vector2 frameDelta, ref Vector2 frameScroll)
        {
            Debug.Assert(_data != null, "_data must not be null while replaying");

            while (_eventIndex < _data!.Frames.Count && _data.Frames[_eventIndex].Frame <= _currentFrame)
            {
                InputFrameEvents frameEvents = _data.Frames[_eventIndex];
                for (int i = 0; i < frameEvents.Events.Count; i++)
                {
                    ProcessEvent(frameEvents.Events[i], ref frameDelta, ref frameScroll);
                }

                _eventIndex++;
            }
        }

        private static void ApplyCurrentFrameSnapshot(
            Keyboard? keyboard,
            Mouse? mouse,
            Vector2 frameDelta,
            Vector2 frameScroll)
        {
            if (keyboard != null)
            {
                ApplyKeyboardSnapshot(keyboard, _replayHeldKeys);
            }

            if (mouse != null)
            {
                ApplyMouseSnapshot(mouse, _replayHeldButtons, frameDelta, frameScroll, _replayMousePosition);
            }
        }

        private static void ProcessEvent(
            RecordedInputEvent evt,
            ref Vector2 frameDelta,
            ref Vector2 frameScroll)
        {
            switch (evt.Type)
            {
                case InputEventTypes.KEY_DOWN:
                    ProcessKeyDown(evt.Data);
                    break;
                case InputEventTypes.KEY_UP:
                    ProcessKeyUp(evt.Data);
                    break;
                case InputEventTypes.MOUSE_CLICK:
                    ProcessMouseClick(evt.Data);
                    break;
                case InputEventTypes.MOUSE_RELEASE:
                    ProcessMouseRelease(evt.Data);
                    break;
                case InputEventTypes.MOUSE_DELTA:
                    ProcessMouseDelta(evt.Data, ref frameDelta);
                    break;
                case InputEventTypes.MOUSE_SCROLL:
                    ProcessMouseScroll(evt.Data, ref frameScroll);
                    break;
                case InputEventTypes.MOUSE_POSITION:
                    ProcessMousePosition(evt.Data);
                    break;
            }
        }

        private static void ProcessKeyDown(string keyName)
        {
            if (!_keyLookup.TryGetValue(keyName, out Key key))
            {
                return;
            }

            _replayHeldKeys.Add(key);
            if (_showOverlay)
            {
                SimulateKeyboardOverlayState.AddHeldKey(keyName);
            }
        }

        private static void ProcessKeyUp(string keyName)
        {
            if (!_keyLookup.TryGetValue(keyName, out Key key))
            {
                return;
            }

            _replayHeldKeys.Remove(key);
            if (_showOverlay)
            {
                SimulateKeyboardOverlayState.RemoveHeldKey(keyName);
            }
        }

        private static void ProcessMouseClick(string buttonName)
        {
            if (!_buttonLookup.TryGetValue(buttonName, out MouseButton button))
            {
                return;
            }

            _replayHeldButtons.Add(button);
            if (_showOverlay && !_hasMousePosition)
            {
                SimulateMouseInputOverlayState.SetButtonHeld(button, true);
            }
        }

        private static void ProcessMouseRelease(string buttonName)
        {
            if (!_buttonLookup.TryGetValue(buttonName, out MouseButton button))
            {
                return;
            }

            _replayHeldButtons.Remove(button);
            if (_showOverlay && !_hasMousePosition)
            {
                SimulateMouseInputOverlayState.SetButtonHeld(button, false);
            }
        }

        private static void ProcessMouseDelta(string data, ref Vector2 frameDelta)
        {
            frameDelta = InputRecorder.ParseVector2(data);
            if (_showOverlay && !_hasMousePosition)
            {
                SimulateMouseInputOverlayState.SetMoveDelta(frameDelta);
            }
        }

        private static void ProcessMousePosition(string data)
        {
            _replayMousePosition = InputRecorder.ParseVector2(data);
        }

        private static void ProcessMouseScroll(string data, ref Vector2 frameScroll)
        {
            if (!float.TryParse(data, NumberStyles.Float, CultureInfo.InvariantCulture, out float scrollY))
            {
                return;
            }

            frameScroll = new Vector2(0f, scrollY);
            if (_showOverlay && !_hasMousePosition)
            {
                int direction = scrollY > 0f ? 1 : scrollY < 0f ? -1 : 0;
                SimulateMouseInputOverlayState.SetScrollDirection(direction);
            }
        }

        private static void ApplyKeyboardSnapshot(Keyboard keyboard, IReadOnlyCollection<Key> heldKeys)
        {
            InputUpdateType updateType = InputUpdateTypeResolver.Resolve();
            using (StateEvent.From(keyboard, out InputEventPtr eventPtr))
            {
                // StateEvent carries the previous frame's state; without zeroing first,
                // released keys would remain pressed until explicitly cleared.
                for (int i = 0; i < _allKeys.Length; i++)
                {
                    KeyControl? control = keyboard[_allKeys[i]];
                    if (control != null)
                    {
                        control.WriteValueIntoEvent(0f, eventPtr);
                    }
                }

                foreach (Key key in heldKeys)
                {
                    KeyControl? control = keyboard[key];
                    if (control != null)
                    {
                        control.WriteValueIntoEvent(1f, eventPtr);
                    }
                }

                InputState.Change(keyboard, eventPtr, updateType);
            }
        }

        private static void ApplyMouseSnapshot(
            Mouse mouse,
            IReadOnlyCollection<MouseButton> heldButtons,
            Vector2 delta,
            Vector2 scroll,
            Vector2? position)
        {
            InputUpdateType updateType = InputUpdateTypeResolver.Resolve();
            using (StateEvent.From(mouse, out InputEventPtr eventPtr))
            {
                mouse.leftButton.WriteValueIntoEvent(0f, eventPtr);
                mouse.rightButton.WriteValueIntoEvent(0f, eventPtr);
                mouse.middleButton.WriteValueIntoEvent(0f, eventPtr);
                mouse.delta.WriteValueIntoEvent(delta, eventPtr);
                mouse.scroll.WriteValueIntoEvent(scroll, eventPtr);

                if (position.HasValue)
                {
                    mouse.position.WriteValueIntoEvent(position.Value, eventPtr);
                }

                foreach (MouseButton button in heldButtons)
                {
                    MouseInputState.GetButtonControl(mouse, button).WriteValueIntoEvent(1f, eventPtr);
                }

                InputState.Change(mouse, eventPtr, updateType);
            }
        }

        private static void ReleaseAllHeldInputs()
        {
            Keyboard? keyboard = Keyboard.current;
            if (keyboard != null)
            {
                ApplyKeyboardSnapshot(keyboard, _emptyKeys);
            }

            Mouse? mouse = Mouse.current;
            if (mouse != null)
            {
                ApplyMouseSnapshot(mouse, _emptyButtons, Vector2.zero, Vector2.zero, null);
            }

            if (_showOverlay)
            {
                foreach (Key key in _replayHeldKeys)
                {
                    SimulateKeyboardOverlayState.RemoveHeldKey(key.ToString());
                }

                foreach (MouseButton button in _replayHeldButtons)
                {
                    SimulateMouseInputOverlayState.SetButtonHeld(button, false);
                }

                SimulateMouseInputOverlayState.SetMoveDelta(Vector2.zero);
                SimulateMouseInputOverlayState.SetScrollDirection(0);
            }
            _replayHeldKeys.Clear();
            _replayHeldButtons.Clear();
        }

        private static Key[] BuildAllKeys()
        {
            List<Key> keys = new List<Key>();
            foreach (Key key in Enum.GetValues(typeof(Key)))
            {
                if (key == Key.None)
                {
                    continue;
                }

                keys.Add(key);
            }

            return keys.ToArray();
        }

        private static Dictionary<string, Key> BuildKeyLookup()
        {
            Dictionary<string, Key> lookup = new Dictionary<string, Key>(StringComparer.OrdinalIgnoreCase);
            foreach (Key key in Enum.GetValues(typeof(Key)))
            {
                if (key == Key.None)
                {
                    continue;
                }

                string name = key.ToString();
                if (!lookup.ContainsKey(name))
                {
                    lookup[name] = key;
                }
            }

            return lookup;
        }

        private static void ApplyUiEvents()
        {
            if (!_replayMousePosition.HasValue)
            {
                return;
            }

            EventSystem? eventSystem = EventSystem.current;
            if (eventSystem == null)
            {
                return;
            }

            Vector2 screenPos = _replayMousePosition.Value;
            bool mouseMoved = !_previousReplayMousePosition.HasValue
                              || _previousReplayMousePosition.Value != screenPos;
            _previousReplayMousePosition = screenPos;

            bool leftHeld = _replayHeldButtons.Contains(MouseButton.Left);
            bool justPressed = leftHeld && !_prevLeftButtonHeld;
            bool justReleased = !leftHeld && _prevLeftButtonHeld;
            _prevLeftButtonHeld = leftHeld;

            Vector2 gameViewSize = Handles.GetMainGameViewSize();
            Vector2 inputPos = new Vector2(screenPos.x, gameViewSize.y - screenPos.y);
            bool currentDispatchUiEventsManually = ShouldDispatchUiEventsManually(eventSystem);
            bool dispatchUiEventsManually = GetPointerDispatchMode(currentDispatchUiEventsManually);

            if (justPressed)
            {
                StorePointerDispatchMode(currentDispatchUiEventsManually);
                dispatchUiEventsManually = GetPointerDispatchMode(currentDispatchUiEventsManually);
                _suppressIdleUiOverlay = false;
                _pressTime = Time.realtimeSinceStartup;
                _pressScreenPosition = screenPos;
                _isDragging = false;
                if (dispatchUiEventsManually)
                {
                    OnUiPointerDown(screenPos, eventSystem);
                }
                if (_showOverlay)
                {
                    SimulateMouseUiOverlayState.Update(
                        MouseAction.Click, inputPos, null, _currentPressTarget?.name, gameViewSize);
                    SimulateMouseUiOverlayState.RequestExpandAnimation();
                }
            }
            else if (leftHeld && ShouldTrackHeldPointer(dispatchUiEventsManually))
            {
                if (dispatchUiEventsManually)
                {
                    OnUiDrag(screenPos);
                }
                else
                {
                    UpdateOverlayDragState(screenPos, eventSystem);
                }

                if (_isDragging)
                {
                    if (_showOverlay)
                    {
                        Vector2 pressInputPos = new Vector2(_pressScreenPosition.x, gameViewSize.y - _pressScreenPosition.y);
                        SimulateMouseUiOverlayState.Update(
                            MouseAction.Drag, inputPos, pressInputPos, null, gameViewSize);
                    }
                }
                else
                {
                    float elapsed = Time.realtimeSinceStartup - _pressTime;
                    if (_showOverlay && elapsed >= 0.5f)
                    {
                        SimulateMouseUiOverlayState.Update(
                            MouseAction.LongPress, inputPos, null, _currentPressTarget?.name, gameViewSize);
                        SimulateMouseUiOverlayState.UpdateLongPressElapsed(elapsed);
                    }
                }
            }
            else if (!_suppressIdleUiOverlay || mouseMoved)
            {
                // Keeping the overlay hidden until the pointer actually moves prevents release fade-out
                // from being cancelled by the next idle frame at the same position.
                _suppressIdleUiOverlay = false;
                if (_showOverlay)
                {
                    SimulateMouseUiOverlayState.Update(
                        MouseAction.Click, inputPos, null, null, gameViewSize);
                }
            }

            if (justReleased)
            {
                if (dispatchUiEventsManually)
                {
                    OnUiPointerUp(screenPos, eventSystem);
                }
                else
                {
                    RequestCompletionDelayForInputSystemUiModule();
                    ClearPointerState();
                }
                _suppressIdleUiOverlay = true;
                if (_showOverlay)
                {
                    SimulateMouseUiOverlayState.RequestDissipateAnimation();
                    SimulateMouseUiOverlayState.Clear();
                }
            }
        }

        private static void EnsureOverlayForReplay(bool showOverlay)
        {
            if (!showOverlay)
            {
                return;
            }

            OverlayCanvasFactory.EnsureExists();
            RecordReplayOverlayFactory.EnsureReplayOverlay();
        }

        private static void ClearOverlayState()
        {
            ReplayInputOverlayState.Clear();
            SimulateMouseUiOverlayState.Clear();
            SimulateMouseInputOverlayState.Clear();
            SimulateKeyboardOverlayState.Clear();
        }

        private static bool ShouldDispatchUiEventsManually(EventSystem eventSystem)
        {
            BaseInputModule? inputModule = eventSystem.currentInputModule;
            return !(inputModule is InputSystemUIInputModule);
        }

        private static bool GetPointerDispatchMode(bool currentDispatchUiEventsManually)
        {
            if (_hasActivePressDispatchMode)
            {
                return _activePressDispatchesUiEventsManually;
            }

            return currentDispatchUiEventsManually;
        }

        private static void StorePointerDispatchMode(bool dispatchUiEventsManually)
        {
            // EventSystem may select its currentInputModule after the press frame, so release must reuse the press path.
            _hasActivePressDispatchMode = true;
            _activePressDispatchesUiEventsManually = dispatchUiEventsManually;
        }

        private static void RequestCompletionDelayForInputSystemUiModule()
        {
            if (_loop)
            {
                // Looping replays do not invoke ReplayCompleted, so delaying would add an unrecorded gap before reset.
                return;
            }

            if (!IsFinalRecordedFrame())
            {
                return;
            }

            // InputSystemUIInputModule consumes this release in EventSystem.Update after input update,
            // while ReplayCompleted handlers read UI verification state synchronously.
            _delayCompletionForUiModule = true;
        }

        private static bool IsFinalRecordedFrame()
        {
            Debug.Assert(_data != null, "_data must not be null while replaying");

            return _eventIndex >= _data!.Frames.Count && _currentFrame >= _data.Metadata.TotalFrames;
        }

        private static bool ShouldTrackHeldPointer(bool dispatchUiEventsManually)
        {
            if (!dispatchUiEventsManually)
            {
                return true;
            }

            return _currentPressTarget != null || _currentDragTarget != null;
        }

        private static void UpdateOverlayDragState(Vector2 screenPos, EventSystem eventSystem)
        {
            if (_isDragging)
            {
                return;
            }

            float distance = (screenPos - _pressScreenPosition).magnitude;
            if (distance > eventSystem.pixelDragThreshold)
            {
                _isDragging = true;
            }
        }

        private static void OnUiPointerDown(Vector2 screenPos, EventSystem eventSystem)
        {
            RaycastResult? hit = UiRaycastHelper.RaycastUI(screenPos, eventSystem);

            _pointerData = new PointerEventData(eventSystem)
            {
                position = screenPos,
                pressPosition = screenPos,
                button = PointerEventData.InputButton.Left
            };
            _pressScreenPosition = screenPos;
            _isDragging = false;
            _currentDragTarget = null;

            if (hit == null)
            {
                _currentPressTarget = null;
                return;
            }

            GameObject rawTarget = hit.Value.gameObject;
            _pointerData.pointerCurrentRaycast = hit.Value;
            _pointerData.pointerPressRaycast = hit.Value;

            _currentPressTarget = ExecuteEvents.GetEventHandler<IPointerDownHandler>(rawTarget)
                                  ?? ExecuteEvents.GetEventHandler<IPointerClickHandler>(rawTarget);

            if (_currentPressTarget != null)
            {
                _pointerData.pointerPress = _currentPressTarget;
                _pointerData.rawPointerPress = rawTarget;
                ExecuteEvents.ExecuteHierarchy(rawTarget, _pointerData, ExecuteEvents.pointerDownHandler);
            }

            // initializePotentialDrag must fire before beginDrag per StandaloneInputModule contract
            _currentDragTarget = ExecuteEvents.GetEventHandler<IDragHandler>(rawTarget);
            if (_currentDragTarget != null)
            {
                ExecuteEvents.Execute(_currentDragTarget, _pointerData, ExecuteEvents.initializePotentialDrag);
            }
        }

        private static void OnUiDrag(Vector2 screenPos)
        {
            if (_pointerData == null)
            {
                return;
            }

            Vector2 delta = screenPos - _pointerData.position;
            if (delta == Vector2.zero)
            {
                return;
            }

            _pointerData.position = screenPos;
            _pointerData.delta = delta;

            if (!_isDragging && _currentDragTarget != null)
            {
                float distance = (screenPos - _pressScreenPosition).magnitude;
                if (distance > EventSystem.current.pixelDragThreshold)
                {
                    _isDragging = true;
                    _pointerData.dragging = true;
                    _pointerData.pointerDrag = _currentDragTarget;
                    ExecuteEvents.Execute(_currentDragTarget, _pointerData, ExecuteEvents.beginDragHandler);
                }
            }

            if (_isDragging && _currentDragTarget != null)
            {
                ExecuteEvents.Execute(_currentDragTarget, _pointerData, ExecuteEvents.dragHandler);
            }
        }

        private static void OnUiPointerUp(Vector2 screenPos, EventSystem eventSystem)
        {
            if (_pointerData == null)
            {
                return;
            }

            _pointerData.position = screenPos;

            if (_currentPressTarget != null)
            {
                ExecuteEvents.Execute(_currentPressTarget, _pointerData, ExecuteEvents.pointerUpHandler);
            }

            if (_isDragging && _currentDragTarget != null)
            {
                RaycastResult? dropHit = UiRaycastHelper.RaycastUI(screenPos, eventSystem);
                if (dropHit != null)
                {
                    _pointerData.pointerCurrentRaycast = dropHit.Value;
                    GameObject? dropTarget = ExecuteEvents.GetEventHandler<IDropHandler>(dropHit.Value.gameObject);
                    if (dropTarget != null)
                    {
                        ExecuteEvents.Execute(dropTarget, _pointerData, ExecuteEvents.dropHandler);
                    }
                }

                ExecuteEvents.Execute(_currentDragTarget, _pointerData, ExecuteEvents.endDragHandler);
            }
            else if (_currentPressTarget != null)
            {
                // StandaloneInputModule skips click when dragged; match that behavior
                GameObject? clickTarget = ExecuteEvents.GetEventHandler<IPointerClickHandler>(
                    _pointerData.rawPointerPress ?? _currentPressTarget);
                if (clickTarget != null)
                {
                    ExecuteEvents.Execute(clickTarget, _pointerData, ExecuteEvents.pointerClickHandler);
                }
            }

            ClearPointerState();
        }

        private static void ClearPointerState()
        {
            _currentPressTarget = null;
            _currentDragTarget = null;
            _isDragging = false;
            _pointerData = null;
            _hasActivePressDispatchMode = false;
            _activePressDispatchesUiEventsManually = false;
        }

        private static bool DetectMousePositionEvents(InputRecordingData data)
        {
            for (int i = 0; i < data.Frames.Count; i++)
            {
                List<RecordedInputEvent> events = data.Frames[i].Events;
                for (int j = 0; j < events.Count; j++)
                {
                    if (events[j].Type == InputEventTypes.MOUSE_POSITION)
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        private static void ResetUiReplayState()
        {
            _replayMousePosition = null;
            _previousReplayMousePosition = null;
            _prevLeftButtonHeld = false;
            _suppressIdleUiOverlay = false;
            _pointerData = null;
            _currentPressTarget = null;
            _currentDragTarget = null;
            _isDragging = false;
            _pressTime = 0f;
            _delayCompletionForUiModule = false;
            _hasActivePressDispatchMode = false;
            _activePressDispatchesUiEventsManually = false;
        }

        private static void OnPlayModeStateChanged(PlayModeStateChange state)
        {
            if (state == PlayModeStateChange.ExitingPlayMode)
            {
                StopReplay();
            }
        }
    }
}
#endif