using System;
using UnityEngine.Events;
using UnityEngine.InputSystem.Layouts;
using UnityEngine.InputSystem.LowLevel;

////TODO: allow multiple device paths

////TODO: streaming support

////REVIEW: consider this for inclusion directly in the input system

namespace UnityEngine.InputSystem
{
    /// <summary>
    /// A wrapper component around <see cref="InputEventTrace"/> that provides an easy interface for recording input
    /// from a GameObject.
    /// </summary>
    /// <remarks>
    /// This component comes with a custom inspector that provides an easy recording and playback interface and also
    /// gives feedback about what has been recorded in the trace. The interface also allows saving and loading event
    /// traces.
    ///
    /// Capturing can either be constrained by a <see cref="devicePath"/> or capture all input occuring in the system.
    ///
    /// Replay by default will happen frame by frame (see <see cref="InputEventTrace.ReplayController.PlayAllFramesOneByOne"/>).
    /// If frame markers are disabled (see <see cref="recordFrames"/>), all events are queued right away in the first
    /// frame and replay completes immediately.
    ///
    /// Other than frame-by-frame, replay can be made to happen in a way that tries to simulate the original input
    /// timing. To do so, enable <see cref="simulateOriginalTimingOnReplay"/>. This will make use of <see
    /// cref="InputEventTrace.ReplayController.PlayAllEventsAccordingToTimestamps"/>
    /// </remarks>
    public class InputRecorder : MonoBehaviour
    {
        /// <summary>
        /// Whether a capture is currently in progress.
        /// </summary>
        /// <value>True if a capture is in progress.</value>
        public bool captureIsRunning => m_EventTrace != null && m_EventTrace.enabled;

        /// <summary>
        /// Whether a replay is currently being run by the component.
        /// </summary>
        /// <value>True if replay is running.</value>
        /// <seealso cref="replay"/>
        /// <seealso cref="StartReplay"/>
        /// <seealso cref="StopReplay"/>
        public bool replayIsRunning => m_ReplayController != null && !m_ReplayController.finished;

        /// <summary>
        /// If true, input recording is started immediately when the component is enabled. Disabled by default.
        /// Call <see cref="StartCapture"/> to manually start capturing.
        /// </summary>
        /// <value>True if component will start recording automatically in <see cref="OnEnable"/>.</value>
        /// <seealso cref="StartCapture"/>
        public bool startRecordingWhenEnabled
        {
            get => m_StartRecordingWhenEnabled;
            set
            {
                m_StartRecordingWhenEnabled = value;
                if (value && enabled && !captureIsRunning)
                    StartCapture();
            }
        }

        /// <summary>
        /// Total number of events captured.
        /// </summary>
        /// <value>Number of captured events.</value>
        public long eventCount => m_EventTrace?.eventCount ?? 0;

        /// <summary>
        /// Total size of captured events.
        /// </summary>
        /// <value>Size of captured events in bytes.</value>
        public long totalEventSizeInBytes => m_EventTrace?.totalEventSizeInBytes ?? 0;

        /// <summary>
        /// Total size of capture memory currently allocated.
        /// </summary>
        /// <value>Size of memory allocated for capture.</value>
        public long allocatedSizeInBytes => m_EventTrace?.allocatedSizeInBytes ?? 0;

        /// <summary>
        /// Whether to record frame marker events when capturing input. Enabled by default.
        /// </summary>
        /// <value>True if frame marker events will be recorded.</value>
        /// <seealso cref="InputEventTrace.recordFrameMarkers"/>
        public bool recordFrames
        {
            get => m_RecordFrames;
            set
            {
                if (m_RecordFrames == value)
                    return;
                m_RecordFrames = value;
                if (m_EventTrace != null)
                    m_EventTrace.recordFrameMarkers = m_RecordFrames;
            }
        }

        /// <summary>
        /// Whether to record only <see cref="StateEvent"/>s and <see cref="DeltaStateEvent"/>s. Disabled by
        /// default.
        /// </summary>
        /// <value>True if anything but state events should be ignored.</value>
        public bool recordStateEventsOnly
        {
            get => m_RecordStateEventsOnly;
            set => m_RecordStateEventsOnly = value;
        }

        /// <summary>
        /// Path that constrains the devices to record from.
        /// </summary>
        /// <value>Input control path to match devices or null/empty.</value>
        /// <remarks>
        /// By default, this is not set. Meaning that input will be recorded from all devices. By setting this property
        /// to a path, only events for devices that match the given path (as dictated by <see cref="InputControlPath.Matches"/>)
        /// will be recorded from.
        ///
        /// By setting this property to the exact path of a device at runtime, recording can be restricted to just that
        /// device.
        /// </remarks>
        /// <seealso cref="InputControlPath"/>
        /// <seealso cref="InputControlPath.Matches"/>
        public string devicePath
        {
            get => m_DevicePath;
            set => m_DevicePath = value;
        }

        public string recordButtonPath
        {
            get => m_RecordButtonPath;
            set
            {
                m_RecordButtonPath = value;
                HookOnInputEvent();
            }
        }

        public string playButtonPath
        {
            get => m_PlayButtonPath;
            set
            {
                m_PlayButtonPath = value;
                HookOnInputEvent();
            }
        }

        /// <summary>
        /// The underlying event trace that contains the captured input events.
        /// </summary>
        /// <value>Underlying event trace.</value>
        /// <remarks>
        /// This will be null if no capture is currently associated with the recorder.
        /// </remarks>
        public InputEventTrace capture => m_EventTrace;

        /// <summary>
        /// The replay controller for when a replay is running.
        /// </summary>
        /// <value>Replay controller for the event trace while replay is running.</value>
        /// <seealso cref="replayIsRunning"/>
        /// <seealso cref="StartReplay"/>
        public InputEventTrace.ReplayController replay => m_ReplayController;

        public int replayPosition
        {
            get
            {
                if (m_ReplayController != null)
                    return m_ReplayController.position;
                return 0;
            }
            ////TODO: allow setting replay position
        }

        /// <summary>
        /// Whether a replay should create new devices or replay recorded events as is. Disabled by default.
        /// </summary>
        /// <value>True if replay should temporary create new devices.</value>
        /// <seealso cref="InputEventTrace.ReplayController.WithAllDevicesMappedToNewInstances"/>
        public bool replayOnNewDevices
        {
            get => m_ReplayOnNewDevices;
            set => m_ReplayOnNewDevices = value;
        }

        /// <summary>
        /// Whether to attempt to re-create the original event timing when replaying events. Disabled by default.
        /// </summary>
        /// <value>If true, events are queued based on their timestamp rather than based on their recorded frames (if any).</value>
        /// <seealso cref="InputEventTrace.ReplayController.PlayAllEventsAccordingToTimestamps"/>
        public bool simulateOriginalTimingOnReplay
        {
            get => m_SimulateOriginalTimingOnReplay;
            set => m_SimulateOriginalTimingOnReplay = value;
        }

        public ChangeEvent changeEvent
        {
            get
            {
                if (m_ChangeEvent == null)
                    m_ChangeEvent = new ChangeEvent();
                return m_ChangeEvent;
            }
        }

        public void StartCapture()
        {
            if (m_EventTrace != null && m_EventTrace.enabled)
                return;

            CreateEventTrace();
            m_EventTrace.Enable();
            m_ChangeEvent?.Invoke(Change.CaptureStarted);
        }

        public void StopCapture()
        {
            if (m_EventTrace != null && m_EventTrace.enabled)
            {
                m_EventTrace.Disable();
                m_ChangeEvent?.Invoke(Change.CaptureStopped);
            }
        }

        public void StartReplay()
        {
            if (m_EventTrace == null)
                return;

            if (replayIsRunning && replay.paused)
            {
                replay.paused = false;
                return;
            }

            StopCapture();

            // Configure replay controller.
            m_ReplayController = m_EventTrace.Replay()
                .OnFinished(StopReplay)
                .OnEvent(_ => m_ChangeEvent?.Invoke(Change.EventPlayed));
            if (m_ReplayOnNewDevices)
                m_ReplayController.WithAllDevicesMappedToNewInstances();

            // Start replay.
            if (m_SimulateOriginalTimingOnReplay)
                m_ReplayController.PlayAllEventsAccordingToTimestamps();
            else
                m_ReplayController.PlayAllFramesOneByOne();

            m_ChangeEvent?.Invoke(Change.ReplayStarted);
        }

        public void StopReplay()
        {
            if (m_ReplayController != null)
            {
                m_ReplayController.Dispose();
                m_ReplayController = null;
                m_ChangeEvent?.Invoke(Change.ReplayStopped);
            }
        }

        public void PauseReplay()
        {
            if (m_ReplayController != null)
                m_ReplayController.paused = true;
        }

        public void ClearCapture()
        {
            m_EventTrace?.Clear();
        }

        public void LoadCaptureFromFile(string fileName)
        {
            if (string.IsNullOrEmpty(fileName))
                throw new ArgumentNullException(nameof(fileName));

            CreateEventTrace();
            m_EventTrace.ReadFrom(fileName);
        }

        public void SaveCaptureToFile(string fileName)
        {
            if (string.IsNullOrEmpty(fileName))
                throw new ArgumentNullException(nameof(fileName));
            m_EventTrace?.WriteTo(fileName);
        }

        protected void OnEnable()
        {
            // Hook InputSystem.onEvent before the event trace does.
            HookOnInputEvent();

            if (m_StartRecordingWhenEnabled)
                StartCapture();
        }

        protected void OnDisable()
        {
            StopCapture();
            StopReplay();
            UnhookOnInputEvent();
        }

        protected void OnDestroy()
        {
            m_ReplayController?.Dispose();
            m_ReplayController = null;
            m_EventTrace?.Dispose();
            m_EventTrace = null;
        }

        private bool OnFilterInputEvent(InputEventPtr eventPtr, InputDevice device)
        {
            // Filter out non-state events, if enabled.
            if (m_RecordStateEventsOnly && !eventPtr.IsA<StateEvent>() && !eventPtr.IsA<DeltaStateEvent>())
                return false;

            // Match device path, if set.
            if (string.IsNullOrEmpty(m_DevicePath) || device == null)
                return true;
            return InputControlPath.MatchesPrefix(m_DevicePath, device);
        }

        private void OnEventRecorded(InputEventPtr eventPtr)
        {
            m_ChangeEvent?.Invoke(Change.EventCaptured);
        }

        private void OnInputEvent(InputEventPtr eventPtr, InputDevice device)
        {
            if (!eventPtr.IsA<StateEvent>() && !eventPtr.IsA<DeltaStateEvent>())
                return;

            if (!string.IsNullOrEmpty(m_PlayButtonPath))
            {
                var playControl = InputControlPath.TryFindControl(device, m_PlayButtonPath) as InputControl<float>;
                if (playControl != null && playControl.ReadValueFromEvent(eventPtr) >= InputSystem.settings.defaultButtonPressPoint)
                {
                    if (replayIsRunning)
                        StopReplay();
                    else
                        StartReplay();

                    eventPtr.handled = true;
                }
            }

            if (!string.IsNullOrEmpty(m_RecordButtonPath))
            {
                var recordControl = InputControlPath.TryFindControl(device, m_RecordButtonPath) as InputControl<float>;
                if (recordControl != null && recordControl.ReadValueFromEvent(eventPtr) >= InputSystem.settings.defaultButtonPressPoint)
                {
                    if (captureIsRunning)
                        StopCapture();
                    else
                        StartCapture();

                    eventPtr.handled = true;
                }
            }
        }

        #if UNITY_EDITOR
        protected void OnValidate()
        {
            if (m_EventTrace != null)
                m_EventTrace.recordFrameMarkers = m_RecordFrames;
        }

        #endif

        [SerializeField] private bool m_StartRecordingWhenEnabled = false;

        [Tooltip("If enabled, additional events will be recorded that demarcate frame boundaries. When replaying, this allows "
            + "spacing out input events across frames corresponding to the original distribution across frames when input was "
            + "recorded. If this is turned off, all input events will be queued in one block when replaying the trace.")]
        [SerializeField] private bool m_RecordFrames = true;

        [Tooltip("If enabled, new devices will be created for captured events when replaying them. If disabled (default), "
            + "events will be queued as is and thus keep their original device ID.")]
        [SerializeField] private bool m_ReplayOnNewDevices;

        [Tooltip("If enabled, the system will try to simulate the original event timing on replay. This differs from replaying frame "
            + "by frame in that replay will try to compensate for differences in frame timings and redistribute events to frames that "
            + "more closely match the original timing. Note that this is not perfect and will not necessarily create a 1:1 match.")]
        [SerializeField] private bool m_SimulateOriginalTimingOnReplay;

        [Tooltip("If enabled, only StateEvents and DeltaStateEvents will be captured.")]
        [SerializeField] private bool m_RecordStateEventsOnly;

        [SerializeField] private int m_CaptureMemoryDefaultSize = 2 * 1024 * 1024;
        [SerializeField] private int m_CaptureMemoryMaxSize = 10 * 1024 * 1024;

        [SerializeField]
        [InputControl(layout = "InputDevice")]
        private string m_DevicePath;

        [SerializeField]
        [InputControl(layout = "Button")]
        private string m_RecordButtonPath;

        [SerializeField]
        [InputControl(layout = "Button")]
        private string m_PlayButtonPath;

        [SerializeField] private ChangeEvent m_ChangeEvent;

        private Action<InputEventPtr, InputDevice> m_OnInputEventDelegate;
        private InputEventTrace m_EventTrace;
        private InputEventTrace.ReplayController m_ReplayController;

        private void CreateEventTrace()
        {
            ////FIXME: remaining configuration should come through, too, if changed after the fact
            if (m_EventTrace == null || m_EventTrace.maxSizeInBytes == 0)
            {
                m_EventTrace?.Dispose();
                m_EventTrace = new InputEventTrace(m_CaptureMemoryDefaultSize, growBuffer: true, maxBufferSizeInBytes: m_CaptureMemoryMaxSize);
            }

            m_EventTrace.recordFrameMarkers = m_RecordFrames;
            m_EventTrace.onFilterEvent += OnFilterInputEvent;
            m_EventTrace.onEvent += OnEventRecorded;
        }

        private void HookOnInputEvent()
        {
            if (string.IsNullOrEmpty(m_PlayButtonPath) && string.IsNullOrEmpty(m_RecordButtonPath))
            {
                UnhookOnInputEvent();
                return;
            }

            if (m_OnInputEventDelegate == null)
                m_OnInputEventDelegate = OnInputEvent;
            InputSystem.onEvent += m_OnInputEventDelegate;
        }

        private void UnhookOnInputEvent()
        {
            if (m_OnInputEventDelegate != null)
                InputSystem.onEvent -= m_OnInputEventDelegate;
        }

        public enum Change
        {
            None,
            EventCaptured,
            EventPlayed,
            CaptureStarted,
            CaptureStopped,
            ReplayStarted,
            ReplayStopped,
        }

        [Serializable]
        public class ChangeEvent : UnityEvent<Change>
        {
        }
    }
}