/// ---------------------------------------------
/// Ultimate Character Controller
/// Copyright (c) Opsive. All Rights Reserved.
/// https://www.opsive.com
/// ---------------------------------------------

namespace Opsive.UltimateCharacterController.Input
{
    using Opsive.UltimateCharacterController.Input.VirtualControls;
    using System.Collections.Generic;
    using UnityEngine;

    /// <summary>
    /// Acts as a common base class for input using the Unity Input Manager. Works with keyboard/mouse, controller, and mobile input.
    /// </summary>
    public class UnityInput : PlayerInput
    {
        /// <summary>
        /// Specifies if any input type should be forced.
        /// </summary>
        public enum ForceInputType { None, Standalone, Virtual }

        [Tooltip("Specifies if any input type should be forced.")]
        [SerializeField] protected ForceInputType m_ForceInput;
        [Tooltip("Should the cursor be disabled?")]
        [SerializeField] protected bool m_DisableCursor = true;
        [Tooltip("Should the cursor be enabled when the escape key is pressed?")]
        [SerializeField] protected bool m_EnableCursorWithEscape = true;
        [Tooltip("If the cursor is enabled with escape should the look vector be prevented from updating?")]
        [SerializeField] protected bool m_PreventLookVectorChanges = true;
        [Tooltip("The joystick is considered up when the raw value is less than the specified threshold.")]
        [Range(0, 1)] [SerializeField] protected float m_JoystickUpThreshold = 1;

        public bool DisableCursor { get { return m_DisableCursor; }
            set
            {
                if (m_Input is VirtualInput) {
                    m_DisableCursor = false;
                }
                m_DisableCursor = value;
                if (m_DisableCursor && Cursor.visible) {
                    Cursor.lockState = CursorLockMode.Locked;
                    Cursor.visible = false;
                } else if (!m_DisableCursor && !Cursor.visible) {
                    Cursor.lockState = CursorLockMode.None;
                    Cursor.visible = true;
                }
            }
        }
        public bool EnableCursorWithEscape { get { return m_EnableCursorWithEscape; } set { m_EnableCursorWithEscape = value; } }
        public bool PreventLookMovementWithEscape { get { return m_PreventLookVectorChanges; } set { m_PreventLookVectorChanges = value; } }
        public float JoystickUpThreshold { get { return m_JoystickUpThreshold; } set { m_JoystickUpThreshold = value; } }

        private InputBase m_Input;
        private bool m_UseVirtualInput;
        private HashSet<string> m_JoystickDownSet;
        private HashSet<string> m_ToAddJoystickDownSet;
        private HashSet<string> m_ToRemoveJoystickDownSet;

        /// <summary>
        /// Initialize the default values.
        /// </summary>
        protected override void Awake()
        {
            base.Awake();

            m_UseVirtualInput = m_ForceInput == ForceInputType.Virtual;
#if !UNITY_EDITOR && (UNITY_IPHONE || UNITY_ANDROID || UNITY_WP_8_1 || UNITY_BLACKBERRY)
            if (m_ForceInput != ForceInputType.Standalone) {
                m_UseVirtualInput = true;
            }
#endif
            if (m_UseVirtualInput) {
                m_Input = new VirtualInput();
                // The cursor must be enabled for virtual controls to allow the drag events to occur.
                m_DisableCursor = false;
            } else {
                m_Input = new StandaloneInput();
            }
            m_Input.Initialize(this);
        }

        /// <summary>
        /// The component has been enabled.
        /// </summary>
        private void OnEnable()
        {
            if (!m_UseVirtualInput && m_DisableCursor) {
                Cursor.lockState = CursorLockMode.Locked;
                Cursor.visible = false;
            }
        }

        /// <summary>
        /// Associates the VirtualControlsManager with the VirtualInput object.
        /// </summary>
        /// <param name="virtualControlsManager">The VirtualControlsManager to associate with the VirtualInput object.</param>
        /// <returns>True if the virtual controls were registered.</returns>
        public bool RegisterVirtualControlsManager(VirtualControlsManager virtualControlsManager)
        {
            if (m_Input is VirtualInput) {
                (m_Input as VirtualInput).RegisterVirtualControlsManager(virtualControlsManager);
                return true;
            }
            return false;
        }

        /// <summary>
        /// Removes the VirtualControlsManager association.
        /// </summary>
        public void UnegisterVirtualControlsManager()
        {
            if (m_Input is VirtualInput) {
                (m_Input as VirtualInput).UnregisterVirtualControlsManager();
            }
        }

        /// <summary>
        /// Update the joystick and cursor state values.
        /// </summary>
        private void LateUpdate()
        {
            if (m_UseVirtualInput) {
                return;
            }
            // The joystick is no longer down after the axis is 0.
            if (IsControllerConnected()) {
                // GetButtonUp/Down doesn't immediately add the button name to the set to prevent the GetButtonUp/Down from returning false
                // if it is called twice within the same frame. Add it after the frame has ended.
                if (m_JoystickDownSet != null) {
                    foreach (var item in m_JoystickDownSet) {
                        if (Mathf.Abs(m_Input.GetAxisRaw(item)) < m_JoystickUpThreshold) {
                            m_ToRemoveJoystickDownSet.Add(item);
                        }
                    }
                    foreach (var item in m_ToRemoveJoystickDownSet) {
                        m_JoystickDownSet.Remove(item);
                    }
                    m_ToRemoveJoystickDownSet.Clear();
                }
                if (m_ToAddJoystickDownSet != null && m_ToAddJoystickDownSet.Count > 0) {
                    if (m_JoystickDownSet == null) {
                        m_JoystickDownSet = new HashSet<string>();
                        m_ToRemoveJoystickDownSet = new HashSet<string>();
                    }
                    foreach (var item in m_ToAddJoystickDownSet) {
                        m_JoystickDownSet.Add(item);
                    }
                    m_ToAddJoystickDownSet.Clear();
                }
            }

            // Enable the cursor if the escape key is pressed. Disable the cursor if it is visbile but should be disabled upon press.
            if (m_EnableCursorWithEscape && UnityEngine.Input.GetKeyDown(KeyCode.Escape)) {
                Cursor.lockState = CursorLockMode.None;
                Cursor.visible = true;
                if (m_PreventLookVectorChanges) {
                    OnApplicationFocus(false);
                }
            } else if (Cursor.visible && m_DisableCursor && !IsPointerOverUI() && (UnityEngine.Input.GetKeyDown(KeyCode.Mouse0) || UnityEngine.Input.GetKeyDown(KeyCode.Mouse1))) {
                Cursor.lockState = CursorLockMode.Locked;
                Cursor.visible = false;
                if (m_PreventLookVectorChanges) {
                    OnApplicationFocus(true);
                }
            }
#if UNITY_EDITOR
            // The cursor should be visible when the game is paused.
            if (!Cursor.visible && Time.deltaTime == 0 && !m_DisableCursor) {
                Cursor.lockState = CursorLockMode.None;
                Cursor.visible = true;
            }
#endif
        }

        /// <summary>
        /// Internal method which returns true if the button is being pressed.
        /// </summary>
        /// <param name="name">The name of the button.</param>
        /// <returns>True of the button is being pressed.</returns>
        protected override bool GetButtonInternal(string name)
        {
            if (m_Input.GetButton(name, InputBase.ButtonAction.GetButton)) {
                return true;
            }
            if (IsControllerConnected()) {
                if (Mathf.Abs(m_Input.GetAxisRaw(name)) == 1) {
                    if (m_JoystickDownSet == null || !m_JoystickDownSet.Contains(name)) {
                        if (m_ToAddJoystickDownSet == null) {
                            m_ToAddJoystickDownSet = new HashSet<string>();
                        }
                        m_ToAddJoystickDownSet.Add(name);
                    }
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// Internal method which returns true if the button was pressed this frame.
        /// </summary>
        /// <param name="name">The name of the button.</param>
        /// <returns>True if the button is pressed this frame.</returns>
        protected override bool GetButtonDownInternal(string name)
        {
            if (IsControllerConnected() && Mathf.Abs(m_Input.GetAxisRaw(name)) == 1) {
                // The button should only be considered down on the first frame.
                if (m_JoystickDownSet != null && m_JoystickDownSet.Contains(name)) {
                    return false;
                }
                if (m_ToAddJoystickDownSet == null) {
                    m_ToAddJoystickDownSet = new HashSet<string>();
                }
                m_ToAddJoystickDownSet.Add(name);
                return true;
            }
            return m_Input.GetButton(name, InputBase.ButtonAction.GetButtonDown);
        }

        /// <summary>
        /// Internal method which returnstrue if the button is up.
        /// </summary>
        /// <param name="name">The name of the button.</param>
        /// <returns>True if the button is up.</returns>
        protected override bool GetButtonUpInternal(string name)
        {
            if (IsControllerConnected()) {
                if (Mathf.Abs(m_Input.GetAxisRaw(name)) == 1 && (m_JoystickDownSet == null || !m_JoystickDownSet.Contains(name))) {
                    if (m_ToAddJoystickDownSet == null) {
                        m_ToAddJoystickDownSet = new HashSet<string>();
                    }
                    m_ToAddJoystickDownSet.Add(name);
                    return false;
                }
                if (m_JoystickDownSet != null && m_JoystickDownSet.Contains(name) && m_Input.GetAxisRaw(name) < m_JoystickUpThreshold) {
                    return true;
                }
                return false;
            }
            return m_Input.GetButton(name, InputBase.ButtonAction.GetButtonUp);
        }

        /// <summary>
        /// Internal method which returns the value of the axis with the specified name.
        /// </summary>
        /// <param name="name">The name of the axis.</param>
        /// <returns>The value of the axis.</returns>
        protected override float GetAxisInternal(string name)
        {
            return m_Input.GetAxis(name);
        }

        /// <summary>
        /// Internal method which returns the value of the raw axis with the specified name.
        /// </summary>
        /// <param name="name">The name of the axis.</param>
        /// <returns>The value of the raw axis.</returns>
        protected override float GetAxisRawInternal(string name)
        {
            return m_Input.GetAxisRaw(name);
        }

        /// <summary>
        /// Returns true if the pointer is over a UI element.
        /// </summary>
        /// <returns>True if the pointer is over a UI element.</returns>
        public override bool IsPointerOverUI()
        {
            // The input will always be over a UI element with virtual inputs.
            if (m_Input is VirtualInput) {
                return false;
            }
            return base.IsPointerOverUI();
        }

        /// <summary>
        /// Enables or disables gameplay input. An example of when it will not be enabled is when there is a fullscreen UI over the main camera.
        /// </summary>
        /// <param name="enable">True if the input is enabled.</param>
        protected override void EnableGameplayInput(bool enable)
        {
            base.EnableGameplayInput(enable);

            if (enable && m_DisableCursor) {
                Cursor.lockState = CursorLockMode.Locked;
                Cursor.visible = false;
            }
        }

        /// <summary>
        /// Does the game have focus?
        /// </summary>
        /// <param name="hasFocus">True if the game has focus.</param>
        protected override void OnApplicationFocus(bool hasFocus)
        {
            base.OnApplicationFocus(hasFocus);

            if (enabled && hasFocus && m_DisableCursor) {
                Cursor.lockState = CursorLockMode.Locked;
                Cursor.visible = false;
            }
        }
    }
}