using System.Runtime.InteropServices;
using UnityEngine.InputSystem.Controls;
using UnityEngine.InputSystem.Layouts;
using UnityEngine.InputSystem.LowLevel;
using UnityEngine.InputSystem.Utilities;
using UnityEngine.Scripting;

////TODO: add capabilities indicating whether pressure is supported

////REVIEW: is there an opportunity to collapse "press" and "pressure" into one? after all, if there's any pressure, isn't the pointer pressed?

////REVIEW: should "displayIndex" be called "windowIndex"? or be part of a better thought-out multi-display API altogether?

////REVIEW: add click and clickCount controls directly to Pointer?
////        (I gave this a look but in my initial try, found it somewhat difficult to add click detection at the Pointer level due
////        to the extra state it involves)

////REVIEW: should we put lock state directly on Pointer?

////REVIEW: should pointer IDs be required to be globally unique across pointing devices?
////REVIEW: should we create new devices instead of using pointer IDs?

////FIXME: pointer deltas in EditorWindows need to be Y *down*

////REVIEW: kill EditorWindowSpace processor and add GetPositionInEditorWindowSpace() and GetDeltaInEditorWindowSpace()?
////        (if we do this, every touch control has to get this, too)

namespace UnityEngine.InputSystem.LowLevel
{
    /// <summary>
    /// Default state structure for pointer devices.
    /// </summary>
    [StructLayout(LayoutKind.Sequential)]
    internal struct PointerState : IInputStateTypeInfo
    {
        public static FourCC kFormat => new FourCC('P', 'T', 'R');

        uint pointerId;

        /// <summary>
        /// Position of the pointer in screen space.
        /// </summary>
#if UNITY_EDITOR
        [InputControl(layout = "Vector2", displayName = "Position", usage = "Point", processors = "AutoWindowSpace", dontReset = true)]
#else
        [InputControl(layout = "Vector2", displayName = "Position", usage = "Point", dontReset = true)]
#endif
        public Vector2 position;

        ////REVIEW: if we have Secondary2DMotion on this, seems like this should be normalized
        [InputControl(layout = "Delta", displayName = "Delta", usage = "Secondary2DMotion")]
        public Vector2 delta;

        [InputControl(layout = "Analog", displayName = "Pressure", usage = "Pressure", defaultState = 1f)]
        public float pressure;

        [InputControl(layout = "Vector2", displayName = "Radius", usage = "Radius")]
        public Vector2 radius;

        [InputControl(name = "press", displayName = "Press", layout = "Button", format = "BIT", bit = 0)]
        public ushort buttons;

        public FourCC format => kFormat;
    }
}

namespace UnityEngine.InputSystem
{
    /// <summary>
    /// Base class for pointer-style devices moving on a 2D screen.
    /// </summary>
    /// <remarks>
    /// This class abstracts over general "pointing" behavior where a pointer is moved across a 2D
    /// surface. Operating at the <c>Pointer</c> level allows treating <see>Mouse</see>, <see>Pen</see>,
    /// and <see>Touchscreen</see> all as pointers with a set of shared behaviors.
    ///
    /// Note that a pointer may have "multi-point" ability as is the case with multi-touch where
    /// multiple touches represent multiple concurrent "pointers". However, for any pointer device
    /// with multiple pointers, only one pointer is considered "primary" and drives the pointer
    /// controls present on the base class.
    /// </remarks>
    /// <seealso cref="Mouse"/>
    /// <seealso cref="Pen"/>
    /// <seealso cref="Touchscreen"/>
    [InputControlLayout(stateType = typeof(PointerState), isGenericTypeOfDevice = true)]
    public class Pointer : InputDevice, IInputStateCallbackReceiver
    {
        ////REVIEW: shouldn't this be done for every touch position, too?
        /// <summary>
        /// The current pointer coordinates in window space.
        /// </summary>
        /// <value>Control representing the current position of the pointer on screen.</value>
        /// <remarks>
        /// Within player code, the coordinates are in the coordinate space of Unity's <c>Display</c>.
        ///
        /// Within editor code, the coordinates are in the coordinate space of the current <c>EditorWindow</c>
        /// This means that if you query the <see cref="Mouse"/> <see cref="position"/> in <c>EditorWindow.OnGUI</c>, for example,
        /// the returned 2D vector will be in the coordinate space of your local GUI (same as
        /// <c>Event.mousePosition</c>).
        /// </remarks>
        public Vector2Control position { get; protected set; }

        /// <summary>
        /// The current window-space motion delta of the pointer.
        /// </summary>
        /// <value>Control representing the motion delta of the pointer.</value>
        /// <remarks>
        /// Every time a pointer is moved, it generates a motion delta. This control represents
        /// this motion.
        ///
        /// Note that some pointers have the ability to generate motion deltas <em>without</em>
        /// actually changing the position of the pointer. This is the case for <see cref="Mouse"/>
        /// which even when, for example, bumping up against the edges of the screen or when being
        /// locked in place, can generate motion. This means that activity on <c>delta</c> is not
        /// necessarily correlated with activity on <see cref="position"/>.
        ///
        /// Deltas have two special behaviors attached to them that makes them quite unique
        /// among input controls.
        ///
        /// For one, deltas will automatically reset to <c>(0,0)</c> between frames. If, for example,
        /// the current delta value is <c>(12,8)</c>, then after the next <see cref="InputSystem.Update"/>,
        /// the delta is automatically set to <c>(0,0)</c>. More precisely, deltas will reset as part
        /// of <see cref="InputSystem.onBeforeUpdate"/>. This happens every time regardless of whether
        /// there are pending motion events for the pointer or not. But because it happens in
        /// <see cref="InputSystem.onBeforeUpdate"/> (that is, <em>before</em> events are processed),
        /// subsequent motion deltas are incorporated normally.
        ///
        /// Note that the resetting is visible to <see cref="InputAction"/>s. This means that when
        /// binding to a delta control from an action that is not using <see cref="InputActionType.PassThrough"/>,
        /// you will see the action getting cancelled at the start of every frame. With a <c>PassThrough</c>
        /// actions, you will instead see it perform one extra time with a zero value.
        ///
        /// The other special behavior of deltas is accumulation. When receiving more than one
        /// motion update in a frame, deltas will not simply switch from one value to the other
        /// but instead accumulate them. For example, if two events are received for a pointer
        /// in a frame and one has a motion delta of <c>(1,1)</c> and the other has a motion delta
        /// of <c>(2,2)</c>, then once <see cref="InputSystem.Update"/> has finished processing
        /// events, the value of the delta control will be <c>(3,3)</c> and not <c>(2,2)</c>.
        ///
        /// Note that just like resetting, accumulation is also visible to <see cref="InputAction"/>s.
        /// This means that because the delta control changes value twice, the action will trigger
        /// twice but the value when it is triggered the second time will be <c>(3,3)</c> and
        /// not <c>(2,2)</c> even though that's the value received from the event.
        /// </remarks>
        /// <seealso cref="InputControlExtensions.AccumulateValueInEvent"/>
        public DeltaControl delta { get; protected set; }

        ////REVIEW: move this down to only TouchScreen?
        /// <summary>
        /// Window-space radius of the pointer contact with the surface.
        /// </summary>
        /// <value>Control representing the horizontal and vertical extents of the pointer contact.</value>
        /// <remarks>
        /// Usually, only touch input has radius detection.
        /// </remarks>
        /// <seealso cref="TouchControl.radius"/>
        public Vector2Control radius { get; protected set; }

        /// <summary>
        /// Normalized pressure with which the pointer is currently pressed while in contact with the pointer surface.
        /// </summary>
        /// <value>Control representing the pressure with which the pointer is pressed down.</value>
        /// <remarks>
        /// This is only meaningful for pointing devices that support pressure. Mice do not, pens usually do, and touch
        /// usually does on mobile platforms.
        ///
        /// Note that it is possible for the value to go above 1 even though it is considered normalized. The reason is
        /// that calibration on the system can put the maximum pressure point below the physically supported maximum value.
        /// </remarks>
        public AxisControl pressure { get; protected set; }

        /// <summary>
        /// Whether the pointer is pressed down.
        /// </summary>
        /// <remarks>
        /// What this means exactly depends on the nature of the pointer. For mice (<see cref="Mouse"/>), it means
        /// that the left button is pressed. For pens (<see cref="Pen"/>), it means that the pen tip is touching
        /// the screen/tablet surface. For touchscreens (<see cref="Touchscreen"/>), it means that there is at least
        /// one finger touching the screen.
        /// </remarks>
        public ButtonControl press { get; protected set; }

        /// <summary>
        /// The pointer that was added or used last by the user or <c>null</c> if there is no pointer
        /// device connected to the system.
        /// </summary>
        /// <value>Currently active <c>Pointer</c> or <c>null</c>.</value>
        public static Pointer current { get; internal set; }

        /// <inheritdoc />
        public override void MakeCurrent()
        {
            base.MakeCurrent();
            current = this;
        }

        /// <inheritdoc />
        protected override void OnRemoved()
        {
            base.OnRemoved();
            if (current == this)
                current = null;
        }

        /// <inheritdoc />
        protected override void FinishSetup()
        {
            position = GetChildControl<Vector2Control>("position");
            delta = GetChildControl<DeltaControl>("delta");
            radius = GetChildControl<Vector2Control>("radius");
            pressure = GetChildControl<AxisControl>("pressure");
            press = GetChildControl<ButtonControl>("press");

            base.FinishSetup();
        }

        /// <summary>
        /// Called whenever the input system advances by one frame.
        /// </summary>
        /// <seealso cref="InputSystem.Update"/>
        protected void OnNextUpdate()
        {
            InputState.Change(delta, Vector2.zero);
        }

        /// <summary>
        /// Called when the pointer receives a state event.
        /// </summary>
        /// <param name="eventPtr">The input event.</param>
        protected unsafe void OnStateEvent(InputEventPtr eventPtr)
        {
            ////FIXME: This stuff makes pointer events too expensive; find a better way.
            delta.AccumulateValueInEvent(currentStatePtr, eventPtr);
            InputState.Change(this, eventPtr);
        }

        void IInputStateCallbackReceiver.OnNextUpdate()
        {
            OnNextUpdate();
        }

        void IInputStateCallbackReceiver.OnStateEvent(InputEventPtr eventPtr)
        {
            OnStateEvent(eventPtr);
        }

        bool IInputStateCallbackReceiver.GetStateOffsetForEvent(InputControl control, InputEventPtr eventPtr, ref uint offset)
        {
            return false;
        }
    }
}