using System.Collections.Generic;
using UnityEngine;
using Valve.VR;

public class VrSimulatorHandFixer156 : SteamVR_Behaviour_Pose
{
    Valve.VR.InteractionSystem.Hand _hand;
    protected override void Start()
    {

        base.Start();
        _hand = this.gameObject.GetComponent<Valve.VR.InteractionSystem.Hand>();
        _hand.handType = SteamVR_Input_Sources.RightHand;

            GameObject broHand = GameObject.Instantiate(_hand.gameObject);
            Destroy(broHand.GetComponent<VrSimulatorHandFixer156>());
            broHand.SetActive(false);
        _hand.otherHand = broHand.GetComponent<Valve.VR.InteractionSystem.Hand>();
        _hand.otherHand.handType = SteamVR_Input_Sources.LeftHand;

        var spoofMouse = new SpoofMouseAction();
        _hand.grabGripAction = spoofMouse;
        spoofMouse.InitializeDictionariesExposed(_hand.handType);

        this.poseAction = new Poser_SteamVR_Action_Pose();
    }

    protected override void OnEnable()
    {

    }

    protected override void Update()
    {
        _hand.grabGripAction.UpdateValue(SteamVR_Input_Sources.RightHand);
    }

    protected override void OnDisable()
    {
    }

    protected override void CheckDeviceIndex()
    {
    }

    //----------------------------------------------------------------------------------------------
    class SpoofMouseAction : SteamVR_Action_Boolean
    {
        public SpoofMouseAction()
        {

        }

        public void InitializeDictionariesExposed(SteamVR_Input_Sources source)
        {
            try
            {
                InitializeDictionaries(source);
            }
            catch(System.Exception e)
            {
            }
        }

        protected override void InitializeDictionaries(SteamVR_Input_Sources source)
        {
            base.InitializeDictionaries(source);

            onStateDown.Add(source, null);
            onStateUp.Add(source, null);
            actionData.Add(source, new InputDigitalActionData_t());
            lastActionData.Add(source, new InputDigitalActionData_t());
        }

        public override void UpdateValue(SteamVR_Input_Sources inputSource)
        {
            lastActionData[inputSource] = actionData[inputSource];
            tempActionData.bState = Input.GetMouseButton(0) || Input.GetMouseButtonDown(0);
            tempActionData.bChanged = Input.GetMouseButtonDown(0) || Input.GetMouseButtonUp(0);
            tempActionData.bActive = true;
            //tempActionData.fUpdateTime
            //tempActionData.act

            actionData[inputSource] = tempActionData;
            changed[inputSource] = tempActionData.bChanged;
            active[inputSource] = tempActionData.bActive;
            activeOrigin[inputSource] = tempActionData.activeOrigin;
            updateTime[inputSource] = Time.time;// tempActionData.fUpdateTime;

            if (changed[inputSource])
                lastChanged[inputSource] = Time.time;

            if (onStateDown[inputSource] != null && GetStateDown(inputSource))
                onStateDown[inputSource].Invoke(this);

            if (onStateUp[inputSource] != null && GetStateUp(inputSource))
                onStateUp[inputSource].Invoke(this);

            if (onChange[inputSource] != null && GetChanged(inputSource))
                onChange[inputSource].Invoke(this);

            if (onUpdate[inputSource] != null)
                onUpdate[inputSource].Invoke(this);

            if (onActiveChange[inputSource] != null && lastActionData[inputSource].bActive != active[inputSource])
                onActiveChange[inputSource].Invoke(this, active[inputSource]);
        }
    }
        class Poser_SteamVR_Action_Pose : SteamVR_Action_Pose
    {
        public override bool GetActive(SteamVR_Input_Sources inputSource)
        {
            return false;
        }
    }   
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Valve.VR.InteractionSystem;

public class NewBehaviourScript : MonoBehaviour {

    private Hand.AttachmentFlags attachmentFlags = Hand.defaultAttachmentFlags & (~Hand.AttachmentFlags.SnapOnAttach) & (~Hand.AttachmentFlags.DetachOthers) & (~Hand.AttachmentFlags.VelocityMovement);

    private Interactable interactable;

    // Use this for initialization
    void Start () {
        interactable = this.GetComponent<Interactable>();
    }

    private void HandHoverUpdate(Hand hand)
    {
        GrabTypes startingGrabType = hand.GetGrabStarting();
        bool isGrabEnding = hand.IsGrabEnding(this.gameObject);

        if (startingGrabType != GrabTypes.None)
        {
            // Call this to continue receiving HandHoverUpdate messages,
            // and prevent the hand from hovering over anything else
            hand.HoverLock(interactable);

            // Attach this object to the hand
            hand.AttachObject(gameObject, startingGrabType, attachmentFlags);
        }
        else if (isGrabEnding)
        {
            // Detach this object from the hand
            hand.DetachObject(gameObject);

            // Call this to undo HoverLock
            hand.HoverUnlock(interactable);

        }
    }
}

//======= Copyright (c) Valve Corporation, All rights reserved. ===============
//
// Purpose: Player interface used to query HMD transforms and VR hands
//
//=============================================================================

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

namespace Valve.VR.InteractionSystem
{
    //-------------------------------------------------------------------------
    // Singleton representing the local VR player/user, with methods for getting
    // the player's hands, head, tracking origin, and guesses for various properties.
    //-------------------------------------------------------------------------
    public class Player : MonoBehaviour
    {
        [Tooltip( "Virtual transform corresponding to the meatspace tracking origin. Devices are tracked relative to this." )]
        public Transform trackingOriginTransform;

        [Tooltip( "List of possible transforms for the head/HMD, including the no-SteamVR fallback camera." )]
        public Transform[] hmdTransforms;

        [Tooltip( "List of possible Hands, including no-SteamVR fallback Hands." )]
        public Hand[] hands;

        [Tooltip( "Reference to the physics collider that follows the player's HMD position." )]
        public Collider headCollider;

        [Tooltip( "These objects are enabled when SteamVR is available" )]
        public GameObject rigSteamVR;

        [Tooltip( "These objects are enabled when SteamVR is not available, or when the user toggles out of VR" )]
        public GameObject rig2DFallback;

        [Tooltip( "The audio listener for this player" )]
        public Transform audioListener;

        public bool allowToggleTo2D = true;

        [SteamVR_DefaultAction("PlayerMove", "default")]
        public SteamVR_Action_Vector2 a_move;

        [SteamVR_DefaultAction("PlayerRotate", "default")]
        public SteamVR_Action_Vector2 a_rotate;

        [SteamVR_DefaultAction("MenuClick", "default")]
        public SteamVR_Action_Boolean a_menu;

        //-------------------------------------------------
        // Singleton instance of the Player. Only one can exist at a time.
        //-------------------------------------------------
        private static Player _instance;
        public static Player instance
        {
            get
            {
                if ( _instance == null )
                {
                    _instance = FindObjectOfType<Player>();
                }
                return _instance;
            }
        }

        //-------------------------------------------------
        // Get the number of active Hands.
        //-------------------------------------------------
        public int handCount
        {
            get
            {
                int count = 0;
                for ( int i = 0; i < hands.Length; i++ )
                {
                    if ( hands[i].gameObject.activeInHierarchy )
                    {
                        count++;
                    }
                }
                return count;
            }
        }

        //-------------------------------------------------
        // Get the i-th active Hand.
        //
        // i - Zero-based index of the active Hand to get
        //-------------------------------------------------
        public Hand GetHand( int i )
        {
            for ( int j = 0; j < hands.Length; j++ )
            {
                if ( !hands[j].gameObject.activeInHierarchy )
                {
                    continue;
                }

                if ( i > 0 )
                {
                    i--;
                    continue;
                }

                return hands[j];
            }

            return null;
        }

        //-------------------------------------------------
        public Hand leftHand
        {
            get
            {
                for ( int j = 0; j < hands.Length; j++ )
                {
                    if ( !hands[j].gameObject.activeInHierarchy )
                    {
                        continue;
                    }

                    if ( hands[j].handType != SteamVR_Input_Sources.LeftHand)
                    {
                        continue;
                    }

                    return hands[j];
                }

                return null;
            }
        }

        //-------------------------------------------------
        public Hand rightHand
        {
            get
            {
                for ( int j = 0; j < hands.Length; j++ )
                {
                    if ( !hands[j].gameObject.activeInHierarchy )
                    {
                        continue;
                    }

                    if ( hands[j].handType != SteamVR_Input_Sources.RightHand)
                    {
                        continue;
                    }

                    return hands[j];
                }

                return null;
            }
        }

        //-------------------------------------------------
        // Get Player scale. Assumes it is scaled equally on all axes.
        //-------------------------------------------------

        public float scale
        {
            get
            {
                return transform.lossyScale.x;
            }
        }

        //-------------------------------------------------
        // Get the HMD transform. This might return the fallback camera transform if SteamVR is unavailable or disabled.
        //-------------------------------------------------
        public Transform hmdTransform
        {
            get
            {
                if (hmdTransforms != null)
                {
                    for (int i = 0; i < hmdTransforms.Length; i++)
                    {
                        if (hmdTransforms[i].gameObject.activeInHierarchy)
                            return hmdTransforms[i];
                    }
                }
                return null;
            }
        }

        //-------------------------------------------------
        // Height of the eyes above the ground - useful for estimating player height.
        //-------------------------------------------------
        public float eyeHeight
        {
            get
            {
                Transform hmd = hmdTransform;
                if ( hmd )
                {
                    Vector3 eyeOffset = Vector3.Project( hmd.position - trackingOriginTransform.position, trackingOriginTransform.up );
                    return eyeOffset.magnitude / trackingOriginTransform.lossyScale.x;
                }
                return 0.0f;
            }
        }

        //-------------------------------------------------
        // Guess for the world-space position of the player's feet, directly beneath the HMD.
        //-------------------------------------------------
        public Vector3 feetPositionGuess
        {
            get
            {
                Transform hmd = hmdTransform;
                if ( hmd )
                {
                    return trackingOriginTransform.position + Vector3.ProjectOnPlane( hmd.position - trackingOriginTransform.position, trackingOriginTransform.up );
                }
                return trackingOriginTransform.position;
            }
        }

        //-------------------------------------------------
        // Guess for the world-space direction of the player's hips/torso. This is effectively just the gaze direction projected onto the floor plane.
        //-------------------------------------------------
        public Vector3 bodyDirectionGuess
        {
            get
            {
                Transform hmd = hmdTransform;
                if ( hmd )
                {
                    Vector3 direction = Vector3.ProjectOnPlane( hmd.forward, trackingOriginTransform.up );
                    if ( Vector3.Dot( hmd.up, trackingOriginTransform.up ) < 0.0f )
                    {
                        // The HMD is upside-down. Either
                        // -The player is bending over backwards
                        // -The player is bent over looking through their legs
                        direction = -direction;
                    }
                    return direction;
                }
                return trackingOriginTransform.forward;
            }
        }

        //-------------------------------------------------
        void Awake()
        {
            SteamVR.Initialize(true); //force openvr

            if ( trackingOriginTransform == null )
            {
                trackingOriginTransform = this.transform;
            }
        }

        //-------------------------------------------------
        private IEnumerator Start()
        {
            _instance = this;

            while (SteamVR_Behaviour.instance.forcingInitialization)
                yield return null;

            if ( SteamVR.instance != null )
            {
                ActivateRig( rigSteamVR );
            }
            else
            {
#if !HIDE_DEBUG_UI
                ActivateRig( rig2DFallback );
#endif
            }
        }

        private void Update()
        {
            bool st = a_menu.GetStateDown(SteamVR_Input_Sources.Any);
            if (st)
            {
                this.transform.position = new Vector3(0, 0, 0);
            }
            else
            {
                Camera camera = this.GetComponentInChildren<Camera>();
                Quaternion cr = Quaternion.Euler(0, 0, 0);
                if (camera != null)
                {
                    Vector2 r = a_rotate.GetAxis(SteamVR_Input_Sources.RightHand);
                    Quaternion qp = this.transform.rotation;
                    qp.eulerAngles += new Vector3(0, r.x, 0);
                    this.transform.rotation = qp;
                    cr = camera.transform.rotation;
                }
                Vector2 m = a_move.GetAxis(SteamVR_Input_Sources.LeftHand);
                m = Quaternion.Euler(0, 0, -cr.eulerAngles.y) * m;
                this.transform.position += new Vector3(m.x / 10, 0, m.y / 10);
            }
        }

        //-------------------------------------------------
        void OnDrawGizmos()
        {
            if ( this != instance )
            {
                return;
            }

            //NOTE: These gizmo icons don't work in the plugin since the icons need to exist in a specific "Gizmos"
            //      folder in your Asset tree. These icons are included under Core/Icons. Moving them into a
            //      "Gizmos" folder should make them work again.

            Gizmos.color = Color.white;
            Gizmos.DrawIcon( feetPositionGuess, "vr_interaction_system_feet.png" );

            Gizmos.color = Color.cyan;
            Gizmos.DrawLine( feetPositionGuess, feetPositionGuess + trackingOriginTransform.up * eyeHeight );

            // Body direction arrow
            Gizmos.color = Color.blue;
            Vector3 bodyDirection = bodyDirectionGuess;
            Vector3 bodyDirectionTangent = Vector3.Cross( trackingOriginTransform.up, bodyDirection );
            Vector3 startForward = feetPositionGuess + trackingOriginTransform.up * eyeHeight * 0.75f;
            Vector3 endForward = startForward + bodyDirection * 0.33f;
            Gizmos.DrawLine( startForward, endForward );
            Gizmos.DrawLine( endForward, endForward - 0.033f * ( bodyDirection + bodyDirectionTangent ) );
            Gizmos.DrawLine( endForward, endForward - 0.033f * ( bodyDirection - bodyDirectionTangent ) );

            Gizmos.color = Color.red;
            int count = handCount;
            for ( int i = 0; i < count; i++ )
            {
                Hand hand = GetHand( i );

                if ( hand.handType == SteamVR_Input_Sources.LeftHand)
                {
                    Gizmos.DrawIcon( hand.transform.position, "vr_interaction_system_left_hand.png" );
                }
                else if ( hand.handType == SteamVR_Input_Sources.RightHand)
                {
                    Gizmos.DrawIcon( hand.transform.position, "vr_interaction_system_right_hand.png" );
                }
                else
                {
                    /*
                    Hand.HandType guessHandType = hand.currentHandType;

                    if ( guessHandType == Hand.HandType.Left )
                    {
                        Gizmos.DrawIcon( hand.transform.position, "vr_interaction_system_left_hand_question.png" );
                    }
                    else if ( guessHandType == Hand.HandType.Right )
                    {
                        Gizmos.DrawIcon( hand.transform.position, "vr_interaction_system_right_hand_question.png" );
                    }
                    else
                    {
                        Gizmos.DrawIcon( hand.transform.position, "vr_interaction_system_unknown_hand.png" );
                    }
                    */
                }
            }
        }

        //-------------------------------------------------
        public void Draw2DDebug()
        {
            if ( !allowToggleTo2D )
                return;

            if ( !SteamVR.active )
                return;

            int width = 100;
            int height = 25;
            int left = Screen.width / 2 - width / 2;
            int top = Screen.height - height - 10;

            string text = ( rigSteamVR.activeSelf ) ? "2D Debug" : "VR";

            if ( GUI.Button( new Rect( left, top, width, height ), text ) )
            {
                if ( rigSteamVR.activeSelf )
                {
                    ActivateRig( rig2DFallback );
                }
                else
                {
                    ActivateRig( rigSteamVR );
                }
            }
        }

        //-------------------------------------------------
        private void ActivateRig( GameObject rig )
        {
            rigSteamVR.SetActive( rig == rigSteamVR );
            rig2DFallback.SetActive( rig == rig2DFallback );

            if ( audioListener )
            {
                audioListener.transform.parent = hmdTransform;
                audioListener.transform.localPosition = Vector3.zero;
                audioListener.transform.localRotation = Quaternion.identity;
            }
        }

        //-------------------------------------------------
        public void PlayerShotSelf()
        {
            //Do something appropriate here
        }
    }
}