using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.Events;

public class gravityGun : MonoBehaviour
{
    [Header ("Main Settings")]
    [Space]

    public float holdDistance = 3;
    public float maxDistanceHeld = 4;
    public float maxDistanceGrab = 10;
    public float holdSpeed = 10;

    public float rotationSpeed;

    public grabMode currentGrabMode;

    public string grabbedObjectTag;
    public string grabbedObjectLayer;

    public LayerMask layer;

    public LayerMask gravityObjectsLayer;
    public string layerForCustomGravityObject;

    public bool changeGravityObjectsEnabled = true;

    public List<string> ableToGrabTags = new List<string> ();

    public float rotorRotationSpeed = 20;
    public float rotorRotationSpeedOnThrowCharge = 40;

    [Space]
    [Header ("Throw Object Settings")]
    [Space]

    public float minTimeToIncreaseThrowForce = 300;
    public float increaseThrowForceSpeed = 1500;
    public float extraThorwForce = 10;
    public float maxThrowForce = 3500;

    public ForceMode powerForceMode;

    public bool useThrowObjectsLayer = true;
    public LayerMask throwObjectsLayerToCheck;

    public float throwPower;
    public ForceMode realisticForceMode;

    [Space]
    [Header ("Grab In Fixed Position Settings")]
    [Space]

    public bool grabInFixedPosition;
    public bool rotateToCameraInFixedPosition;
    public bool rotateToCameraInFreePosition;

    public float closestHoldDistanceInFixedPosition;

    [Space]
    [Header ("Remote Events Settings")]
    [Space]

    public bool useRemoteEventOnObjectsFound;
    public List<string> remoteEventNameListOnGrabObject = new List<string> ();
    public List<string> remoteEventNameListOnDropObject = new List<string> ();

    [Space]
    [Header ("Drop Settings")]
    [Space]

    public bool useForceWhenObjectDropped;
    public bool useForceWhenObjectDroppedOnFirstPerson;
    public bool useForceWhenObjectDroppedOnThirdPerson;
    public float forceWhenObjectDroppedOnFirstPerson;
    public float forceWhenObjectDroppedOnThirdPerson;

    [Space]
    [Header ("Transparency Settings")]
    [Space]

    public float alphaTransparency = 0.5f;
    public bool enableTransparency = true;
    public Shader pickableShader;

    [Space]
    [Header ("Noise Settings")]
    [Space]

    public bool launchedObjectsCanMakeNoise;
    public float minObjectSpeedToActivateNoise;

    [Space]
    [Header ("Debug")]
    [Space]

    public bool showDebugPrint;

    public bool canUseWeapon = true;

    public bool objectIsVehicle;

    public bool objectFocus;

    public bool grabbed;

    public float currentMaxDistanceHeld;
    public float currentDistanceToGrabbedObject;

    public bool chargingThrowObject;

    public GameObject objectHeld;
    public GameObject currentObjectToGrabFound;

    public bool weaponActive;

    [Space]
    [Header ("Main Events Settings")]
    [Space]

    public bool useEventOnObjectFound;
    public UnityEvent eventOnObjectFound;
    public UnityEvent eventOnObjectLost;

    public bool useEventOnObjectGrabbedDropped;
    public UnityEvent eventOnObjectGrabbed;
    public UnityEvent eventOnObjectDropped;

    public bool useEventOnLaunchObjects;
    public UnityEvent eventOnLaunchObjects;

    public bool useEventOnChangeGravityGunActiveState;
    public UnityEvent eventOnGravityGunActive;
    public UnityEvent eventOnGravityGunDeactivate;

    [Space]
    [Header ("Secondary Events Settings")]
    [Space]

    public UnityEvent secondaryFunctionEventPressDown;
    public UnityEvent secondaryFunctionEventPress;
    public UnityEvent secondaryFunctionEventPressUp;

    [Space]
    [Header ("Components")]
    [Space]

    public playerController playerControllerManager;
    public playerCamera playerCameraManager;

    public playerWeaponSystem mainPlayerWeaponSystem;

    public Transform mainCameraTransform;

    public simpleAnimationSystem animationSystem;

    public Slider powerSlider;

    public bool useRotor = true;
    public Transform rotor;
    public Transform grabZoneTransform;

    public PhysicsMaterial highFrictionMaterial;

    public enum grabMode
    {
        powers,
        realistic
    }

    Rigidbody objectHeldRigidbody;
    float holdTimer = 0;
    float timer = 0;
    RaycastHit hit;

    bool grabbedObjectTagLayerStored;
    string originalGrabbedObjectTag;
    int originalGrabbedObjectLayer;

    float orignalHoldDistance;

    Transform fixedGrabedTransform;
    RigidbodyConstraints objectHeldRigidbodyConstraints = RigidbodyConstraints.None;
    Transform objectHeldFollowTransform;

    Vector3 nextObjectHeldPosition;
    Vector3 currentObjectHeldPosition;

    GameObject currentObjectToThrow;
    Transform currentHoldTransform;
    artificialObjectGravity currentArtificialObjectGravity;
    vehicleGravityControl currentVehicleGravityControl;

    Vector2 axisValues;

    bool currentObjectWasInsideGravityRoom;

    grabbedObjectState currentGrabbedObjectState;

    float currentGrabExtraDistance;

    Vector3 throwObjectDirection;

    GameObject currentCharacterGrabbed;

    List<int> currentObjectGrabbedLayerList = new List<int> ();
    bool grabbedObjectIsRagdoll;


    bool componentsInitialized;
    Coroutine setFixedGrabbedTransformCoroutine;


    void Start ()
    {
        orignalHoldDistance = holdDistance;

        powerSlider.maxValue = maxThrowForce;
        powerSlider.value = maxThrowForce;
    }

    void Update ()
    {
        // if an object is grabbed, then move it from its original position, to the other in front of the camera
        if (objectHeld != null) {

            if (useRotor) {
                if (chargingThrowObject) {
                    rotor.Rotate (0, 0, Time.deltaTime * rotorRotationSpeedOnThrowCharge);
                } else {
                    rotor.Rotate (0, 0, Time.deltaTime * rotorRotationSpeed);
                }
            }

            //get the transform for the grabbed object to follow
            currentHoldTransform = mainCameraTransform;

            if (playerCameraManager.is2_5ViewActive ()) {
                currentHoldTransform = playerCameraManager.getCurrentLookDirection2_5d ();
                holdDistance = 0;
            }

            if (playerCameraManager.useTopDownView) {
                currentHoldTransform = playerCameraManager.getCurrentLookDirectionTopDown ();
                holdDistance = 0;
            }

            currentDistanceToGrabbedObject = GKC_Utils.distance (objectHeld.transform.position, currentHoldTransform.position);

            if (!grabbed) {
                timer += Time.deltaTime;

                if ((currentDistanceToGrabbedObject <= currentMaxDistanceHeld || grabInFixedPosition) && timer > 0.5f) {
                    grabbed = true;
                    timer = 0;
                }
            }

            //if the object is not capable to move in front of the camera, because for example is being blocked for a wall, drop it
            if (currentDistanceToGrabbedObject > (currentMaxDistanceHeld + 2) && grabbed) {
                dropObject ();
            } else {
                //if the object is a cube, a turret, or anything that can move freely, set its position in front of the camera
                if (grabInFixedPosition) {
                    nextObjectHeldPosition = fixedGrabedTransform.position + fixedGrabedTransform.forward * holdDistance;
                    currentObjectHeldPosition = objectHeld.transform.position;
                } else {
                    if (playerCameraManager.is2_5ViewActive ()) {
                        nextObjectHeldPosition = currentHoldTransform.position + mainCameraTransform.forward * holdDistance;
                    } else {
                        nextObjectHeldPosition = currentHoldTransform.position + mainCameraTransform.forward * (holdDistance + objectHeld.transform.localScale.x);
                    }
                    currentObjectHeldPosition = objectHeld.transform.position;
                }

                objectHeldRigidbody.linearVelocity = (nextObjectHeldPosition - currentObjectHeldPosition) * holdSpeed;

                if ((rotateToCameraInFixedPosition && grabInFixedPosition) || (!grabInFixedPosition && rotateToCameraInFreePosition)) {
                    objectHeld.transform.rotation = Quaternion.Slerp (objectHeld.transform.rotation, mainCameraTransform.rotation, Time.deltaTime * rotationSpeed);
                }
            }
        }

        if (weaponActive && objectHeld == null && canUseWeapon) {
            if (Physics.Raycast (mainCameraTransform.position, mainCameraTransform.TransformDirection (Vector3.forward), out hit, maxDistanceGrab, layer)) {

                if (currentObjectToGrabFound != hit.collider.gameObject) {
                    currentObjectToGrabFound = hit.collider.gameObject;

                    if (checkTypeObject (currentObjectToGrabFound)) {
                        GameObject mainObjectFound = applyDamage.getCharacterOrVehicle (currentObjectToGrabFound);

                        if (mainObjectFound == null) {
                            grabObjectParent currentGrabObjectParent = currentObjectToGrabFound.GetComponent<grabObjectParent> ();

                            if (currentGrabObjectParent != null) {
                                mainObjectFound = currentGrabObjectParent.getObjectToGrab ();
                            } else {
                                mainObjectFound = currentObjectToGrabFound;
                            }
                        }

                        if (!objectFocus) {

                            animationSystem.playForwardAnimation ();

                            objectFocus = true;

                            checkObjectFoundOrLostState ();
                        }
                    } else {
                        if (objectFocus) {

                            animationSystem.playBackwardAnimation ();

                            objectFocus = false;

                            checkObjectFoundOrLostState ();
                        }
                    }
                }
            } else {
                if (objectFocus) {

                    animationSystem.playBackwardAnimation ();

                    objectFocus = false;

                    checkObjectFoundOrLostState ();

                    currentObjectToGrabFound = null;
                }
            }
        }

        if (grabbed && objectHeld == null) {
            dropObject ();
        }
    }

    public void checkObjectFoundOrLostState ()
    {
        if (useEventOnObjectFound) {
            if (objectFocus) {
                eventOnObjectFound.Invoke ();
            } else {
                eventOnObjectLost.Invoke ();
            }
        }
    }

    public void grabObject ()
    {
        if (Physics.Raycast (mainCameraTransform.position, mainCameraTransform.TransformDirection (Vector3.forward), out hit, maxDistanceGrab, layer) && objectFocus) {
            grabCurrenObject (hit.collider.gameObject);
        }
    }

    public void grabCurrenObject (GameObject objectToGrab)
    {
        if (checkTypeObject (objectToGrab)) {

            //reset the hold distance
            holdDistance = orignalHoldDistance;

            currentGrabExtraDistance = 0;

            grabObjectProperties currentGrabObjectProperties = null;

            objectIsVehicle = applyDamage.isVehicle (objectToGrab);

            bool objectIsCharacter = applyDamage.isCharacter (objectToGrab);

            objectHeld = applyDamage.getCharacterOrVehicle (objectToGrab);

            if (objectHeld != null) {
                currentGrabObjectProperties = objectHeld.GetComponent<grabObjectProperties> ();
            }

            currentCharacterGrabbed = objectHeld;

            grabbedObjectIsRagdoll = false;

            if (objectIsVehicle || objectIsCharacter) {
                if (objectIsVehicle) {
                    Rigidbody objectToGrabRigidbody = applyDamage.applyForce (objectHeld);

                    if (objectToGrabRigidbody.isKinematic) {
                        objectHeld = null;
                        return;
                    }
                } else {
                    objectHeld = objectToGrab;

                    if (applyDamage.isCharacter (objectHeld)) {
                        Animator currentObjectAnimator = objectHeld.GetComponent<Animator> ();

                        if (currentObjectAnimator != null) {
                            objectHeld = currentObjectAnimator.GetBoneTransform (HumanBodyBones.Hips).gameObject;
                            grabbedObjectIsRagdoll = true;
                        }
                    }
                }
            } else {
                grabObjectParent currentGrabObjectParent = objectToGrab.GetComponent<grabObjectParent> ();

                if (currentGrabObjectParent != null) {
                    objectHeld = currentGrabObjectParent.getObjectToGrab ();
                } else {
                    objectHeld = objectToGrab;
                }

                currentCharacterGrabbed = objectHeld;

                currentGrabObjectProperties = objectHeld.GetComponent<grabObjectProperties> ();
            }

            objectHeldRigidbody = objectHeld.GetComponent<Rigidbody> ();

            if (objectHeldRigidbody == null) {
                grabbed = false;
                objectHeld = null;
                currentCharacterGrabbed = null;

                objectFocus = false;

                return;
            }

            if (showDebugPrint) {
                print (currentCharacterGrabbed.name);
            }

            if (useRemoteEventOnObjectsFound) {
                remoteEventSystem currentRemoteEventSystem = currentCharacterGrabbed.GetComponent<remoteEventSystem> ();

                if (currentRemoteEventSystem != null) {
                    for (int i = 0; i < remoteEventNameListOnGrabObject.Count; i++) {
                        currentRemoteEventSystem.callRemoteEvent (remoteEventNameListOnGrabObject [i]);
                    }
                }
            }

            if (currentGrabObjectProperties != null) {
                if (currentGrabObjectProperties.useExtraGrabDistance) {
                    currentGrabExtraDistance = currentGrabObjectProperties.getExtraGrabDistance ();

                    holdDistance += currentGrabExtraDistance;
                }

                currentGrabObjectProperties.checkEventsOnGrabObject ();
            }

            //get its tag, to set it again to the object, when it is dropped
            if (!objectIsVehicle) {
                grabbedObjectTagLayerStored = true;
                originalGrabbedObjectTag = objectHeld.tag;

                if (grabbedObjectIsRagdoll) {
                    currentObjectGrabbedLayerList = applyDamage.getBodyColliderLayerList (currentCharacterGrabbed);
                    applyDamage.setBodyColliderLayerList (currentCharacterGrabbed, LayerMask.NameToLayer (grabbedObjectLayer));
                } else {
                    originalGrabbedObjectLayer = objectHeld.layer;
                }

                objectHeld.tag = grabbedObjectTag;
                objectHeld.layer = LayerMask.NameToLayer (grabbedObjectLayer);
            }

            if (objectHeldRigidbody != null) {
                objectHeldRigidbody.isKinematic = false;
                objectHeldRigidbody.useGravity = false;
                objectHeldRigidbody.linearVelocity = Vector3.zero;
            }

            //if the object has its gravity modified, pause that script
            currentArtificialObjectGravity = objectHeld.GetComponent<artificialObjectGravity> ();

            if (currentArtificialObjectGravity != null) {
                currentArtificialObjectGravity.setActiveState (false);
            }

            if (currentGrabObjectProperties != null) {
                currentGrabObjectProperties.checkEventToSetPlayer (playerControllerManager.gameObject);
            }

            pickUpObject currentPickUpObject = objectHeld.GetComponent<pickUpObject> ();

            if (currentPickUpObject != null) {
                currentPickUpObject.activateObjectTrigger ();
            }

            grabObjectEventSystem currentGrabObjectEventSystem = objectHeld.GetComponent<grabObjectEventSystem> ();

            if (currentGrabObjectEventSystem != null) {
                currentGrabObjectEventSystem.callEventOnGrab ();
            }

            objectToPlaceSystem currentObjectToPlaceSystem = objectHeld.GetComponent<objectToPlaceSystem> ();

            if (currentObjectToPlaceSystem != null) {
                currentObjectToPlaceSystem.setObjectInGrabbedState (true);
            }

            currentGrabbedObjectState = null;

            if (currentGrabMode == grabMode.powers) {
                if (objectHeldRigidbody != null) {
                    objectHeldRigidbodyConstraints = objectHeldRigidbody.constraints;
                    objectHeldRigidbody.freezeRotation = true;
                }

                currentGrabbedObjectState = objectHeld.GetComponent<grabbedObjectState> ();

                if (currentGrabbedObjectState == null) {
                    currentGrabbedObjectState = objectHeld.AddComponent<grabbedObjectState> ();
                }

                if (currentGrabbedObjectState != null) {
                    currentGrabbedObjectState.setCurrentHolder (playerControllerManager.gameObject);

                    currentGrabbedObjectState.setGrabbedState (true);
                }
            } else {
                if (objectHeldRigidbody != null) {
                    if (!objectIsVehicle) {
                        objectHeldRigidbodyConstraints = objectHeldRigidbody.constraints;
                        objectHeldRigidbody.freezeRotation = true;
                    }
                }
            }

            if (objectHeld.GetComponent<pickUpObject> ()) {
                objectHeld.transform.SetParent (null);
            }

            //if the transparency is enabled, change all the color of all the materials of the object
            if (enableTransparency) {
                outlineObjectSystem currentOutlineObjectSystem = objectHeld.GetComponentInChildren<outlineObjectSystem> ();

                if (currentOutlineObjectSystem != null) {
                    currentOutlineObjectSystem.setTransparencyState (true, pickableShader, alphaTransparency);
                }
            }

            powerSlider.value = 0;
            powerSlider.maxValue = maxThrowForce;

            holdTimer = 0;

            if (fixedGrabedTransform == null) {
                GameObject fixedPositionObject = new GameObject ();
                fixedGrabedTransform = fixedPositionObject.transform;
                fixedGrabedTransform.name = "Fixed Grabbed Transform";
            }

            if (grabInFixedPosition) {
                fixedGrabedTransform.SetParent (mainCameraTransform);
                fixedGrabedTransform.transform.position = objectHeld.transform.position;
                fixedGrabedTransform.transform.rotation = mainCameraTransform.rotation;

                currentMaxDistanceHeld = GKC_Utils.distance (objectHeld.transform.position, mainCameraTransform.position) + holdDistance;
                holdDistance = 0;
            } else {
                currentMaxDistanceHeld = maxDistanceHeld + (holdDistance + orignalHoldDistance) + 0.5f;
            }

            currentObjectWasInsideGravityRoom = false;
        }
    }

    //check if the object detected by the raycast is in the able to grab list or is a vehicle
    public bool checkTypeObject (GameObject objectToCheck)
    {
        if (ableToGrabTags.Contains (objectToCheck.tag)) {
            return true;
        }

        if (applyDamage.isVehicle (objectToCheck)) {
            return true;
        }

        characterDamageReceiver currentCharacterDamageReceiver = objectToCheck.GetComponent<characterDamageReceiver> ();

        if (currentCharacterDamageReceiver != null) {
            if (ableToGrabTags.Contains (currentCharacterDamageReceiver.character.tag)) {
                return true;
            }
        }

        grabObjectParent currentGrabObjectParent = objectToCheck.GetComponent<grabObjectParent> ();

        if (currentGrabObjectParent != null) {
            return true;
        }

        return false;
    }

    //drop the object
    public void dropObject ()
    {
        if (useThrowObjectsLayer) {
            throwObjectDirection = Vector3.zero;

            if (objectHeld != null) {
                bool surfaceLocated = false;

                Vector3 raycastPosition = Vector3.zero;

                raycastPosition = objectHeld.transform.position;

                Vector3 raycastDirection = mainCameraTransform.TransformDirection (Vector3.forward);

                if (Physics.Raycast (raycastPosition, raycastDirection, out hit, Mathf.Infinity, throwObjectsLayerToCheck)) {

                    if (hit.collider.gameObject != objectHeld && hit.collider.gameObject != playerControllerManager.gameObject) {
                        Vector3 heading = hit.point - objectHeld.transform.position;

                        float distance = heading.magnitude;

                        throwObjectDirection = heading / distance;
                        throwObjectDirection.Normalize ();

                        surfaceLocated = true;

                        //						print ("new surface");
                    } else {
                        raycastPosition = hit.point;

                        if (Physics.Raycast (raycastPosition, raycastDirection, out hit, Mathf.Infinity, throwObjectsLayerToCheck)) {

                            if (hit.collider.gameObject != objectHeld && hit.collider.gameObject != playerControllerManager.gameObject) {
                                Vector3 heading = hit.point - objectHeld.transform.position;

                                float distance = heading.magnitude;

                                throwObjectDirection = heading / distance;
                                throwObjectDirection.Normalize ();

                                surfaceLocated = true;

                                //								print ("located new one");
                            }
                        }
                    }
                }

                if (!surfaceLocated) {
                    //					print ("not located");
                    throwObjectDirection = mainCameraTransform.forward;
                }
            }
        }

        if (objectHeld != null) {
            //set the tag of the object that had before grab it, and if the object has its own gravity, enable again
            if (grabbedObjectTagLayerStored) {
                objectHeld.tag = originalGrabbedObjectTag;

                if (grabbedObjectIsRagdoll && currentObjectGrabbedLayerList.Count > 0) {
                    applyDamage.setBodyColliderLayerList (currentCharacterGrabbed, currentObjectGrabbedLayerList);
                } else {
                    objectHeld.layer = originalGrabbedObjectLayer;
                }

                grabbedObjectIsRagdoll = false;
                currentObjectGrabbedLayerList.Clear ();

                grabbedObjectTagLayerStored = false;
            }

            currentArtificialObjectGravity = objectHeld.GetComponent<artificialObjectGravity> ();

            if (currentArtificialObjectGravity != null) {
                currentArtificialObjectGravity.setActiveState (true);
            }

            if (objectHeldRigidbody != null) {
                if (!objectIsVehicle && currentArtificialObjectGravity == null) {
                    objectHeldRigidbody.useGravity = true;
                }

                objectHeldRigidbody.freezeRotation = false;

                if (objectHeldRigidbodyConstraints != RigidbodyConstraints.None) {
                    objectHeldRigidbody.constraints = objectHeldRigidbodyConstraints;
                    objectHeldRigidbodyConstraints = RigidbodyConstraints.None;
                }
            }

            grabObjectProperties currentGrabObjectProperties = objectHeld.GetComponent<grabObjectProperties> ();

            if (currentGrabObjectProperties != null) {
                currentGrabObjectProperties.checkEventsOnDropObject ();
            }

            if (enableTransparency) {
                //set the normal shader of the object 
                outlineObjectSystem currentOutlineObjectSystem = objectHeld.GetComponentInChildren<outlineObjectSystem> ();

                if (currentOutlineObjectSystem != null) {
                    currentOutlineObjectSystem.setTransparencyState (false, null, 0);
                }
            }

            if (useRemoteEventOnObjectsFound) {
                remoteEventSystem currentRemoteEventSystem = currentCharacterGrabbed.GetComponent<remoteEventSystem> ();

                if (currentRemoteEventSystem != null) {
                    for (int i = 0; i < remoteEventNameListOnDropObject.Count; i++) {
                        if (showDebugPrint) {
                            print (remoteEventNameListOnDropObject [i]);
                        }

                        currentRemoteEventSystem.callRemoteEvent (remoteEventNameListOnDropObject [i]);
                    }
                }
            }

            grabbedObjectState currentGrabbedObjectState = objectHeld.GetComponent<grabbedObjectState> ();

            if (currentGrabbedObjectState != null) {
                currentObjectWasInsideGravityRoom = currentGrabbedObjectState.isInsideZeroGravityRoom ();

                currentGrabbedObjectState.checkGravityRoomState ();

                currentGrabbedObjectState.setGrabbedState (false);

                if (!currentObjectWasInsideGravityRoom) {
                    currentGrabbedObjectState.removeGrabbedObjectComponent ();
                }
            }

            objectToPlaceSystem currentObjectToPlaceSystem = objectHeld.GetComponent<objectToPlaceSystem> ();

            if (currentObjectToPlaceSystem != null) {
                currentObjectToPlaceSystem.setObjectInGrabbedState (false);
            }

            grabObjectEventSystem currentGrabObjectEventSystem = objectHeld.GetComponent<grabObjectEventSystem> ();

            if (currentGrabObjectEventSystem != null) {
                currentGrabObjectEventSystem.callEventOnDrop ();
            }
        }

        grabbed = false;
        objectHeld = null;
        objectHeldRigidbody = null;
        currentCharacterGrabbed = null;

        currentObjectToGrabFound = null;

        animationSystem.playBackwardAnimation ();

        objectFocus = false;

        if (showDebugPrint) {
            print ("drop object");
        }
    }

    public void checkJointsInObject (GameObject objectToThrow, float force)
    {
        CharacterJoint currentCharacterJoint = objectToThrow.GetComponent<CharacterJoint> ();

        if (currentCharacterJoint != null) {
            checkJointsInObject (currentCharacterJoint.connectedBody.gameObject, force);
        } else {
            addForceToThrownRigidbody (objectToThrow, force);
        }
    }

    public void addForceToThrownRigidbody (GameObject objectToThrow, float force)
    {
        Component [] components = objectToThrow.GetComponentsInChildren (typeof (Rigidbody));
        foreach (Rigidbody child in components) {
            if (!child.isKinematic && child.GetComponent<Collider> ()) {
                Vector3 forceDirection = mainCameraTransform.forward;

                if (useThrowObjectsLayer) {
                    if (showDebugPrint) {
                        print (throwObjectDirection + " " + forceDirection);
                    }

                    if (throwObjectDirection != Vector3.zero) {
                        forceDirection = throwObjectDirection;
                    }
                }

                forceDirection *= force * child.mass;

                child.AddForce (forceDirection, powerForceMode);

                checkIfEnableNoiseOnCollision (objectToThrow, forceDirection.magnitude);
            }
        }
    }

    public void throwRealisticGrabbedObject ()
    {
        Rigidbody currentRigidbody = objectHeld.GetComponent<Rigidbody> ();

        dropObject ();

        if (currentRigidbody != null) {
            Vector3 forceDirection = mainCameraTransform.forward * throwPower * currentRigidbody.mass;
            currentRigidbody.AddForce (forceDirection, realisticForceMode);

            checkIfEnableNoiseOnCollision (objectHeld, forceDirection.magnitude);
        }
    }

    public void resetFixedGrabedTransformPosition ()
    {
        stopResetFixedGrabedTransformPositionCoroutine ();

        setFixedGrabbedTransformCoroutine = StartCoroutine (resetFixedGrabedTransformPositionCoroutine ());
    }

    public void stopResetFixedGrabedTransformPositionCoroutine ()
    {
        if (setFixedGrabbedTransformCoroutine != null) {
            StopCoroutine (setFixedGrabbedTransformCoroutine);
        }
    }

    IEnumerator resetFixedGrabedTransformPositionCoroutine ()
    {
        Vector3 targetPosition = Vector3.forward * (orignalHoldDistance + currentGrabExtraDistance);

        float dist = GKC_Utils.distance (fixedGrabedTransform.position, mainCameraTransform.position + targetPosition);
        float duration = dist / 10;
        float t = 0;
        bool targetReached = false;

        float timer = 0;

        while (!targetReached && t < 1 && fixedGrabedTransform.localPosition != targetPosition) {
            t += Time.deltaTime / duration;
            fixedGrabedTransform.localPosition = Vector3.Lerp (fixedGrabedTransform.localPosition, targetPosition, t);

            timer += Time.deltaTime;

            if (GKC_Utils.distance (fixedGrabedTransform.localPosition, targetPosition) < 0.01f || timer > duration) {
                targetReached = true;
            }

            yield return null;
        }
    }

    public void checkIfDropObject (GameObject objectToCheck)
    {
        if (objectHeld == objectToCheck) {
            dropObject ();
        }
    }

    public void setWeaponActiveState (bool state)
    {
        weaponActive = state;

        initializeComponents ();

        dropObject ();

        if (useEventOnChangeGravityGunActiveState) {
            if (weaponActive) {
                eventOnGravityGunActive.Invoke ();
            } else {
                eventOnGravityGunDeactivate.Invoke ();
            }
        }
    }

    public GameObject getGrabbedObject ()
    {
        return objectHeld;
    }

    public bool isGrabbedObject ()
    {
        return objectHeld != null;
    }

    public void checkIfEnableNoiseOnCollision (GameObject objectToCheck, float launchSpeed)
    {
        if (launchedObjectsCanMakeNoise && launchSpeed >= minObjectSpeedToActivateNoise) {
            noiseSystem currentNoiseSystem = objectToCheck.GetComponent<noiseSystem> ();

            if (currentNoiseSystem != null) {
                currentNoiseSystem.setUseNoiseState (true);
            }
        }
    }

    public void addForceToLaunchObject ()
    {
        if (currentGrabMode == grabMode.powers) {
            if (holdTimer < maxThrowForce) {
                holdTimer += Time.deltaTime * increaseThrowForceSpeed;

                powerSlider.value += Time.deltaTime * increaseThrowForceSpeed;

                chargingThrowObject = true;
            }
        }
    }

    public void launchObject ()
    {
        powerSlider.value = 0;

        currentObjectToThrow = objectHeld;

        Rigidbody currentRigidbody = currentObjectToThrow.GetComponent<Rigidbody> ();

        dropObject ();

        bool canAddForceToObjectDropped = false;

        if (currentRigidbody != null) {
            //if the button has been pressed and released quickly, drop the object, else addforce to its rigidbody
            if (!objectIsVehicle && !currentObjectWasInsideGravityRoom) {
                currentRigidbody.useGravity = true;
            }

            if (currentGrabMode == grabMode.powers) {
                if (holdTimer > minTimeToIncreaseThrowForce) {
                    launchedObjects currentLaunchedObjects = currentObjectToThrow.GetComponent<launchedObjects> ();

                    if (currentLaunchedObjects == null) {
                        currentLaunchedObjects = currentObjectToThrow.AddComponent<launchedObjects> ();
                    }

                    currentLaunchedObjects.setCurrentPlayer (gameObject);

                    if (currentObjectToThrow.GetComponent<CharacterJoint> ()) {
                        checkJointsInObject (currentObjectToThrow, holdTimer);
                    } else {
                        holdTimer += extraThorwForce;
                        addForceToThrownRigidbody (currentObjectToThrow, holdTimer);
                    }

                    if (useEventOnLaunchObjects) {
                        eventOnLaunchObjects.Invoke ();
                    }
                } else {
                    canAddForceToObjectDropped = true;
                }
            } else {
                canAddForceToObjectDropped = true;
            }
        }

        if (canAddForceToObjectDropped) {
            if (useForceWhenObjectDropped) {
                if (useForceWhenObjectDroppedOnFirstPerson && playerCameraManager.isFirstPersonActive ()) {
                    addForceToThrownRigidbody (currentObjectToThrow, forceWhenObjectDroppedOnFirstPerson);
                } else if (useForceWhenObjectDroppedOnThirdPerson && !playerCameraManager.isFirstPersonActive ()) {
                    addForceToThrownRigidbody (currentObjectToThrow, forceWhenObjectDroppedOnThirdPerson);
                }
            }
        }

        chargingThrowObject = false;
    }

    public bool isCurrentObjectToGrabFound (GameObject objectToCheck)
    {
        if (currentObjectToGrabFound == objectToCheck) {
            return true;
        }

        return false;
    }

    //CALL INPUT FUNCTIONS
    public void inputGrabObject ()
    {
        //if the player is in aim mode, grab an object
        if (!playerControllerManager.isUsingDevice () && weaponActive && !objectHeld && canUseWeapon) {
            grabObject ();
        }
    }

    public void inputHoldToLaunchObject ()
    {
        //if the drop button is being holding, add force to the final velocity of the drooped object
        if (grabbed && weaponActive) {
            addForceToLaunchObject ();
        }
    }

    public void inputReleaseToLaunchObject ()
    {
        //when the button is released, check the amount of strength accumulated
        if (weaponActive) {
            if (grabbed) {
                launchObject ();

                if (useEventOnObjectGrabbedDropped) {
                    eventOnObjectDropped.Invoke ();
                }
            } else {
                if (objectHeld) {
                    if (useEventOnObjectGrabbedDropped) {
                        eventOnObjectGrabbed.Invoke ();
                    }
                }
            }
        }
    }

    public void inputResetFixedGrabedTransformPosition ()
    {
        if (objectHeld != null && weaponActive) {
            resetFixedGrabedTransformPosition ();
        }
    }

    public void activateSecondaryFunctionPressDown ()
    {
        if (weaponActive) {
            secondaryFunctionEventPressDown.Invoke ();
        }
    }

    public void activateSecondaryFunctionPress ()
    {
        if (weaponActive) {
            secondaryFunctionEventPress.Invoke ();
        }
    }

    public void activateSecondaryFunctionPressUp ()
    {
        if (weaponActive) {
            secondaryFunctionEventPressUp.Invoke ();
        }
    }

    public void setNewGravityToGrabbedObject ()
    {
        if (changeGravityObjectsEnabled) {
            GameObject grabbedObject = getGrabbedObject ();

            if (grabbedObject.GetComponent<Rigidbody> ()) {
                dropObject ();

                //if the current object grabbed is a vehicle, enable its own gravity control component
                currentVehicleGravityControl = grabbedObject.GetComponent<vehicleGravityControl> ();

                if (currentVehicleGravityControl != null) {
                    currentVehicleGravityControl.activateGravityPower (mainCameraTransform.TransformDirection (Vector3.forward),
                        mainCameraTransform.TransformDirection (Vector3.right));
                } else {
                    //else, it is a regular object
                    //change the layer, because the object will use a raycast to check the new normal when a collision happens
                    grabbedObject.layer = LayerMask.NameToLayer (layerForCustomGravityObject);

                    //if the object has a regular gravity, attach the scrip and set its values
                    currentArtificialObjectGravity = grabbedObject.GetComponent<artificialObjectGravity> ();

                    if (currentArtificialObjectGravity == null) {
                        currentArtificialObjectGravity = grabbedObject.AddComponent<artificialObjectGravity> ();
                    }

                    currentArtificialObjectGravity.enableGravity (gravityObjectsLayer, highFrictionMaterial, mainCameraTransform.forward);
                }
            }
        }
    }

    public bool isCarryingObject ()
    {
        return grabbed;
    }

    public void setCanUseWeaponState (bool state)
    {
        canUseWeapon = state;

        initializeComponents ();

        if (!canUseWeapon) {
            if (objectHeld != null) {
                dropObject ();
            }

            if (objectFocus) {
                animationSystem.playBackwardAnimation ();

                objectFocus = false;

                checkObjectFoundOrLostState ();
            }
        }
    }

    public void rotateRotor (float newSpeed)
    {
        if (useRotor) {
            rotor.Rotate (0, 0, Time.deltaTime * newSpeed);
        }
    }

    void initializeComponents ()
    {
        if (componentsInitialized) {
            return;
        }

        if (mainPlayerWeaponSystem != null) {
            GameObject playerControllerGameObject = mainPlayerWeaponSystem.getPlayerWeaponsManger ().gameObject;

            playerComponentsManager mainPlayerComponentsManager = playerControllerGameObject.GetComponent<playerComponentsManager> ();

            if (mainPlayerComponentsManager != null) {
                playerControllerManager = mainPlayerComponentsManager.getPlayerController ();

                playerCameraManager = mainPlayerComponentsManager.getPlayerCamera ();

                mainCameraTransform = playerCameraManager.getCameraTransform ();
            }
        }

        componentsInitialized = true;
    }
}